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

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

__all__ = [
    'GetEndpointServiceResult',
    'AwaitableGetEndpointServiceResult',
    'get_endpoint_service',
    'get_endpoint_service_output',
]

@pulumi.output_type
class GetEndpointServiceResult:
    """
    A collection of values returned by getEndpointService.
    """
    def __init__(__self__, auto_accept_enabled=None, billing_type=None, business_status=None, create_time=None, description=None, id=None, ip_address_versions=None, payer=None, private_dns_enabled=None, private_dns_name=None, private_dns_name_configuration=None, private_dns_type=None, project_name=None, resources=None, service_domain=None, service_id=None, service_name=None, service_name_managed=None, service_name_suffix=None, service_owner=None, service_resource_type=None, service_type=None, status=None, tags=None, update_time=None, wildcard_domain_enabled=None, zone_ids=None):
        if auto_accept_enabled and not isinstance(auto_accept_enabled, bool):
            raise TypeError("Expected argument 'auto_accept_enabled' to be a bool")
        pulumi.set(__self__, "auto_accept_enabled", auto_accept_enabled)
        if billing_type and not isinstance(billing_type, int):
            raise TypeError("Expected argument 'billing_type' to be a int")
        pulumi.set(__self__, "billing_type", billing_type)
        if business_status and not isinstance(business_status, str):
            raise TypeError("Expected argument 'business_status' to be a str")
        pulumi.set(__self__, "business_status", business_status)
        if create_time and not isinstance(create_time, str):
            raise TypeError("Expected argument 'create_time' to be a str")
        pulumi.set(__self__, "create_time", create_time)
        if description and not isinstance(description, str):
            raise TypeError("Expected argument 'description' to be a str")
        pulumi.set(__self__, "description", description)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if ip_address_versions and not isinstance(ip_address_versions, list):
            raise TypeError("Expected argument 'ip_address_versions' to be a list")
        pulumi.set(__self__, "ip_address_versions", ip_address_versions)
        if payer and not isinstance(payer, str):
            raise TypeError("Expected argument 'payer' to be a str")
        pulumi.set(__self__, "payer", payer)
        if private_dns_enabled and not isinstance(private_dns_enabled, bool):
            raise TypeError("Expected argument 'private_dns_enabled' to be a bool")
        pulumi.set(__self__, "private_dns_enabled", private_dns_enabled)
        if private_dns_name and not isinstance(private_dns_name, str):
            raise TypeError("Expected argument 'private_dns_name' to be a str")
        pulumi.set(__self__, "private_dns_name", private_dns_name)
        if private_dns_name_configuration and not isinstance(private_dns_name_configuration, dict):
            raise TypeError("Expected argument 'private_dns_name_configuration' to be a dict")
        pulumi.set(__self__, "private_dns_name_configuration", private_dns_name_configuration)
        if private_dns_type and not isinstance(private_dns_type, str):
            raise TypeError("Expected argument 'private_dns_type' to be a str")
        pulumi.set(__self__, "private_dns_type", private_dns_type)
        if project_name and not isinstance(project_name, str):
            raise TypeError("Expected argument 'project_name' to be a str")
        pulumi.set(__self__, "project_name", project_name)
        if resources and not isinstance(resources, list):
            raise TypeError("Expected argument 'resources' to be a list")
        pulumi.set(__self__, "resources", resources)
        if service_domain and not isinstance(service_domain, str):
            raise TypeError("Expected argument 'service_domain' to be a str")
        pulumi.set(__self__, "service_domain", service_domain)
        if service_id and not isinstance(service_id, str):
            raise TypeError("Expected argument 'service_id' to be a str")
        pulumi.set(__self__, "service_id", service_id)
        if service_name and not isinstance(service_name, str):
            raise TypeError("Expected argument 'service_name' to be a str")
        pulumi.set(__self__, "service_name", service_name)
        if service_name_managed and not isinstance(service_name_managed, str):
            raise TypeError("Expected argument 'service_name_managed' to be a str")
        pulumi.set(__self__, "service_name_managed", service_name_managed)
        if service_name_suffix and not isinstance(service_name_suffix, str):
            raise TypeError("Expected argument 'service_name_suffix' to be a str")
        pulumi.set(__self__, "service_name_suffix", service_name_suffix)
        if service_owner and not isinstance(service_owner, str):
            raise TypeError("Expected argument 'service_owner' to be a str")
        pulumi.set(__self__, "service_owner", service_owner)
        if service_resource_type and not isinstance(service_resource_type, str):
            raise TypeError("Expected argument 'service_resource_type' to be a str")
        pulumi.set(__self__, "service_resource_type", service_resource_type)
        if service_type and not isinstance(service_type, str):
            raise TypeError("Expected argument 'service_type' to be a str")
        pulumi.set(__self__, "service_type", service_type)
        if status and not isinstance(status, str):
            raise TypeError("Expected argument 'status' to be a str")
        pulumi.set(__self__, "status", status)
        if tags and not isinstance(tags, list):
            raise TypeError("Expected argument 'tags' to be a list")
        pulumi.set(__self__, "tags", tags)
        if update_time and not isinstance(update_time, str):
            raise TypeError("Expected argument 'update_time' to be a str")
        pulumi.set(__self__, "update_time", update_time)
        if wildcard_domain_enabled and not isinstance(wildcard_domain_enabled, bool):
            raise TypeError("Expected argument 'wildcard_domain_enabled' to be a bool")
        pulumi.set(__self__, "wildcard_domain_enabled", wildcard_domain_enabled)
        if zone_ids and not isinstance(zone_ids, list):
            raise TypeError("Expected argument 'zone_ids' to be a list")
        pulumi.set(__self__, "zone_ids", zone_ids)

    @property
    @pulumi.getter(name="autoAcceptEnabled")
    def auto_accept_enabled(self) -> builtins.bool:
        """
        是否自动接受终端节点连接。true：终端节点服务自动接受终端节点连接。false：终端节点服务不会自动接受终端节点连接，需要调用EnableVpcEndpointConnection接口手动接受。
        """
        return pulumi.get(self, "auto_accept_enabled")

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> builtins.int:
        """
        终端节点服务的计费类型。0：不计费。3：按量计费。
        """
        return pulumi.get(self, "billing_type")

    @property
    @pulumi.getter(name="businessStatus")
    def business_status(self) -> builtins.str:
        """
        终端节点服务是否被锁定。Normal：正常。FinancialLocked：被锁定。说明该参数返回为空时，表示终端节点服务未锁定。
        """
        return pulumi.get(self, "business_status")

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> builtins.str:
        """
        终端节点服务的创建时间。
        """
        return pulumi.get(self, "create_time")

    @property
    @pulumi.getter
    def description(self) -> builtins.str:
        """
        终端节点服务的描述信息。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        Uniquely identifies the resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ipAddressVersions")
    def ip_address_versions(self) -> Sequence[builtins.str]:
        """
        终端节点服务的IP协议类型。返回值中仅包含ipv4时，说明该终端节点服务为IPv4类型，仅支持提供IPv4服务。返回值中同时包含ipv4和ipv6时，说明该终端节点服务为双栈类型，支持同时提供IPv4和IPv6服务。
        """
        return pulumi.get(self, "ip_address_versions")

    @property
    @pulumi.getter
    def payer(self) -> builtins.str:
        """
        私网连接的付费账号。Endpoint：终端节点账号。EndpointService：终端节点服务账号。
        """
        return pulumi.get(self, "payer")

    @property
    @pulumi.getter(name="privateDnsEnabled")
    def private_dns_enabled(self) -> builtins.bool:
        """
        终端节点服务是否启用私有DNS名称。false：未启用。true：已启用。
        """
        return pulumi.get(self, "private_dns_enabled")

    @property
    @pulumi.getter(name="privateDnsName")
    def private_dns_name(self) -> builtins.str:
        """
        终端节点服务的私有DNS名称。参数PrivateDNSEnabled返回值为false时，该参数返回空。
        """
        return pulumi.get(self, "private_dns_name")

    @property
    @pulumi.getter(name="privateDnsNameConfiguration")
    def private_dns_name_configuration(self) -> 'outputs.GetEndpointServicePrivateDnsNameConfigurationResult':
        """
        终端节点服务私有DNS名称的配置信息。说明PrivateDNSType为private时，不返回该参数。
        """
        return pulumi.get(self, "private_dns_name_configuration")

    @property
    @pulumi.getter(name="privateDnsType")
    def private_dns_type(self) -> builtins.str:
        """
        私有DNS名称的域名类型。public：公网。说明未开通自定义私网域名功能时，不返回该参数。
        """
        return pulumi.get(self, "private_dns_type")

    @property
    @pulumi.getter(name="projectName")
    def project_name(self) -> builtins.str:
        """
        终端节点服务所属的项目名称。
        """
        return pulumi.get(self, "project_name")

    @property
    @pulumi.getter
    def resources(self) -> Sequence['outputs.GetEndpointServiceResourceResult']:
        """
        终端节点服务提供服务的资源。
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter(name="serviceDomain")
    def service_domain(self) -> builtins.str:
        """
        终端节点服务的服务域名。
        """
        return pulumi.get(self, "service_domain")

    @property
    @pulumi.getter(name="serviceId")
    def service_id(self) -> builtins.str:
        """
        终端节点服务的ID。
        """
        return pulumi.get(self, "service_id")

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> builtins.str:
        """
        终端节点服务的名称。
        """
        return pulumi.get(self, "service_name")

    @property
    @pulumi.getter(name="serviceNameManaged")
    def service_name_managed(self) -> builtins.str:
        """
        是否为托管终端节点服务。false：非托管终端节点服务。true：托管终端节点服务。说明终端节点服务所属账号未开通托管终端节点服务功能时，不返回该参数。
        """
        return pulumi.get(self, "service_name_managed")

    @property
    @pulumi.getter(name="serviceNameSuffix")
    def service_name_suffix(self) -> builtins.str:
        """
        终端节点服务的名称后缀。设置名称后缀后，系统会按照com.volces.privatelink.<地域ID>.<名称后缀>的格式生成终端节点服务的名称。说明该参数正在邀测中，如需使用不同名称后缀区分业务，请联系客户经理。
        """
        return pulumi.get(self, "service_name_suffix")

    @property
    @pulumi.getter(name="serviceOwner")
    def service_owner(self) -> builtins.str:
        """
        当前服务主体。
        """
        return pulumi.get(self, "service_owner")

    @property
    @pulumi.getter(name="serviceResourceType")
    def service_resource_type(self) -> builtins.str:
        """
        服务资源的类型。CLB：负载均衡CLB。ALB：应用型负载均衡ALB。RDSMySQL：云数据库 MySQL版。
        """
        return pulumi.get(self, "service_resource_type")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> builtins.str:
        """
        终端节点服务的类型。Interface：接口终端节点服务。
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter
    def status(self) -> builtins.str:
        """
        终端节点服务的状态。Creating：创建中。Pending：配置修改中。Available：可用。Deleting：删除中。
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def tags(self) -> Sequence['outputs.GetEndpointServiceTagResult']:
        """
        终端节点服务的标签信息。
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="updateTime")
    def update_time(self) -> builtins.str:
        """
        终端节点服务的最近操作时间。
        """
        return pulumi.get(self, "update_time")

    @property
    @pulumi.getter(name="wildcardDomainEnabled")
    def wildcard_domain_enabled(self) -> builtins.bool:
        """
        是否启用通配符域名。true：启用。false：未启用。
        """
        return pulumi.get(self, "wildcard_domain_enabled")

    @property
    @pulumi.getter(name="zoneIds")
    def zone_ids(self) -> Sequence[builtins.str]:
        """
        终端节点服务提供服务的可用区。说明参数ServiceResourceType返回值为RDSMySQL时，该参数返回空值。
        """
        return pulumi.get(self, "zone_ids")


class AwaitableGetEndpointServiceResult(GetEndpointServiceResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetEndpointServiceResult(
            auto_accept_enabled=self.auto_accept_enabled,
            billing_type=self.billing_type,
            business_status=self.business_status,
            create_time=self.create_time,
            description=self.description,
            id=self.id,
            ip_address_versions=self.ip_address_versions,
            payer=self.payer,
            private_dns_enabled=self.private_dns_enabled,
            private_dns_name=self.private_dns_name,
            private_dns_name_configuration=self.private_dns_name_configuration,
            private_dns_type=self.private_dns_type,
            project_name=self.project_name,
            resources=self.resources,
            service_domain=self.service_domain,
            service_id=self.service_id,
            service_name=self.service_name,
            service_name_managed=self.service_name_managed,
            service_name_suffix=self.service_name_suffix,
            service_owner=self.service_owner,
            service_resource_type=self.service_resource_type,
            service_type=self.service_type,
            status=self.status,
            tags=self.tags,
            update_time=self.update_time,
            wildcard_domain_enabled=self.wildcard_domain_enabled,
            zone_ids=self.zone_ids)


def get_endpoint_service(id: Optional[builtins.str] = None,
                         opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetEndpointServiceResult:
    """
    Data Source schema for Byteplus::PrivateLink::EndpointService


    :param builtins.str id: Uniquely identifies the resource.
    """
    __args__ = dict()
    __args__['id'] = id
    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke('bytepluscc:privatelink/getEndpointService:getEndpointService', __args__, opts=opts, typ=GetEndpointServiceResult).value

    return AwaitableGetEndpointServiceResult(
        auto_accept_enabled=pulumi.get(__ret__, 'auto_accept_enabled'),
        billing_type=pulumi.get(__ret__, 'billing_type'),
        business_status=pulumi.get(__ret__, 'business_status'),
        create_time=pulumi.get(__ret__, 'create_time'),
        description=pulumi.get(__ret__, 'description'),
        id=pulumi.get(__ret__, 'id'),
        ip_address_versions=pulumi.get(__ret__, 'ip_address_versions'),
        payer=pulumi.get(__ret__, 'payer'),
        private_dns_enabled=pulumi.get(__ret__, 'private_dns_enabled'),
        private_dns_name=pulumi.get(__ret__, 'private_dns_name'),
        private_dns_name_configuration=pulumi.get(__ret__, 'private_dns_name_configuration'),
        private_dns_type=pulumi.get(__ret__, 'private_dns_type'),
        project_name=pulumi.get(__ret__, 'project_name'),
        resources=pulumi.get(__ret__, 'resources'),
        service_domain=pulumi.get(__ret__, 'service_domain'),
        service_id=pulumi.get(__ret__, 'service_id'),
        service_name=pulumi.get(__ret__, 'service_name'),
        service_name_managed=pulumi.get(__ret__, 'service_name_managed'),
        service_name_suffix=pulumi.get(__ret__, 'service_name_suffix'),
        service_owner=pulumi.get(__ret__, 'service_owner'),
        service_resource_type=pulumi.get(__ret__, 'service_resource_type'),
        service_type=pulumi.get(__ret__, 'service_type'),
        status=pulumi.get(__ret__, 'status'),
        tags=pulumi.get(__ret__, 'tags'),
        update_time=pulumi.get(__ret__, 'update_time'),
        wildcard_domain_enabled=pulumi.get(__ret__, 'wildcard_domain_enabled'),
        zone_ids=pulumi.get(__ret__, 'zone_ids'))
def get_endpoint_service_output(id: Optional[pulumi.Input[builtins.str]] = None,
                                opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetEndpointServiceResult]:
    """
    Data Source schema for Byteplus::PrivateLink::EndpointService


    :param builtins.str id: Uniquely identifies the resource.
    """
    __args__ = dict()
    __args__['id'] = id
    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke_output('bytepluscc:privatelink/getEndpointService:getEndpointService', __args__, opts=opts, typ=GetEndpointServiceResult)
    return __ret__.apply(lambda __response__: GetEndpointServiceResult(
        auto_accept_enabled=pulumi.get(__response__, 'auto_accept_enabled'),
        billing_type=pulumi.get(__response__, 'billing_type'),
        business_status=pulumi.get(__response__, 'business_status'),
        create_time=pulumi.get(__response__, 'create_time'),
        description=pulumi.get(__response__, 'description'),
        id=pulumi.get(__response__, 'id'),
        ip_address_versions=pulumi.get(__response__, 'ip_address_versions'),
        payer=pulumi.get(__response__, 'payer'),
        private_dns_enabled=pulumi.get(__response__, 'private_dns_enabled'),
        private_dns_name=pulumi.get(__response__, 'private_dns_name'),
        private_dns_name_configuration=pulumi.get(__response__, 'private_dns_name_configuration'),
        private_dns_type=pulumi.get(__response__, 'private_dns_type'),
        project_name=pulumi.get(__response__, 'project_name'),
        resources=pulumi.get(__response__, 'resources'),
        service_domain=pulumi.get(__response__, 'service_domain'),
        service_id=pulumi.get(__response__, 'service_id'),
        service_name=pulumi.get(__response__, 'service_name'),
        service_name_managed=pulumi.get(__response__, 'service_name_managed'),
        service_name_suffix=pulumi.get(__response__, 'service_name_suffix'),
        service_owner=pulumi.get(__response__, 'service_owner'),
        service_resource_type=pulumi.get(__response__, 'service_resource_type'),
        service_type=pulumi.get(__response__, 'service_type'),
        status=pulumi.get(__response__, 'status'),
        tags=pulumi.get(__response__, 'tags'),
        update_time=pulumi.get(__response__, 'update_time'),
        wildcard_domain_enabled=pulumi.get(__response__, 'wildcard_domain_enabled'),
        zone_ids=pulumi.get(__response__, 'zone_ids')))
