# 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

__all__ = [
    'GatewayBackendSpecArgs',
    'GatewayBackendSpecArgsDict',
    'GatewayCustomLogArgs',
    'GatewayCustomLogArgsDict',
    'GatewayCustomLogCustomVariableArgs',
    'GatewayCustomLogCustomVariableArgsDict',
    'GatewayCustomLogRequestHeaderArgs',
    'GatewayCustomLogRequestHeaderArgsDict',
    'GatewayCustomLogResponseHeaderArgs',
    'GatewayCustomLogResponseHeaderArgsDict',
    'GatewayEventArgs',
    'GatewayEventArgsDict',
    'GatewayLogSpecArgs',
    'GatewayLogSpecArgsDict',
    'GatewayMonitorSpecArgs',
    'GatewayMonitorSpecArgsDict',
    'GatewayNetworkSpecArgs',
    'GatewayNetworkSpecArgsDict',
    'GatewayNetworkSpecSubnetArgs',
    'GatewayNetworkSpecSubnetArgsDict',
    'GatewayResourceSpecArgs',
    'GatewayResourceSpecArgsDict',
    'GatewayResourceSpecNetworkTypeArgs',
    'GatewayResourceSpecNetworkTypeArgsDict',
    'GatewayServiceAuthSpecArgs',
    'GatewayServiceAuthSpecArgsDict',
    'GatewayServiceCustomDomainArgs',
    'GatewayServiceCustomDomainArgsDict',
    'GatewayServiceDomainArgs',
    'GatewayServiceDomainArgsDict',
    'GatewayServiceDomainSpecArgs',
    'GatewayServiceDomainSpecArgsDict',
    'GatewayTraceSpecArgs',
    'GatewayTraceSpecArgsDict',
    'GatewayTraceSpecApmTraceSpecArgs',
    'GatewayTraceSpecApmTraceSpecArgsDict',
    'GatewayTraceSpecTlsTraceSpecArgs',
    'GatewayTraceSpecTlsTraceSpecArgsDict',
    'UpstreamBackendTargetArgs',
    'UpstreamBackendTargetArgsDict',
    'UpstreamCircuitBreakingSettingsArgs',
    'UpstreamCircuitBreakingSettingsArgsDict',
    'UpstreamLoadBalancerSettingsArgs',
    'UpstreamLoadBalancerSettingsArgsDict',
    'UpstreamLoadBalancerSettingsConsistentHashLbArgs',
    'UpstreamLoadBalancerSettingsConsistentHashLbArgsDict',
    'UpstreamLoadBalancerSettingsConsistentHashLbHttpCookieArgs',
    'UpstreamLoadBalancerSettingsConsistentHashLbHttpCookieArgsDict',
    'UpstreamSourceIngressSettingsArgs',
    'UpstreamSourceIngressSettingsArgsDict',
    'UpstreamSourceSourceSpecArgs',
    'UpstreamSourceSourceSpecArgsDict',
    'UpstreamSourceSourceSpecK8SSourceArgs',
    'UpstreamSourceSourceSpecK8SSourceArgsDict',
    'UpstreamSourceSourceSpecNacosSourceArgs',
    'UpstreamSourceSourceSpecNacosSourceArgsDict',
    'UpstreamSourceSourceSpecNacosSourceAuthConfigArgs',
    'UpstreamSourceSourceSpecNacosSourceAuthConfigArgsDict',
    'UpstreamSourceSourceSpecNacosSourceAuthConfigBasicArgs',
    'UpstreamSourceSourceSpecNacosSourceAuthConfigBasicArgsDict',
    'UpstreamTlsSettingsArgs',
    'UpstreamTlsSettingsArgsDict',
    'UpstreamUpstreamSpecArgs',
    'UpstreamUpstreamSpecArgsDict',
    'UpstreamUpstreamSpecAiProviderArgs',
    'UpstreamUpstreamSpecAiProviderArgsDict',
    'UpstreamUpstreamSpecAiProviderCustomModelServiceArgs',
    'UpstreamUpstreamSpecAiProviderCustomModelServiceArgsDict',
    'UpstreamUpstreamSpecEcsInstanceArgs',
    'UpstreamUpstreamSpecEcsInstanceArgsDict',
    'UpstreamUpstreamSpecK8SServiceArgs',
    'UpstreamUpstreamSpecK8SServiceArgsDict',
    'UpstreamUpstreamSpecNacosServiceArgs',
    'UpstreamUpstreamSpecNacosServiceArgsDict',
    'UpstreamUpstreamSpecVeFaasArgs',
    'UpstreamUpstreamSpecVeFaasArgsDict',
    'UpstreamVersionDetailArgs',
    'UpstreamVersionDetailArgsDict',
    'UpstreamVersionDetailLabelArgs',
    'UpstreamVersionDetailLabelArgsDict',
]

MYPY = False

if not MYPY:
    class GatewayBackendSpecArgsDict(TypedDict):
        is_vke_with_flannel_cni_supported: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否支持VKE Flannel CNI。
        """
        vke_pod_cidr: NotRequired[pulumi.Input[builtins.str]]
        """
        VKE Pod CIDR。
        """
elif False:
    GatewayBackendSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayBackendSpecArgs:
    def __init__(__self__, *,
                 is_vke_with_flannel_cni_supported: Optional[pulumi.Input[builtins.bool]] = None,
                 vke_pod_cidr: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] is_vke_with_flannel_cni_supported: 是否支持VKE Flannel CNI。
        :param pulumi.Input[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[pulumi.Input[builtins.bool]]:
        """
        是否支持VKE Flannel CNI。
        """
        return pulumi.get(self, "is_vke_with_flannel_cni_supported")

    @is_vke_with_flannel_cni_supported.setter
    def is_vke_with_flannel_cni_supported(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_vke_with_flannel_cni_supported", value)

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

    @vke_pod_cidr.setter
    def vke_pod_cidr(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "vke_pod_cidr", value)


if not MYPY:
    class GatewayCustomLogArgsDict(TypedDict):
        custom_variables: NotRequired[pulumi.Input[Sequence[pulumi.Input['GatewayCustomLogCustomVariableArgsDict']]]]
        request_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['GatewayCustomLogRequestHeaderArgsDict']]]]
        response_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['GatewayCustomLogResponseHeaderArgsDict']]]]
elif False:
    GatewayCustomLogArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayCustomLogArgs:
    def __init__(__self__, *,
                 custom_variables: Optional[pulumi.Input[Sequence[pulumi.Input['GatewayCustomLogCustomVariableArgs']]]] = None,
                 request_headers: Optional[pulumi.Input[Sequence[pulumi.Input['GatewayCustomLogRequestHeaderArgs']]]] = None,
                 response_headers: Optional[pulumi.Input[Sequence[pulumi.Input['GatewayCustomLogResponseHeaderArgs']]]] = 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[pulumi.Input[Sequence[pulumi.Input['GatewayCustomLogCustomVariableArgs']]]]:
        return pulumi.get(self, "custom_variables")

    @custom_variables.setter
    def custom_variables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GatewayCustomLogCustomVariableArgs']]]]):
        pulumi.set(self, "custom_variables", value)

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

    @request_headers.setter
    def request_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GatewayCustomLogRequestHeaderArgs']]]]):
        pulumi.set(self, "request_headers", value)

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

    @response_headers.setter
    def response_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GatewayCustomLogResponseHeaderArgs']]]]):
        pulumi.set(self, "response_headers", value)


if not MYPY:
    class GatewayCustomLogCustomVariableArgsDict(TypedDict):
        aliases_in_log: NotRequired[pulumi.Input[builtins.str]]
        """
        字段别名。
        """
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        请求头键。
        """
elif False:
    GatewayCustomLogCustomVariableArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayCustomLogCustomVariableArgs:
    def __init__(__self__, *,
                 aliases_in_log: Optional[pulumi.Input[builtins.str]] = None,
                 key: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] aliases_in_log: 字段别名。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        字段别名。
        """
        return pulumi.get(self, "aliases_in_log")

    @aliases_in_log.setter
    def aliases_in_log(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "aliases_in_log", value)

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

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)


if not MYPY:
    class GatewayCustomLogRequestHeaderArgsDict(TypedDict):
        aliases_in_log: NotRequired[pulumi.Input[builtins.str]]
        """
        字段别名。
        """
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        请求头键。
        """
elif False:
    GatewayCustomLogRequestHeaderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayCustomLogRequestHeaderArgs:
    def __init__(__self__, *,
                 aliases_in_log: Optional[pulumi.Input[builtins.str]] = None,
                 key: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] aliases_in_log: 字段别名。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        字段别名。
        """
        return pulumi.get(self, "aliases_in_log")

    @aliases_in_log.setter
    def aliases_in_log(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "aliases_in_log", value)

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

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)


if not MYPY:
    class GatewayCustomLogResponseHeaderArgsDict(TypedDict):
        aliases_in_log: NotRequired[pulumi.Input[builtins.str]]
        """
        字段别名。
        """
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        请求头键。
        """
elif False:
    GatewayCustomLogResponseHeaderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayCustomLogResponseHeaderArgs:
    def __init__(__self__, *,
                 aliases_in_log: Optional[pulumi.Input[builtins.str]] = None,
                 key: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] aliases_in_log: 字段别名。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        字段别名。
        """
        return pulumi.get(self, "aliases_in_log")

    @aliases_in_log.setter
    def aliases_in_log(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "aliases_in_log", value)

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

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)


if not MYPY:
    class GatewayEventArgsDict(TypedDict):
        code: NotRequired[pulumi.Input[builtins.str]]
        """
        事件代码。
        """
        created_time: NotRequired[pulumi.Input[builtins.str]]
        """
        事件创建时间。
        """
        data: NotRequired[pulumi.Input[builtins.str]]
        """
        附带信息。
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        事件描述。
        """
elif False:
    GatewayEventArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayEventArgs:
    def __init__(__self__, *,
                 code: Optional[pulumi.Input[builtins.str]] = None,
                 created_time: Optional[pulumi.Input[builtins.str]] = None,
                 data: Optional[pulumi.Input[builtins.str]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] code: 事件代码。
        :param pulumi.Input[builtins.str] created_time: 事件创建时间。
        :param pulumi.Input[builtins.str] data: 附带信息。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        事件代码。
        """
        return pulumi.get(self, "code")

    @code.setter
    def code(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "code", value)

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

    @created_time.setter
    def created_time(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "created_time", value)

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

    @data.setter
    def data(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "data", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "description", value)


if not MYPY:
    class GatewayLogSpecArgsDict(TypedDict):
        enable: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启日志服务。
        """
        project_id: NotRequired[pulumi.Input[builtins.str]]
        """
        日志项目ID。
        """
        topic_id: NotRequired[pulumi.Input[builtins.str]]
        """
        日志主题ID。ProjectId 指定项目里面的日志主题。
        """
elif False:
    GatewayLogSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayLogSpecArgs:
    def __init__(__self__, *,
                 enable: Optional[pulumi.Input[builtins.bool]] = None,
                 project_id: Optional[pulumi.Input[builtins.str]] = None,
                 topic_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] enable: 是否开启日志服务。
        :param pulumi.Input[builtins.str] project_id: 日志项目ID。
        :param pulumi.Input[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[pulumi.Input[builtins.bool]]:
        """
        是否开启日志服务。
        """
        return pulumi.get(self, "enable")

    @enable.setter
    def enable(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable", value)

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

    @project_id.setter
    def project_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "project_id", value)

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

    @topic_id.setter
    def topic_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "topic_id", value)


if not MYPY:
    class GatewayMonitorSpecArgsDict(TypedDict):
        enable: NotRequired[pulumi.Input[builtins.bool]]
        """
        托管Prometheus（VMP）服务。
        """
        workspace_id: NotRequired[pulumi.Input[builtins.str]]
        """
        Prometheus工作区ID。
        """
elif False:
    GatewayMonitorSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayMonitorSpecArgs:
    def __init__(__self__, *,
                 enable: Optional[pulumi.Input[builtins.bool]] = None,
                 workspace_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] enable: 托管Prometheus（VMP）服务。
        :param pulumi.Input[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[pulumi.Input[builtins.bool]]:
        """
        托管Prometheus（VMP）服务。
        """
        return pulumi.get(self, "enable")

    @enable.setter
    def enable(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable", value)

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

    @workspace_id.setter
    def workspace_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "workspace_id", value)


if not MYPY:
    class GatewayNetworkSpecArgsDict(TypedDict):
        subnets: NotRequired[pulumi.Input[Sequence[pulumi.Input['GatewayNetworkSpecSubnetArgsDict']]]]
        vpc_id: NotRequired[pulumi.Input[builtins.str]]
        """
        VPC ID。
        """
        vpc_name: NotRequired[pulumi.Input[builtins.str]]
        """
        VPC名称。
        """
elif False:
    GatewayNetworkSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayNetworkSpecArgs:
    def __init__(__self__, *,
                 subnets: Optional[pulumi.Input[Sequence[pulumi.Input['GatewayNetworkSpecSubnetArgs']]]] = None,
                 vpc_id: Optional[pulumi.Input[builtins.str]] = None,
                 vpc_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] vpc_id: VPC ID。
        :param pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input['GatewayNetworkSpecSubnetArgs']]]]:
        return pulumi.get(self, "subnets")

    @subnets.setter
    def subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GatewayNetworkSpecSubnetArgs']]]]):
        pulumi.set(self, "subnets", value)

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

    @vpc_id.setter
    def vpc_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "vpc_id", value)

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

    @vpc_name.setter
    def vpc_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "vpc_name", value)


if not MYPY:
    class GatewayNetworkSpecSubnetArgsDict(TypedDict):
        az: NotRequired[pulumi.Input[builtins.str]]
        """
        可用区。
        """
        subnet_id: NotRequired[pulumi.Input[builtins.str]]
        """
        子网ID。
        """
        subnet_name: NotRequired[pulumi.Input[builtins.str]]
        """
        子网名称。
        """
elif False:
    GatewayNetworkSpecSubnetArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayNetworkSpecSubnetArgs:
    def __init__(__self__, *,
                 az: Optional[pulumi.Input[builtins.str]] = None,
                 subnet_id: Optional[pulumi.Input[builtins.str]] = None,
                 subnet_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] az: 可用区。
        :param pulumi.Input[builtins.str] subnet_id: 子网ID。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        可用区。
        """
        return pulumi.get(self, "az")

    @az.setter
    def az(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "az", value)

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

    @subnet_id.setter
    def subnet_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "subnet_id", value)

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

    @subnet_name.setter
    def subnet_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "subnet_name", value)


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

@pulumi.input_type
class GatewayResourceSpecArgs:
    def __init__(__self__, *,
                 clb_spec_code: Optional[pulumi.Input[builtins.str]] = None,
                 instance_spec_code: Optional[pulumi.Input[builtins.str]] = None,
                 network_type: Optional[pulumi.Input['GatewayResourceSpecNetworkTypeArgs']] = None,
                 public_network_bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 public_network_billing_type: Optional[pulumi.Input[builtins.str]] = None,
                 replicas: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[builtins.str] instance_spec_code: 节点规格，取值：1c2g。2c4g。4c8g。8c16g。
        :param pulumi.Input['GatewayResourceSpecNetworkTypeArgs'] network_type: 网络类型。默认值为开启公网，开启私网。
        :param pulumi.Input[builtins.int] public_network_bandwidth: 公网带宽上限，该字段仅用于“按带宽上限收费”公网网络计费方式。单位为Mbps。取值限制为0~500。默认值为0。
        :param pulumi.Input[builtins.str] public_network_billing_type: 公网网络计费方式，取值：traffic：按实际流量计费。bandwidth：按带宽上限计费。
        :param pulumi.Input[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[pulumi.Input[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")

    @clb_spec_code.setter
    def clb_spec_code(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "clb_spec_code", value)

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

    @instance_spec_code.setter
    def instance_spec_code(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "instance_spec_code", value)

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

    @network_type.setter
    def network_type(self, value: Optional[pulumi.Input['GatewayResourceSpecNetworkTypeArgs']]):
        pulumi.set(self, "network_type", value)

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

    @public_network_bandwidth.setter
    def public_network_bandwidth(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "public_network_bandwidth", value)

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

    @public_network_billing_type.setter
    def public_network_billing_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "public_network_billing_type", value)

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

    @replicas.setter
    def replicas(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "replicas", value)


if not MYPY:
    class GatewayResourceSpecNetworkTypeArgsDict(TypedDict):
        enable_private_network: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否启用私网。
        """
        enable_public_network: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否启用公网。
        """
elif False:
    GatewayResourceSpecNetworkTypeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayResourceSpecNetworkTypeArgs:
    def __init__(__self__, *,
                 enable_private_network: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_public_network: Optional[pulumi.Input[builtins.bool]] = None):
        """
        :param pulumi.Input[builtins.bool] enable_private_network: 是否启用私网。
        :param pulumi.Input[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[pulumi.Input[builtins.bool]]:
        """
        是否启用私网。
        """
        return pulumi.get(self, "enable_private_network")

    @enable_private_network.setter
    def enable_private_network(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable_private_network", value)

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

    @enable_public_network.setter
    def enable_public_network(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable_public_network", value)


if not MYPY:
    class GatewayServiceAuthSpecArgsDict(TypedDict):
        enable: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启认证。
        """
elif False:
    GatewayServiceAuthSpecArgsDict: TypeAlias = Mapping[str, Any]

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

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

    @enable.setter
    def enable(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable", value)


if not MYPY:
    class GatewayServiceCustomDomainArgsDict(TypedDict):
        domain: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义域名。
        """
        domain_id: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义域名ID。
        """
elif False:
    GatewayServiceCustomDomainArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayServiceCustomDomainArgs:
    def __init__(__self__, *,
                 domain: Optional[pulumi.Input[builtins.str]] = None,
                 domain_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] domain: 自定义域名。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        自定义域名。
        """
        return pulumi.get(self, "domain")

    @domain.setter
    def domain(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "domain", value)

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

    @domain_id.setter
    def domain_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "domain_id", value)


if not MYPY:
    class GatewayServiceDomainArgsDict(TypedDict):
        domain: NotRequired[pulumi.Input[builtins.str]]
        """
        域名。
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        域名类型。取值：public：公网。private：私网。
        """
elif False:
    GatewayServiceDomainArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayServiceDomainArgs:
    def __init__(__self__, *,
                 domain: Optional[pulumi.Input[builtins.str]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] domain: 域名。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        域名。
        """
        return pulumi.get(self, "domain")

    @domain.setter
    def domain(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "domain", value)

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

    @type.setter
    def type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class GatewayServiceDomainSpecArgsDict(TypedDict):
        enable_public_resolution: NotRequired[pulumi.Input[builtins.bool]]
        """
        开启私网域名公网解析。
        """
elif False:
    GatewayServiceDomainSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayServiceDomainSpecArgs:
    def __init__(__self__, *,
                 enable_public_resolution: Optional[pulumi.Input[builtins.bool]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[builtins.bool]]:
        """
        开启私网域名公网解析。
        """
        return pulumi.get(self, "enable_public_resolution")

    @enable_public_resolution.setter
    def enable_public_resolution(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable_public_resolution", value)


if not MYPY:
    class GatewayTraceSpecArgsDict(TypedDict):
        apm_trace_spec: NotRequired[pulumi.Input['GatewayTraceSpecApmTraceSpecArgsDict']]
        """
        应用性能监控全链路版链路追踪配置。
        """
        enable: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否启用链路追踪。
        """
        tls_trace_spec: NotRequired[pulumi.Input['GatewayTraceSpecTlsTraceSpecArgsDict']]
        """
        链路追踪配置信息。
        """
        trace_type: NotRequired[pulumi.Input[builtins.str]]
        """
        链路追踪类型，取值：tls：日志服务。apm：应用性能监控全链路版。
        """
elif False:
    GatewayTraceSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayTraceSpecArgs:
    def __init__(__self__, *,
                 apm_trace_spec: Optional[pulumi.Input['GatewayTraceSpecApmTraceSpecArgs']] = None,
                 enable: Optional[pulumi.Input[builtins.bool]] = None,
                 tls_trace_spec: Optional[pulumi.Input['GatewayTraceSpecTlsTraceSpecArgs']] = None,
                 trace_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input['GatewayTraceSpecApmTraceSpecArgs'] apm_trace_spec: 应用性能监控全链路版链路追踪配置。
        :param pulumi.Input[builtins.bool] enable: 是否启用链路追踪。
        :param pulumi.Input['GatewayTraceSpecTlsTraceSpecArgs'] tls_trace_spec: 链路追踪配置信息。
        :param pulumi.Input[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[pulumi.Input['GatewayTraceSpecApmTraceSpecArgs']]:
        """
        应用性能监控全链路版链路追踪配置。
        """
        return pulumi.get(self, "apm_trace_spec")

    @apm_trace_spec.setter
    def apm_trace_spec(self, value: Optional[pulumi.Input['GatewayTraceSpecApmTraceSpecArgs']]):
        pulumi.set(self, "apm_trace_spec", value)

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

    @enable.setter
    def enable(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable", value)

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

    @tls_trace_spec.setter
    def tls_trace_spec(self, value: Optional[pulumi.Input['GatewayTraceSpecTlsTraceSpecArgs']]):
        pulumi.set(self, "tls_trace_spec", value)

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

    @trace_type.setter
    def trace_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "trace_type", value)


if not MYPY:
    class GatewayTraceSpecApmTraceSpecArgsDict(TypedDict):
        api_key: NotRequired[pulumi.Input[builtins.str]]
        """
        API Key。
        """
elif False:
    GatewayTraceSpecApmTraceSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayTraceSpecApmTraceSpecArgs:
    def __init__(__self__, *,
                 api_key: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        API Key。
        """
        return pulumi.get(self, "api_key")

    @api_key.setter
    def api_key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "api_key", value)


if not MYPY:
    class GatewayTraceSpecTlsTraceSpecArgsDict(TypedDict):
        iam_user_ak: NotRequired[pulumi.Input[builtins.str]]
        """
        Access key。
        """
        iam_user_sk: NotRequired[pulumi.Input[builtins.str]]
        """
        Secret key。
        """
        project_id: NotRequired[pulumi.Input[builtins.str]]
        """
        日志项目ID。
        """
        trace_id: NotRequired[pulumi.Input[builtins.str]]
        """
        Trace ID。
        """
elif False:
    GatewayTraceSpecTlsTraceSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GatewayTraceSpecTlsTraceSpecArgs:
    def __init__(__self__, *,
                 iam_user_ak: Optional[pulumi.Input[builtins.str]] = None,
                 iam_user_sk: Optional[pulumi.Input[builtins.str]] = None,
                 project_id: Optional[pulumi.Input[builtins.str]] = None,
                 trace_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] iam_user_ak: Access key。
        :param pulumi.Input[builtins.str] iam_user_sk: Secret key。
        :param pulumi.Input[builtins.str] project_id: 日志项目ID。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        Access key。
        """
        return pulumi.get(self, "iam_user_ak")

    @iam_user_ak.setter
    def iam_user_ak(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "iam_user_ak", value)

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

    @iam_user_sk.setter
    def iam_user_sk(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "iam_user_sk", value)

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

    @project_id.setter
    def project_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "project_id", value)

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

    @trace_id.setter
    def trace_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "trace_id", value)


if not MYPY:
    class UpstreamBackendTargetArgsDict(TypedDict):
        health_status: NotRequired[pulumi.Input[builtins.str]]
        """
        健康检查状态。
        """
        ip: NotRequired[pulumi.Input[builtins.str]]
        """
        后端节点IP。
        """
        port: NotRequired[pulumi.Input[builtins.int]]
        """
        后端节点端口。
        """
elif False:
    UpstreamBackendTargetArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamBackendTargetArgs:
    def __init__(__self__, *,
                 health_status: Optional[pulumi.Input[builtins.str]] = None,
                 ip: Optional[pulumi.Input[builtins.str]] = None,
                 port: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] health_status: 健康检查状态。
        :param pulumi.Input[builtins.str] ip: 后端节点IP。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        健康检查状态。
        """
        return pulumi.get(self, "health_status")

    @health_status.setter
    def health_status(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "health_status", value)

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

    @ip.setter
    def ip(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "ip", value)

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

    @port.setter
    def port(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "port", value)


if not MYPY:
    class UpstreamCircuitBreakingSettingsArgsDict(TypedDict):
        base_ejection_time: NotRequired[pulumi.Input[builtins.int]]
        """
        最小弹出时间。单位为毫秒。取值限制为1~86400000。默认值为30秒。
        """
        consecutive_errors: NotRequired[pulumi.Input[builtins.int]]
        """
        连续失败次数。取值限制为1~100。默认值为5。
        """
        enable: NotRequired[pulumi.Input[builtins.bool]]
        """
        开启。
        """
        interval: NotRequired[pulumi.Input[builtins.int]]
        """
        计算周期。单位为毫秒。取值限制为1~86400000。默认值为10秒。
        """
        max_ejection_percent: NotRequired[pulumi.Input[builtins.int]]
        """
        最大熔断比例。取值限制为1~100。默认值为20%。
        """
        min_health_percent: NotRequired[pulumi.Input[builtins.int]]
        """
        最小健康比例。取值限制为0~100。默认值为60%。
        """
elif False:
    UpstreamCircuitBreakingSettingsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamCircuitBreakingSettingsArgs:
    def __init__(__self__, *,
                 base_ejection_time: Optional[pulumi.Input[builtins.int]] = None,
                 consecutive_errors: Optional[pulumi.Input[builtins.int]] = None,
                 enable: Optional[pulumi.Input[builtins.bool]] = None,
                 interval: Optional[pulumi.Input[builtins.int]] = None,
                 max_ejection_percent: Optional[pulumi.Input[builtins.int]] = None,
                 min_health_percent: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] base_ejection_time: 最小弹出时间。单位为毫秒。取值限制为1~86400000。默认值为30秒。
        :param pulumi.Input[builtins.int] consecutive_errors: 连续失败次数。取值限制为1~100。默认值为5。
        :param pulumi.Input[builtins.bool] enable: 开启。
        :param pulumi.Input[builtins.int] interval: 计算周期。单位为毫秒。取值限制为1~86400000。默认值为10秒。
        :param pulumi.Input[builtins.int] max_ejection_percent: 最大熔断比例。取值限制为1~100。默认值为20%。
        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
        """
        最小弹出时间。单位为毫秒。取值限制为1~86400000。默认值为30秒。
        """
        return pulumi.get(self, "base_ejection_time")

    @base_ejection_time.setter
    def base_ejection_time(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "base_ejection_time", value)

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

    @consecutive_errors.setter
    def consecutive_errors(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "consecutive_errors", value)

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

    @enable.setter
    def enable(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable", value)

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

    @interval.setter
    def interval(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "interval", value)

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

    @max_ejection_percent.setter
    def max_ejection_percent(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "max_ejection_percent", value)

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

    @min_health_percent.setter
    def min_health_percent(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "min_health_percent", value)


if not MYPY:
    class UpstreamLoadBalancerSettingsArgsDict(TypedDict):
        consistent_hash_lb: NotRequired[pulumi.Input['UpstreamLoadBalancerSettingsConsistentHashLbArgsDict']]
        """
        一致性哈希负载均衡。
        """
        lb_policy: NotRequired[pulumi.Input[builtins.str]]
        """
        负载均衡策略，取值：SimpleLB：简单负载均衡。ConsistentHashLB：一致性哈希负载均衡。
        """
        simple_lb: NotRequired[pulumi.Input[builtins.str]]
        """
        简单负载均衡，取值：ROUND*ROBIN：轮询。LEAST*CONN：最小连接数。RANDOM：随机。
        """
        warmup_duration: NotRequired[pulumi.Input[builtins.int]]
        """
        预热时间。单位为秒。
        """
elif False:
    UpstreamLoadBalancerSettingsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamLoadBalancerSettingsArgs:
    def __init__(__self__, *,
                 consistent_hash_lb: Optional[pulumi.Input['UpstreamLoadBalancerSettingsConsistentHashLbArgs']] = None,
                 lb_policy: Optional[pulumi.Input[builtins.str]] = None,
                 simple_lb: Optional[pulumi.Input[builtins.str]] = None,
                 warmup_duration: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input['UpstreamLoadBalancerSettingsConsistentHashLbArgs'] consistent_hash_lb: 一致性哈希负载均衡。
        :param pulumi.Input[builtins.str] lb_policy: 负载均衡策略，取值：SimpleLB：简单负载均衡。ConsistentHashLB：一致性哈希负载均衡。
        :param pulumi.Input[builtins.str] simple_lb: 简单负载均衡，取值：ROUND*ROBIN：轮询。LEAST*CONN：最小连接数。RANDOM：随机。
        :param pulumi.Input[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[pulumi.Input['UpstreamLoadBalancerSettingsConsistentHashLbArgs']]:
        """
        一致性哈希负载均衡。
        """
        return pulumi.get(self, "consistent_hash_lb")

    @consistent_hash_lb.setter
    def consistent_hash_lb(self, value: Optional[pulumi.Input['UpstreamLoadBalancerSettingsConsistentHashLbArgs']]):
        pulumi.set(self, "consistent_hash_lb", value)

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

    @lb_policy.setter
    def lb_policy(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "lb_policy", value)

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

    @simple_lb.setter
    def simple_lb(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "simple_lb", value)

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

    @warmup_duration.setter
    def warmup_duration(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "warmup_duration", value)


if not MYPY:
    class UpstreamLoadBalancerSettingsConsistentHashLbArgsDict(TypedDict):
        hash_key: NotRequired[pulumi.Input[builtins.str]]
        """
        一致性哈希方式，取值：UseSourceIp：基于源IP地址。HttpQueryParameterName：基于参数。HttpHeaderName：基于头。HTTPCookie：基于cookie。
        """
        http_cookie: NotRequired[pulumi.Input['UpstreamLoadBalancerSettingsConsistentHashLbHttpCookieArgsDict']]
        """
        Cookie。
        """
        http_header_name: NotRequired[pulumi.Input[builtins.str]]
        """
        参数。支持ASCII可打印字符，长度限制为1~256个字符。
        """
        http_query_parameter_name: NotRequired[pulumi.Input[builtins.str]]
        """
        参数。支持ASCII可打印字符，长度限制为1~256个字符。
        """
        use_source_ip: NotRequired[pulumi.Input[builtins.str]]
        """
        源IP地址。
        """
elif False:
    UpstreamLoadBalancerSettingsConsistentHashLbArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamLoadBalancerSettingsConsistentHashLbArgs:
    def __init__(__self__, *,
                 hash_key: Optional[pulumi.Input[builtins.str]] = None,
                 http_cookie: Optional[pulumi.Input['UpstreamLoadBalancerSettingsConsistentHashLbHttpCookieArgs']] = None,
                 http_header_name: Optional[pulumi.Input[builtins.str]] = None,
                 http_query_parameter_name: Optional[pulumi.Input[builtins.str]] = None,
                 use_source_ip: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] hash_key: 一致性哈希方式，取值：UseSourceIp：基于源IP地址。HttpQueryParameterName：基于参数。HttpHeaderName：基于头。HTTPCookie：基于cookie。
        :param pulumi.Input['UpstreamLoadBalancerSettingsConsistentHashLbHttpCookieArgs'] http_cookie: Cookie。
        :param pulumi.Input[builtins.str] http_header_name: 参数。支持ASCII可打印字符，长度限制为1~256个字符。
        :param pulumi.Input[builtins.str] http_query_parameter_name: 参数。支持ASCII可打印字符，长度限制为1~256个字符。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        一致性哈希方式，取值：UseSourceIp：基于源IP地址。HttpQueryParameterName：基于参数。HttpHeaderName：基于头。HTTPCookie：基于cookie。
        """
        return pulumi.get(self, "hash_key")

    @hash_key.setter
    def hash_key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "hash_key", value)

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

    @http_cookie.setter
    def http_cookie(self, value: Optional[pulumi.Input['UpstreamLoadBalancerSettingsConsistentHashLbHttpCookieArgs']]):
        pulumi.set(self, "http_cookie", value)

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

    @http_header_name.setter
    def http_header_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "http_header_name", value)

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

    @http_query_parameter_name.setter
    def http_query_parameter_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "http_query_parameter_name", value)

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

    @use_source_ip.setter
    def use_source_ip(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "use_source_ip", value)


if not MYPY:
    class UpstreamLoadBalancerSettingsConsistentHashLbHttpCookieArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        名称。支持ASCII可打印字符，长度限制为0~256个字符。
        """
        path: NotRequired[pulumi.Input[builtins.str]]
        """
        路径。支持ASCII可打印字符，长度限制为1~256个字符。
        """
        ttl: NotRequired[pulumi.Input[builtins.int]]
        """
        有效期。单位为秒。
        """
elif False:
    UpstreamLoadBalancerSettingsConsistentHashLbHttpCookieArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamLoadBalancerSettingsConsistentHashLbHttpCookieArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 path: Optional[pulumi.Input[builtins.str]] = None,
                 ttl: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] name: 名称。支持ASCII可打印字符，长度限制为0~256个字符。
        :param pulumi.Input[builtins.str] path: 路径。支持ASCII可打印字符，长度限制为1~256个字符。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        名称。支持ASCII可打印字符，长度限制为0~256个字符。
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)

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

    @path.setter
    def path(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "path", value)

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

    @ttl.setter
    def ttl(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "ttl", value)


if not MYPY:
    class UpstreamSourceIngressSettingsArgsDict(TypedDict):
        enable_all_ingress_classes: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否启用所有Ingress类。
        """
        enable_all_namespaces: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否全部命名空间。
        """
        enable_ingress: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启。
        """
        enable_ingress_without_ingress_class: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否监听IngressClass为空的资源。
        """
        ingress_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        指定IngressClass。
        """
        update_status: NotRequired[pulumi.Input[builtins.bool]]
        """
        流量入口切换。开启后，当前集群Ingress中Status的IP地址会被修改为当前网关的IP地址。
        """
        watch_namespaces: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        指定命名空间。
        """
elif False:
    UpstreamSourceIngressSettingsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamSourceIngressSettingsArgs:
    def __init__(__self__, *,
                 enable_all_ingress_classes: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_all_namespaces: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_ingress: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_ingress_without_ingress_class: Optional[pulumi.Input[builtins.bool]] = None,
                 ingress_classes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 update_status: Optional[pulumi.Input[builtins.bool]] = None,
                 watch_namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[builtins.bool] enable_all_ingress_classes: 是否启用所有Ingress类。
        :param pulumi.Input[builtins.bool] enable_all_namespaces: 是否全部命名空间。
        :param pulumi.Input[builtins.bool] enable_ingress: 是否开启。
        :param pulumi.Input[builtins.bool] enable_ingress_without_ingress_class: 是否监听IngressClass为空的资源。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ingress_classes: 指定IngressClass。
        :param pulumi.Input[builtins.bool] update_status: 流量入口切换。开启后，当前集群Ingress中Status的IP地址会被修改为当前网关的IP地址。
        :param pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[builtins.bool]]:
        """
        是否启用所有Ingress类。
        """
        return pulumi.get(self, "enable_all_ingress_classes")

    @enable_all_ingress_classes.setter
    def enable_all_ingress_classes(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable_all_ingress_classes", value)

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

    @enable_all_namespaces.setter
    def enable_all_namespaces(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable_all_namespaces", value)

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

    @enable_ingress.setter
    def enable_ingress(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable_ingress", value)

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

    @enable_ingress_without_ingress_class.setter
    def enable_ingress_without_ingress_class(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enable_ingress_without_ingress_class", value)

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

    @ingress_classes.setter
    def ingress_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "ingress_classes", value)

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

    @update_status.setter
    def update_status(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "update_status", value)

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

    @watch_namespaces.setter
    def watch_namespaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "watch_namespaces", value)


if not MYPY:
    class UpstreamSourceSourceSpecArgsDict(TypedDict):
        k8_s_source: NotRequired[pulumi.Input['UpstreamSourceSourceSpecK8SSourceArgsDict']]
        """
        容器集群来源。
        """
        nacos_source: NotRequired[pulumi.Input['UpstreamSourceSourceSpecNacosSourceArgsDict']]
        """
        注册中心来源。
        """
elif False:
    UpstreamSourceSourceSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamSourceSourceSpecArgs:
    def __init__(__self__, *,
                 k8_s_source: Optional[pulumi.Input['UpstreamSourceSourceSpecK8SSourceArgs']] = None,
                 nacos_source: Optional[pulumi.Input['UpstreamSourceSourceSpecNacosSourceArgs']] = None):
        """
        :param pulumi.Input['UpstreamSourceSourceSpecK8SSourceArgs'] k8_s_source: 容器集群来源。
        :param pulumi.Input['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[pulumi.Input['UpstreamSourceSourceSpecK8SSourceArgs']]:
        """
        容器集群来源。
        """
        return pulumi.get(self, "k8_s_source")

    @k8_s_source.setter
    def k8_s_source(self, value: Optional[pulumi.Input['UpstreamSourceSourceSpecK8SSourceArgs']]):
        pulumi.set(self, "k8_s_source", value)

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

    @nacos_source.setter
    def nacos_source(self, value: Optional[pulumi.Input['UpstreamSourceSourceSpecNacosSourceArgs']]):
        pulumi.set(self, "nacos_source", value)


if not MYPY:
    class UpstreamSourceSourceSpecK8SSourceArgsDict(TypedDict):
        cluster_id: NotRequired[pulumi.Input[builtins.str]]
        """
        集群ID。
        """
        cluster_type: NotRequired[pulumi.Input[builtins.str]]
        """
        集群类型。
        """
elif False:
    UpstreamSourceSourceSpecK8SSourceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamSourceSourceSpecK8SSourceArgs:
    def __init__(__self__, *,
                 cluster_id: Optional[pulumi.Input[builtins.str]] = None,
                 cluster_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] cluster_id: 集群ID。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        集群ID。
        """
        return pulumi.get(self, "cluster_id")

    @cluster_id.setter
    def cluster_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "cluster_id", value)

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

    @cluster_type.setter
    def cluster_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "cluster_type", value)


if not MYPY:
    class UpstreamSourceSourceSpecNacosSourceArgsDict(TypedDict):
        auth_config: NotRequired[pulumi.Input['UpstreamSourceSourceSpecNacosSourceAuthConfigArgsDict']]
        """
        认证配置。
        """
        nacos_id: NotRequired[pulumi.Input[builtins.str]]
        """
        Nacos ID。
        """
        nacos_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Nacos名称。
        """
elif False:
    UpstreamSourceSourceSpecNacosSourceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamSourceSourceSpecNacosSourceArgs:
    def __init__(__self__, *,
                 auth_config: Optional[pulumi.Input['UpstreamSourceSourceSpecNacosSourceAuthConfigArgs']] = None,
                 nacos_id: Optional[pulumi.Input[builtins.str]] = None,
                 nacos_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input['UpstreamSourceSourceSpecNacosSourceAuthConfigArgs'] auth_config: 认证配置。
        :param pulumi.Input[builtins.str] nacos_id: Nacos ID。
        :param pulumi.Input[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[pulumi.Input['UpstreamSourceSourceSpecNacosSourceAuthConfigArgs']]:
        """
        认证配置。
        """
        return pulumi.get(self, "auth_config")

    @auth_config.setter
    def auth_config(self, value: Optional[pulumi.Input['UpstreamSourceSourceSpecNacosSourceAuthConfigArgs']]):
        pulumi.set(self, "auth_config", value)

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

    @nacos_id.setter
    def nacos_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "nacos_id", value)

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

    @nacos_name.setter
    def nacos_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "nacos_name", value)


if not MYPY:
    class UpstreamSourceSourceSpecNacosSourceAuthConfigArgsDict(TypedDict):
        basic: NotRequired[pulumi.Input['UpstreamSourceSourceSpecNacosSourceAuthConfigBasicArgsDict']]
        """
        Basic认证。
        """
elif False:
    UpstreamSourceSourceSpecNacosSourceAuthConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamSourceSourceSpecNacosSourceAuthConfigArgs:
    def __init__(__self__, *,
                 basic: Optional[pulumi.Input['UpstreamSourceSourceSpecNacosSourceAuthConfigBasicArgs']] = None):
        """
        :param pulumi.Input['UpstreamSourceSourceSpecNacosSourceAuthConfigBasicArgs'] basic: Basic认证。
        """
        if basic is not None:
            pulumi.set(__self__, "basic", basic)

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

    @basic.setter
    def basic(self, value: Optional[pulumi.Input['UpstreamSourceSourceSpecNacosSourceAuthConfigBasicArgs']]):
        pulumi.set(self, "basic", value)


if not MYPY:
    class UpstreamSourceSourceSpecNacosSourceAuthConfigBasicArgsDict(TypedDict):
        password: NotRequired[pulumi.Input[builtins.str]]
        """
        密码。
        """
        username: NotRequired[pulumi.Input[builtins.str]]
        """
        用户名。
        """
elif False:
    UpstreamSourceSourceSpecNacosSourceAuthConfigBasicArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamSourceSourceSpecNacosSourceAuthConfigBasicArgs:
    def __init__(__self__, *,
                 password: Optional[pulumi.Input[builtins.str]] = None,
                 username: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] password: 密码。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        密码。
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "password", value)

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

    @username.setter
    def username(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "username", value)


if not MYPY:
    class UpstreamTlsSettingsArgsDict(TypedDict):
        sni: NotRequired[pulumi.Input[builtins.str]]
        """
        SNI。留空时会将访问网关的域名透传到upstream。
        """
        tls_mode: NotRequired[pulumi.Input[builtins.str]]
        """
        TLS模式，取值：DISABLE：关闭TLS。SIMPLE：单向TLS。
        """
elif False:
    UpstreamTlsSettingsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamTlsSettingsArgs:
    def __init__(__self__, *,
                 sni: Optional[pulumi.Input[builtins.str]] = None,
                 tls_mode: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] sni: SNI。留空时会将访问网关的域名透传到upstream。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        SNI。留空时会将访问网关的域名透传到upstream。
        """
        return pulumi.get(self, "sni")

    @sni.setter
    def sni(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "sni", value)

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

    @tls_mode.setter
    def tls_mode(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "tls_mode", value)


if not MYPY:
    class UpstreamUpstreamSpecArgsDict(TypedDict):
        ai_provider: NotRequired[pulumi.Input['UpstreamUpstreamSpecAiProviderArgsDict']]
        """
        AI模型代理。
        """
        ecs_instances: NotRequired[pulumi.Input[Sequence[pulumi.Input['UpstreamUpstreamSpecEcsInstanceArgsDict']]]]
        k8_s_service: NotRequired[pulumi.Input['UpstreamUpstreamSpecK8SServiceArgsDict']]
        """
        容器服务。
        """
        nacos_service: NotRequired[pulumi.Input['UpstreamUpstreamSpecNacosServiceArgsDict']]
        """
        注册中心。
        """
        ve_faas: NotRequired[pulumi.Input['UpstreamUpstreamSpecVeFaasArgsDict']]
        """
        函数服务。
        """
elif False:
    UpstreamUpstreamSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamUpstreamSpecArgs:
    def __init__(__self__, *,
                 ai_provider: Optional[pulumi.Input['UpstreamUpstreamSpecAiProviderArgs']] = None,
                 ecs_instances: Optional[pulumi.Input[Sequence[pulumi.Input['UpstreamUpstreamSpecEcsInstanceArgs']]]] = None,
                 k8_s_service: Optional[pulumi.Input['UpstreamUpstreamSpecK8SServiceArgs']] = None,
                 nacos_service: Optional[pulumi.Input['UpstreamUpstreamSpecNacosServiceArgs']] = None,
                 ve_faas: Optional[pulumi.Input['UpstreamUpstreamSpecVeFaasArgs']] = None):
        """
        :param pulumi.Input['UpstreamUpstreamSpecAiProviderArgs'] ai_provider: AI模型代理。
        :param pulumi.Input['UpstreamUpstreamSpecK8SServiceArgs'] k8_s_service: 容器服务。
        :param pulumi.Input['UpstreamUpstreamSpecNacosServiceArgs'] nacos_service: 注册中心。
        :param pulumi.Input['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[pulumi.Input['UpstreamUpstreamSpecAiProviderArgs']]:
        """
        AI模型代理。
        """
        return pulumi.get(self, "ai_provider")

    @ai_provider.setter
    def ai_provider(self, value: Optional[pulumi.Input['UpstreamUpstreamSpecAiProviderArgs']]):
        pulumi.set(self, "ai_provider", value)

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

    @ecs_instances.setter
    def ecs_instances(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UpstreamUpstreamSpecEcsInstanceArgs']]]]):
        pulumi.set(self, "ecs_instances", value)

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

    @k8_s_service.setter
    def k8_s_service(self, value: Optional[pulumi.Input['UpstreamUpstreamSpecK8SServiceArgs']]):
        pulumi.set(self, "k8_s_service", value)

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

    @nacos_service.setter
    def nacos_service(self, value: Optional[pulumi.Input['UpstreamUpstreamSpecNacosServiceArgs']]):
        pulumi.set(self, "nacos_service", value)

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

    @ve_faas.setter
    def ve_faas(self, value: Optional[pulumi.Input['UpstreamUpstreamSpecVeFaasArgs']]):
        pulumi.set(self, "ve_faas", value)


if not MYPY:
    class UpstreamUpstreamSpecAiProviderArgsDict(TypedDict):
        base_url: NotRequired[pulumi.Input[builtins.str]]
        """
        模型地址。
        """
        custom_model_service: NotRequired[pulumi.Input['UpstreamUpstreamSpecAiProviderCustomModelServiceArgsDict']]
        """
        火山自部署模型服务。
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        模型服务商名称。
        """
        token: NotRequired[pulumi.Input[builtins.str]]
        """
        模型API key。
        """
elif False:
    UpstreamUpstreamSpecAiProviderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamUpstreamSpecAiProviderArgs:
    def __init__(__self__, *,
                 base_url: Optional[pulumi.Input[builtins.str]] = None,
                 custom_model_service: Optional[pulumi.Input['UpstreamUpstreamSpecAiProviderCustomModelServiceArgs']] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 token: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] base_url: 模型地址。
        :param pulumi.Input['UpstreamUpstreamSpecAiProviderCustomModelServiceArgs'] custom_model_service: 火山自部署模型服务。
        :param pulumi.Input[builtins.str] name: 模型服务商名称。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        模型地址。
        """
        return pulumi.get(self, "base_url")

    @base_url.setter
    def base_url(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "base_url", value)

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

    @custom_model_service.setter
    def custom_model_service(self, value: Optional[pulumi.Input['UpstreamUpstreamSpecAiProviderCustomModelServiceArgs']]):
        pulumi.set(self, "custom_model_service", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)

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

    @token.setter
    def token(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "token", value)


if not MYPY:
    class UpstreamUpstreamSpecAiProviderCustomModelServiceArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        模型服务名称。
        """
        namespace: NotRequired[pulumi.Input[builtins.str]]
        """
        命名空间。
        """
        port: NotRequired[pulumi.Input[builtins.int]]
        """
        端口。
        """
elif False:
    UpstreamUpstreamSpecAiProviderCustomModelServiceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamUpstreamSpecAiProviderCustomModelServiceArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 namespace: Optional[pulumi.Input[builtins.str]] = None,
                 port: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] name: 模型服务名称。
        :param pulumi.Input[builtins.str] namespace: 命名空间。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        模型服务名称。
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)

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

    @namespace.setter
    def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "namespace", value)

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

    @port.setter
    def port(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "port", value)


if not MYPY:
    class UpstreamUpstreamSpecEcsInstanceArgsDict(TypedDict):
        ecs_id: NotRequired[pulumi.Input[builtins.str]]
        """
        云服务器ID。
        """
        ip: NotRequired[pulumi.Input[builtins.str]]
        """
        IP地址。
        """
        port: NotRequired[pulumi.Input[builtins.int]]
        """
        端口。
        """
elif False:
    UpstreamUpstreamSpecEcsInstanceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamUpstreamSpecEcsInstanceArgs:
    def __init__(__self__, *,
                 ecs_id: Optional[pulumi.Input[builtins.str]] = None,
                 ip: Optional[pulumi.Input[builtins.str]] = None,
                 port: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] ecs_id: 云服务器ID。
        :param pulumi.Input[builtins.str] ip: IP地址。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        云服务器ID。
        """
        return pulumi.get(self, "ecs_id")

    @ecs_id.setter
    def ecs_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "ecs_id", value)

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

    @ip.setter
    def ip(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "ip", value)

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

    @port.setter
    def port(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "port", value)


if not MYPY:
    class UpstreamUpstreamSpecK8SServiceArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        容器服务名称。长度限制为2~63个字符。
        """
        namespace: NotRequired[pulumi.Input[builtins.str]]
        """
        命名空间。长度限制为2~63个字符。
        """
        port: NotRequired[pulumi.Input[builtins.int]]
        """
        端口。
        """
elif False:
    UpstreamUpstreamSpecK8SServiceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamUpstreamSpecK8SServiceArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 namespace: Optional[pulumi.Input[builtins.str]] = None,
                 port: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] name: 容器服务名称。长度限制为2~63个字符。
        :param pulumi.Input[builtins.str] namespace: 命名空间。长度限制为2~63个字符。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        容器服务名称。长度限制为2~63个字符。
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)

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

    @namespace.setter
    def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "namespace", value)

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

    @port.setter
    def port(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "port", value)


if not MYPY:
    class UpstreamUpstreamSpecNacosServiceArgsDict(TypedDict):
        group: NotRequired[pulumi.Input[builtins.str]]
        """
        分组。
        """
        namespace: NotRequired[pulumi.Input[builtins.str]]
        """
        命名空间。
        """
        namespace_id: NotRequired[pulumi.Input[builtins.str]]
        """
        命名空间ID。
        """
        service: NotRequired[pulumi.Input[builtins.str]]
        """
        服务。
        """
        upstream_source_id: NotRequired[pulumi.Input[builtins.str]]
        """
        Upstream来源ID。
        """
elif False:
    UpstreamUpstreamSpecNacosServiceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamUpstreamSpecNacosServiceArgs:
    def __init__(__self__, *,
                 group: Optional[pulumi.Input[builtins.str]] = None,
                 namespace: Optional[pulumi.Input[builtins.str]] = None,
                 namespace_id: Optional[pulumi.Input[builtins.str]] = None,
                 service: Optional[pulumi.Input[builtins.str]] = None,
                 upstream_source_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] group: 分组。
        :param pulumi.Input[builtins.str] namespace: 命名空间。
        :param pulumi.Input[builtins.str] namespace_id: 命名空间ID。
        :param pulumi.Input[builtins.str] service: 服务。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        分组。
        """
        return pulumi.get(self, "group")

    @group.setter
    def group(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "group", value)

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

    @namespace.setter
    def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "namespace", value)

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

    @namespace_id.setter
    def namespace_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "namespace_id", value)

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

    @service.setter
    def service(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "service", value)

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

    @upstream_source_id.setter
    def upstream_source_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "upstream_source_id", value)


if not MYPY:
    class UpstreamUpstreamSpecVeFaasArgsDict(TypedDict):
        function_id: NotRequired[pulumi.Input[builtins.str]]
        """
        函数ID。
        """
elif False:
    UpstreamUpstreamSpecVeFaasArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamUpstreamSpecVeFaasArgs:
    def __init__(__self__, *,
                 function_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        函数ID。
        """
        return pulumi.get(self, "function_id")

    @function_id.setter
    def function_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "function_id", value)


if not MYPY:
    class UpstreamVersionDetailArgsDict(TypedDict):
        labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['UpstreamVersionDetailLabelArgsDict']]]]
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        版本名称。支持大小写字母、数字和中划线（-），长度限制为2~63个字符。不能以中划线（-）开头。
        """
        update_time: NotRequired[pulumi.Input[builtins.str]]
        """
        更新时间。
        """
elif False:
    UpstreamVersionDetailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamVersionDetailArgs:
    def __init__(__self__, *,
                 labels: Optional[pulumi.Input[Sequence[pulumi.Input['UpstreamVersionDetailLabelArgs']]]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 update_time: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] name: 版本名称。支持大小写字母、数字和中划线（-），长度限制为2~63个字符。不能以中划线（-）开头。
        :param pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input['UpstreamVersionDetailLabelArgs']]]]:
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UpstreamVersionDetailLabelArgs']]]]):
        pulumi.set(self, "labels", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)

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

    @update_time.setter
    def update_time(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "update_time", value)


if not MYPY:
    class UpstreamVersionDetailLabelArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        值。
        """
elif False:
    UpstreamVersionDetailLabelArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamVersionDetailLabelArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 键。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        键。
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "value", value)


