# 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__ = [
    'GetDomainResult',
    'AwaitableGetDomainResult',
    'get_domain',
    'get_domain_output',
]

@pulumi.output_type
class GetDomainResult:
    """
    A collection of values returned by getDomain.
    """
    def __init__(__self__, access_mode=None, advanced_defense_ip=None, advanced_defense_ipv6=None, api_enable=None, attack_status=None, auto_cc_enable=None, automatic_black_enable=None, backend_groups=None, black_ip_enable=None, black_lct_enable=None, bot_dytoken_enable=None, bot_frequency_enable=None, bot_repeat_enable=None, bot_sequence_default_action=None, bot_sequence_enable=None, cc_enable=None, certificate_id=None, certificate_name=None, certificate_platform=None, clb_instance_ids=None, clb_listener_id=None, clb_pool_id=None, clb_server_id=None, client_ip_location=None, client_max_body_size=None, cloud_access_configs=None, cname=None, custom_bot_enable=None, custom_headers=None, custom_rsp_enable=None, custom_sni=None, defence_mode=None, dlp_enable=None, domain=None, enable_custom_redirect=None, enable_http2=None, enable_ipv6=None, enable_sni=None, id=None, keep_alive_request=None, keep_alive_timeout=None, lb_algorithm=None, port=None, project_name=None, protocol_follow=None, protocol_ports=None, protocols=None, proxy_config=None, proxy_connect_timeout=None, proxy_keep_alive=None, proxy_keep_alive_timeout=None, proxy_read_timeout=None, proxy_retry=None, proxy_write_timeout=None, public_real_server=None, rsp_abnormal_enable=None, server_ips=None, src_ips=None, src_protocol=None, ssl_ciphers=None, ssl_protocols=None, status=None, system_bot_enable=None, tamper_proof_enable=None, tcp_listener_configs=None, tls_enable=None, tls_fields_config=None, update_time=None, vpc_id=None, waf_enable=None, waf_white_req_enable=None, white_enable=None, white_field_enable=None):
        if access_mode and not isinstance(access_mode, int):
            raise TypeError("Expected argument 'access_mode' to be a int")
        pulumi.set(__self__, "access_mode", access_mode)
        if advanced_defense_ip and not isinstance(advanced_defense_ip, str):
            raise TypeError("Expected argument 'advanced_defense_ip' to be a str")
        pulumi.set(__self__, "advanced_defense_ip", advanced_defense_ip)
        if advanced_defense_ipv6 and not isinstance(advanced_defense_ipv6, str):
            raise TypeError("Expected argument 'advanced_defense_ipv6' to be a str")
        pulumi.set(__self__, "advanced_defense_ipv6", advanced_defense_ipv6)
        if api_enable and not isinstance(api_enable, int):
            raise TypeError("Expected argument 'api_enable' to be a int")
        pulumi.set(__self__, "api_enable", api_enable)
        if attack_status and not isinstance(attack_status, int):
            raise TypeError("Expected argument 'attack_status' to be a int")
        pulumi.set(__self__, "attack_status", attack_status)
        if auto_cc_enable and not isinstance(auto_cc_enable, int):
            raise TypeError("Expected argument 'auto_cc_enable' to be a int")
        pulumi.set(__self__, "auto_cc_enable", auto_cc_enable)
        if automatic_black_enable and not isinstance(automatic_black_enable, int):
            raise TypeError("Expected argument 'automatic_black_enable' to be a int")
        pulumi.set(__self__, "automatic_black_enable", automatic_black_enable)
        if backend_groups and not isinstance(backend_groups, list):
            raise TypeError("Expected argument 'backend_groups' to be a list")
        pulumi.set(__self__, "backend_groups", backend_groups)
        if black_ip_enable and not isinstance(black_ip_enable, int):
            raise TypeError("Expected argument 'black_ip_enable' to be a int")
        pulumi.set(__self__, "black_ip_enable", black_ip_enable)
        if black_lct_enable and not isinstance(black_lct_enable, int):
            raise TypeError("Expected argument 'black_lct_enable' to be a int")
        pulumi.set(__self__, "black_lct_enable", black_lct_enable)
        if bot_dytoken_enable and not isinstance(bot_dytoken_enable, int):
            raise TypeError("Expected argument 'bot_dytoken_enable' to be a int")
        pulumi.set(__self__, "bot_dytoken_enable", bot_dytoken_enable)
        if bot_frequency_enable and not isinstance(bot_frequency_enable, int):
            raise TypeError("Expected argument 'bot_frequency_enable' to be a int")
        pulumi.set(__self__, "bot_frequency_enable", bot_frequency_enable)
        if bot_repeat_enable and not isinstance(bot_repeat_enable, int):
            raise TypeError("Expected argument 'bot_repeat_enable' to be a int")
        pulumi.set(__self__, "bot_repeat_enable", bot_repeat_enable)
        if bot_sequence_default_action and not isinstance(bot_sequence_default_action, int):
            raise TypeError("Expected argument 'bot_sequence_default_action' to be a int")
        pulumi.set(__self__, "bot_sequence_default_action", bot_sequence_default_action)
        if bot_sequence_enable and not isinstance(bot_sequence_enable, int):
            raise TypeError("Expected argument 'bot_sequence_enable' to be a int")
        pulumi.set(__self__, "bot_sequence_enable", bot_sequence_enable)
        if cc_enable and not isinstance(cc_enable, int):
            raise TypeError("Expected argument 'cc_enable' to be a int")
        pulumi.set(__self__, "cc_enable", cc_enable)
        if certificate_id and not isinstance(certificate_id, str):
            raise TypeError("Expected argument 'certificate_id' to be a str")
        pulumi.set(__self__, "certificate_id", certificate_id)
        if certificate_name and not isinstance(certificate_name, str):
            raise TypeError("Expected argument 'certificate_name' to be a str")
        pulumi.set(__self__, "certificate_name", certificate_name)
        if certificate_platform and not isinstance(certificate_platform, str):
            raise TypeError("Expected argument 'certificate_platform' to be a str")
        pulumi.set(__self__, "certificate_platform", certificate_platform)
        if clb_instance_ids and not isinstance(clb_instance_ids, str):
            raise TypeError("Expected argument 'clb_instance_ids' to be a str")
        pulumi.set(__self__, "clb_instance_ids", clb_instance_ids)
        if clb_listener_id and not isinstance(clb_listener_id, str):
            raise TypeError("Expected argument 'clb_listener_id' to be a str")
        pulumi.set(__self__, "clb_listener_id", clb_listener_id)
        if clb_pool_id and not isinstance(clb_pool_id, str):
            raise TypeError("Expected argument 'clb_pool_id' to be a str")
        pulumi.set(__self__, "clb_pool_id", clb_pool_id)
        if clb_server_id and not isinstance(clb_server_id, str):
            raise TypeError("Expected argument 'clb_server_id' to be a str")
        pulumi.set(__self__, "clb_server_id", clb_server_id)
        if client_ip_location and not isinstance(client_ip_location, int):
            raise TypeError("Expected argument 'client_ip_location' to be a int")
        pulumi.set(__self__, "client_ip_location", client_ip_location)
        if client_max_body_size and not isinstance(client_max_body_size, int):
            raise TypeError("Expected argument 'client_max_body_size' to be a int")
        pulumi.set(__self__, "client_max_body_size", client_max_body_size)
        if cloud_access_configs and not isinstance(cloud_access_configs, list):
            raise TypeError("Expected argument 'cloud_access_configs' to be a list")
        pulumi.set(__self__, "cloud_access_configs", cloud_access_configs)
        if cname and not isinstance(cname, str):
            raise TypeError("Expected argument 'cname' to be a str")
        pulumi.set(__self__, "cname", cname)
        if custom_bot_enable and not isinstance(custom_bot_enable, int):
            raise TypeError("Expected argument 'custom_bot_enable' to be a int")
        pulumi.set(__self__, "custom_bot_enable", custom_bot_enable)
        if custom_headers and not isinstance(custom_headers, list):
            raise TypeError("Expected argument 'custom_headers' to be a list")
        pulumi.set(__self__, "custom_headers", custom_headers)
        if custom_rsp_enable and not isinstance(custom_rsp_enable, int):
            raise TypeError("Expected argument 'custom_rsp_enable' to be a int")
        pulumi.set(__self__, "custom_rsp_enable", custom_rsp_enable)
        if custom_sni and not isinstance(custom_sni, str):
            raise TypeError("Expected argument 'custom_sni' to be a str")
        pulumi.set(__self__, "custom_sni", custom_sni)
        if defence_mode and not isinstance(defence_mode, int):
            raise TypeError("Expected argument 'defence_mode' to be a int")
        pulumi.set(__self__, "defence_mode", defence_mode)
        if dlp_enable and not isinstance(dlp_enable, int):
            raise TypeError("Expected argument 'dlp_enable' to be a int")
        pulumi.set(__self__, "dlp_enable", dlp_enable)
        if domain and not isinstance(domain, str):
            raise TypeError("Expected argument 'domain' to be a str")
        pulumi.set(__self__, "domain", domain)
        if enable_custom_redirect and not isinstance(enable_custom_redirect, int):
            raise TypeError("Expected argument 'enable_custom_redirect' to be a int")
        pulumi.set(__self__, "enable_custom_redirect", enable_custom_redirect)
        if enable_http2 and not isinstance(enable_http2, int):
            raise TypeError("Expected argument 'enable_http2' to be a int")
        pulumi.set(__self__, "enable_http2", enable_http2)
        if enable_ipv6 and not isinstance(enable_ipv6, int):
            raise TypeError("Expected argument 'enable_ipv6' to be a int")
        pulumi.set(__self__, "enable_ipv6", enable_ipv6)
        if enable_sni and not isinstance(enable_sni, int):
            raise TypeError("Expected argument 'enable_sni' to be a int")
        pulumi.set(__self__, "enable_sni", enable_sni)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if keep_alive_request and not isinstance(keep_alive_request, int):
            raise TypeError("Expected argument 'keep_alive_request' to be a int")
        pulumi.set(__self__, "keep_alive_request", keep_alive_request)
        if keep_alive_timeout and not isinstance(keep_alive_timeout, int):
            raise TypeError("Expected argument 'keep_alive_timeout' to be a int")
        pulumi.set(__self__, "keep_alive_timeout", keep_alive_timeout)
        if lb_algorithm and not isinstance(lb_algorithm, str):
            raise TypeError("Expected argument 'lb_algorithm' to be a str")
        pulumi.set(__self__, "lb_algorithm", lb_algorithm)
        if port and not isinstance(port, int):
            raise TypeError("Expected argument 'port' to be a int")
        pulumi.set(__self__, "port", port)
        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 protocol_follow and not isinstance(protocol_follow, int):
            raise TypeError("Expected argument 'protocol_follow' to be a int")
        pulumi.set(__self__, "protocol_follow", protocol_follow)
        if protocol_ports and not isinstance(protocol_ports, dict):
            raise TypeError("Expected argument 'protocol_ports' to be a dict")
        pulumi.set(__self__, "protocol_ports", protocol_ports)
        if protocols and not isinstance(protocols, list):
            raise TypeError("Expected argument 'protocols' to be a list")
        pulumi.set(__self__, "protocols", protocols)
        if proxy_config and not isinstance(proxy_config, int):
            raise TypeError("Expected argument 'proxy_config' to be a int")
        pulumi.set(__self__, "proxy_config", proxy_config)
        if proxy_connect_timeout and not isinstance(proxy_connect_timeout, int):
            raise TypeError("Expected argument 'proxy_connect_timeout' to be a int")
        pulumi.set(__self__, "proxy_connect_timeout", proxy_connect_timeout)
        if proxy_keep_alive and not isinstance(proxy_keep_alive, int):
            raise TypeError("Expected argument 'proxy_keep_alive' to be a int")
        pulumi.set(__self__, "proxy_keep_alive", proxy_keep_alive)
        if proxy_keep_alive_timeout and not isinstance(proxy_keep_alive_timeout, int):
            raise TypeError("Expected argument 'proxy_keep_alive_timeout' to be a int")
        pulumi.set(__self__, "proxy_keep_alive_timeout", proxy_keep_alive_timeout)
        if proxy_read_timeout and not isinstance(proxy_read_timeout, int):
            raise TypeError("Expected argument 'proxy_read_timeout' to be a int")
        pulumi.set(__self__, "proxy_read_timeout", proxy_read_timeout)
        if proxy_retry and not isinstance(proxy_retry, int):
            raise TypeError("Expected argument 'proxy_retry' to be a int")
        pulumi.set(__self__, "proxy_retry", proxy_retry)
        if proxy_write_timeout and not isinstance(proxy_write_timeout, int):
            raise TypeError("Expected argument 'proxy_write_timeout' to be a int")
        pulumi.set(__self__, "proxy_write_timeout", proxy_write_timeout)
        if public_real_server and not isinstance(public_real_server, int):
            raise TypeError("Expected argument 'public_real_server' to be a int")
        pulumi.set(__self__, "public_real_server", public_real_server)
        if rsp_abnormal_enable and not isinstance(rsp_abnormal_enable, int):
            raise TypeError("Expected argument 'rsp_abnormal_enable' to be a int")
        pulumi.set(__self__, "rsp_abnormal_enable", rsp_abnormal_enable)
        if server_ips and not isinstance(server_ips, str):
            raise TypeError("Expected argument 'server_ips' to be a str")
        pulumi.set(__self__, "server_ips", server_ips)
        if src_ips and not isinstance(src_ips, str):
            raise TypeError("Expected argument 'src_ips' to be a str")
        pulumi.set(__self__, "src_ips", src_ips)
        if src_protocol and not isinstance(src_protocol, str):
            raise TypeError("Expected argument 'src_protocol' to be a str")
        pulumi.set(__self__, "src_protocol", src_protocol)
        if ssl_ciphers and not isinstance(ssl_ciphers, list):
            raise TypeError("Expected argument 'ssl_ciphers' to be a list")
        pulumi.set(__self__, "ssl_ciphers", ssl_ciphers)
        if ssl_protocols and not isinstance(ssl_protocols, list):
            raise TypeError("Expected argument 'ssl_protocols' to be a list")
        pulumi.set(__self__, "ssl_protocols", ssl_protocols)
        if status and not isinstance(status, int):
            raise TypeError("Expected argument 'status' to be a int")
        pulumi.set(__self__, "status", status)
        if system_bot_enable and not isinstance(system_bot_enable, int):
            raise TypeError("Expected argument 'system_bot_enable' to be a int")
        pulumi.set(__self__, "system_bot_enable", system_bot_enable)
        if tamper_proof_enable and not isinstance(tamper_proof_enable, int):
            raise TypeError("Expected argument 'tamper_proof_enable' to be a int")
        pulumi.set(__self__, "tamper_proof_enable", tamper_proof_enable)
        if tcp_listener_configs and not isinstance(tcp_listener_configs, list):
            raise TypeError("Expected argument 'tcp_listener_configs' to be a list")
        pulumi.set(__self__, "tcp_listener_configs", tcp_listener_configs)
        if tls_enable and not isinstance(tls_enable, int):
            raise TypeError("Expected argument 'tls_enable' to be a int")
        pulumi.set(__self__, "tls_enable", tls_enable)
        if tls_fields_config and not isinstance(tls_fields_config, dict):
            raise TypeError("Expected argument 'tls_fields_config' to be a dict")
        pulumi.set(__self__, "tls_fields_config", tls_fields_config)
        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 vpc_id and not isinstance(vpc_id, str):
            raise TypeError("Expected argument 'vpc_id' to be a str")
        pulumi.set(__self__, "vpc_id", vpc_id)
        if waf_enable and not isinstance(waf_enable, int):
            raise TypeError("Expected argument 'waf_enable' to be a int")
        pulumi.set(__self__, "waf_enable", waf_enable)
        if waf_white_req_enable and not isinstance(waf_white_req_enable, int):
            raise TypeError("Expected argument 'waf_white_req_enable' to be a int")
        pulumi.set(__self__, "waf_white_req_enable", waf_white_req_enable)
        if white_enable and not isinstance(white_enable, int):
            raise TypeError("Expected argument 'white_enable' to be a int")
        pulumi.set(__self__, "white_enable", white_enable)
        if white_field_enable and not isinstance(white_field_enable, int):
            raise TypeError("Expected argument 'white_field_enable' to be a int")
        pulumi.set(__self__, "white_field_enable", white_field_enable)

    @property
    @pulumi.getter(name="accessMode")
    def access_mode(self) -> builtins.int:
        """
        接入模式。10：CNAME 接入，11：负载均衡（CLB）7 层接入。
        """
        return pulumi.get(self, "access_mode")

    @property
    @pulumi.getter(name="advancedDefenseIp")
    def advanced_defense_ip(self) -> builtins.str:
        """
        高防实例 IP。高防型 WAF 接入展示，否则为空。
        """
        return pulumi.get(self, "advanced_defense_ip")

    @property
    @pulumi.getter(name="advancedDefenseIpv6")
    def advanced_defense_ipv6(self) -> builtins.str:
        """
        高防实例 Ipv6。高防型 WAF 接入展示，否则为空。
        """
        return pulumi.get(self, "advanced_defense_ipv6")

    @property
    @pulumi.getter(name="apiEnable")
    def api_enable(self) -> builtins.int:
        """
        是否开启了 API 防护策略。0：关闭，1：开启。
        """
        return pulumi.get(self, "api_enable")

    @property
    @pulumi.getter(name="attackStatus")
    def attack_status(self) -> builtins.int:
        """
        攻击状态。0:未发现攻击,1:发现攻击。
        """
        return pulumi.get(self, "attack_status")

    @property
    @pulumi.getter(name="autoCcEnable")
    def auto_cc_enable(self) -> builtins.int:
        """
        是否开启智能 CC 防护策略。0：关闭，1：开启。
        """
        return pulumi.get(self, "auto_cc_enable")

    @property
    @pulumi.getter(name="automaticBlackEnable")
    def automatic_black_enable(self) -> builtins.int:
        """
        是否开启自动封禁。0：关闭，1：开启。
        """
        return pulumi.get(self, "automatic_black_enable")

    @property
    @pulumi.getter(name="backendGroups")
    def backend_groups(self) -> Sequence['outputs.GetDomainBackendGroupResult']:
        """
        源站配置。
        """
        return pulumi.get(self, "backend_groups")

    @property
    @pulumi.getter(name="blackIpEnable")
    def black_ip_enable(self) -> builtins.int:
        """
        是否开启了黑名单策略。0：关闭, 1：开启。
        """
        return pulumi.get(self, "black_ip_enable")

    @property
    @pulumi.getter(name="blackLctEnable")
    def black_lct_enable(self) -> builtins.int:
        """
        是否开启了区域封禁策略。0：关闭;1：开启。
        """
        return pulumi.get(self, "black_lct_enable")

    @property
    @pulumi.getter(name="botDytokenEnable")
    def bot_dytoken_enable(self) -> builtins.int:
        """
        是否开启动态Token防护。
        """
        return pulumi.get(self, "bot_dytoken_enable")

    @property
    @pulumi.getter(name="botFrequencyEnable")
    def bot_frequency_enable(self) -> builtins.int:
        """
        是否开启 bot 频率限制策略。
        0：关闭
        1：开启。
        """
        return pulumi.get(self, "bot_frequency_enable")

    @property
    @pulumi.getter(name="botRepeatEnable")
    def bot_repeat_enable(self) -> builtins.int:
        """
        是否开启 bot 统计防护策略。
        0：关闭
        1：开启。
        """
        return pulumi.get(self, "bot_repeat_enable")

    @property
    @pulumi.getter(name="botSequenceDefaultAction")
    def bot_sequence_default_action(self) -> builtins.int:
        """
        设置 bot 行为地图策略默认动作，当 BotSequenceEnable = 1 开启状态时生效。默认为 0 （观察）。
        0：观察
        2：拦截
        6：JS 挑战
        7：人机验证。
        """
        return pulumi.get(self, "bot_sequence_default_action")

    @property
    @pulumi.getter(name="botSequenceEnable")
    def bot_sequence_enable(self) -> builtins.int:
        """
        是否开启 bot 行为地图。
        0：关闭
        1：开启。
        """
        return pulumi.get(self, "bot_sequence_enable")

    @property
    @pulumi.getter(name="ccEnable")
    def cc_enable(self) -> builtins.int:
        """
        是否开启 CC 防护策略。
        0：关闭
        1：开启。
        """
        return pulumi.get(self, "cc_enable")

    @property
    @pulumi.getter(name="certificateId")
    def certificate_id(self) -> builtins.str:
        """
        托管至证书中心的证书ID。
        """
        return pulumi.get(self, "certificate_id")

    @property
    @pulumi.getter(name="certificateName")
    def certificate_name(self) -> builtins.str:
        """
        证书名称，协议类型包含 HTTPS 时显示。
        """
        return pulumi.get(self, "certificate_name")

    @property
    @pulumi.getter(name="certificatePlatform")
    def certificate_platform(self) -> builtins.str:
        """
        证书托管平台:waf/certificate_service。
        """
        return pulumi.get(self, "certificate_platform")

    @property
    @pulumi.getter(name="clbInstanceIds")
    def clb_instance_ids(self) -> builtins.str:
        """
        CLB实例ID。
        """
        return pulumi.get(self, "clb_instance_ids")

    @property
    @pulumi.getter(name="clbListenerId")
    def clb_listener_id(self) -> builtins.str:
        """
        CLB监听器ID。
        """
        return pulumi.get(self, "clb_listener_id")

    @property
    @pulumi.getter(name="clbPoolId")
    def clb_pool_id(self) -> builtins.str:
        """
        CLB后端服务器组ID。
        """
        return pulumi.get(self, "clb_pool_id")

    @property
    @pulumi.getter(name="clbServerId")
    def clb_server_id(self) -> builtins.str:
        """
        CLB后端服务器ID。
        """
        return pulumi.get(self, "clb_server_id")

    @property
    @pulumi.getter(name="clientIpLocation")
    def client_ip_location(self) -> builtins.int:
        """
        客户端IP获取方式。0:自定义Header字段,1:通过X-Forwarded-For(XFF)字段中第一个公网IP地址作为客户端真实IP地址。
        """
        return pulumi.get(self, "client_ip_location")

    @property
    @pulumi.getter(name="clientMaxBodySize")
    def client_max_body_size(self) -> builtins.int:
        """
        客户端请求body最大值(MB)。
        """
        return pulumi.get(self, "client_max_body_size")

    @property
    @pulumi.getter(name="cloudAccessConfigs")
    def cloud_access_configs(self) -> Sequence['outputs.GetDomainCloudAccessConfigResult']:
        """
        LB接入参数。
        """
        return pulumi.get(self, "cloud_access_configs")

    @property
    @pulumi.getter
    def cname(self) -> builtins.str:
        """
        CNAME记录。
        """
        return pulumi.get(self, "cname")

    @property
    @pulumi.getter(name="customBotEnable")
    def custom_bot_enable(self) -> builtins.int:
        """
        是否开启自定义BOT防护。
        """
        return pulumi.get(self, "custom_bot_enable")

    @property
    @pulumi.getter(name="customHeaders")
    def custom_headers(self) -> Sequence[builtins.str]:
        """
        自定义Header。
        """
        return pulumi.get(self, "custom_headers")

    @property
    @pulumi.getter(name="customRspEnable")
    def custom_rsp_enable(self) -> builtins.int:
        """
        是否开启自定义响应。
        """
        return pulumi.get(self, "custom_rsp_enable")

    @property
    @pulumi.getter(name="customSni")
    def custom_sni(self) -> builtins.str:
        """
        自定义SNI。
        """
        return pulumi.get(self, "custom_sni")

    @property
    @pulumi.getter(name="defenceMode")
    def defence_mode(self) -> builtins.int:
        """
        为例外 ALB 实例设置防护模式。
        1：启用防护，已配置的防护策略生效。
        2：暂停防护，仅执行转发而不检测，已配置的防护策略不生效。
        3：回源模式，直接将请求解析至源站，不再转发至 WAF 实例。
        设置例外防护实例后，域名可能还会存在以下防护状态：
        5：部分启用，默认防护模式为启用防护，但存在例外实例为暂停防护或回源模式状态。
        6：部分暂停，默认防护模式为暂停防护，但存在例外实例为启用防护或回源模式状态。
        7：部分回源，默认防护模式为回源模式，但存在例外实例为启用防护或暂停防护状态。
        """
        return pulumi.get(self, "defence_mode")

    @property
    @pulumi.getter(name="dlpEnable")
    def dlp_enable(self) -> builtins.int:
        """
        是否开启数据泄露防护。
        """
        return pulumi.get(self, "dlp_enable")

    @property
    @pulumi.getter
    def domain(self) -> builtins.str:
        """
        防护的域名信息，支持泛域名和精确域名。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter(name="enableCustomRedirect")
    def enable_custom_redirect(self) -> builtins.int:
        """
        是否开启用户自定义重定向。0:关闭,1:开启。
        """
        return pulumi.get(self, "enable_custom_redirect")

    @property
    @pulumi.getter(name="enableHttp2")
    def enable_http2(self) -> builtins.int:
        """
        是否开启HTTP2.0。0:关闭,1:开启。
        """
        return pulumi.get(self, "enable_http2")

    @property
    @pulumi.getter(name="enableIpv6")
    def enable_ipv6(self) -> builtins.int:
        """
        是否支持防护Ipv6请求。0:关闭,1:开启。
        """
        return pulumi.get(self, "enable_ipv6")

    @property
    @pulumi.getter(name="enableSni")
    def enable_sni(self) -> builtins.int:
        """
        是否开启SNI配置。0:关闭,1:开启。
        """
        return pulumi.get(self, "enable_sni")

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

    @property
    @pulumi.getter(name="keepAliveRequest")
    def keep_alive_request(self) -> builtins.int:
        """
        长连接复用个数。
        """
        return pulumi.get(self, "keep_alive_request")

    @property
    @pulumi.getter(name="keepAliveTimeout")
    def keep_alive_timeout(self) -> builtins.int:
        """
        长连接保持时间(秒)。
        """
        return pulumi.get(self, "keep_alive_timeout")

    @property
    @pulumi.getter(name="lbAlgorithm")
    def lb_algorithm(self) -> builtins.str:
        """
        负载均衡算法类型。wrr:加权轮询,wlc:加权最小连接数,sh:源地址哈希。
        """
        return pulumi.get(self, "lb_algorithm")

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

    @property
    @pulumi.getter(name="projectName")
    def project_name(self) -> builtins.str:
        """
        项目名称。
        """
        return pulumi.get(self, "project_name")

    @property
    @pulumi.getter(name="protocolFollow")
    def protocol_follow(self) -> builtins.int:
        """
        是否开启协议跟随。0:关闭,1:开启。
        """
        return pulumi.get(self, "protocol_follow")

    @property
    @pulumi.getter(name="protocolPorts")
    def protocol_ports(self) -> 'outputs.GetDomainProtocolPortsResult':
        """
        接入端口信息。
        """
        return pulumi.get(self, "protocol_ports")

    @property
    @pulumi.getter
    def protocols(self) -> Sequence[builtins.str]:
        """
        接入协议类型,支持HTTP/HTTPS。
        """
        return pulumi.get(self, "protocols")

    @property
    @pulumi.getter(name="proxyConfig")
    def proxy_config(self) -> builtins.int:
        """
        是否开启代理配置。0:关闭,1:开启。
        """
        return pulumi.get(self, "proxy_config")

    @property
    @pulumi.getter(name="proxyConnectTimeout")
    def proxy_connect_timeout(self) -> builtins.int:
        """
        WAF和后端服务器的建连超时时间(秒)。
        """
        return pulumi.get(self, "proxy_connect_timeout")

    @property
    @pulumi.getter(name="proxyKeepAlive")
    def proxy_keep_alive(self) -> builtins.int:
        """
        WAF回源长连接可复用个数。
        """
        return pulumi.get(self, "proxy_keep_alive")

    @property
    @pulumi.getter(name="proxyKeepAliveTimeout")
    def proxy_keep_alive_timeout(self) -> builtins.int:
        """
        空闲长连接超时时间(秒)。
        """
        return pulumi.get(self, "proxy_keep_alive_timeout")

    @property
    @pulumi.getter(name="proxyReadTimeout")
    def proxy_read_timeout(self) -> builtins.int:
        """
        WAF从后端服务器读取响应的超时时间(秒)。
        """
        return pulumi.get(self, "proxy_read_timeout")

    @property
    @pulumi.getter(name="proxyRetry")
    def proxy_retry(self) -> builtins.int:
        """
        WAF回源重试次数。
        """
        return pulumi.get(self, "proxy_retry")

    @property
    @pulumi.getter(name="proxyWriteTimeout")
    def proxy_write_timeout(self) -> builtins.int:
        """
        WAF将请求传输到后端服务器的超时时间(秒)。
        """
        return pulumi.get(self, "proxy_write_timeout")

    @property
    @pulumi.getter(name="publicRealServer")
    def public_real_server(self) -> builtins.int:
        """
        CNAME接入回源方式。0:私网回源,1:公网回源。
        """
        return pulumi.get(self, "public_real_server")

    @property
    @pulumi.getter(name="rspAbnormalEnable")
    def rsp_abnormal_enable(self) -> builtins.int:
        """
        是否开启异常响应防护。
        """
        return pulumi.get(self, "rsp_abnormal_enable")

    @property
    @pulumi.getter(name="serverIps")
    def server_ips(self) -> builtins.str:
        """
        服务IP。
        """
        return pulumi.get(self, "server_ips")

    @property
    @pulumi.getter(name="srcIps")
    def src_ips(self) -> builtins.str:
        """
        WAF回源IP。
        """
        return pulumi.get(self, "src_ips")

    @property
    @pulumi.getter(name="srcProtocol")
    def src_protocol(self) -> builtins.str:
        """
        源站协议。
        """
        return pulumi.get(self, "src_protocol")

    @property
    @pulumi.getter(name="sslCiphers")
    def ssl_ciphers(self) -> Sequence[builtins.str]:
        """
        加密套件。
        """
        return pulumi.get(self, "ssl_ciphers")

    @property
    @pulumi.getter(name="sslProtocols")
    def ssl_protocols(self) -> Sequence[builtins.str]:
        """
        TLS协议版本。如:TLSv1,TLSv1.1,TLSv1.2,TLSv1.3。
        """
        return pulumi.get(self, "ssl_protocols")

    @property
    @pulumi.getter
    def status(self) -> builtins.int:
        """
        接入状态。0:正常,1:DNS未解析,2:配置中,3:配置失败,4:配置未生效,5:更新中,6:实例已删除。
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="systemBotEnable")
    def system_bot_enable(self) -> builtins.int:
        """
        是否开启托管BOT防护。
        """
        return pulumi.get(self, "system_bot_enable")

    @property
    @pulumi.getter(name="tamperProofEnable")
    def tamper_proof_enable(self) -> builtins.int:
        """
        是否开启防篡改。
        """
        return pulumi.get(self, "tamper_proof_enable")

    @property
    @pulumi.getter(name="tcpListenerConfigs")
    def tcp_listener_configs(self) -> Sequence['outputs.GetDomainTcpListenerConfigResult']:
        """
        TCP监听器配置。
        """
        return pulumi.get(self, "tcp_listener_configs")

    @property
    @pulumi.getter(name="tlsEnable")
    def tls_enable(self) -> builtins.int:
        """
        是否开启日志服务。0:关闭,1:开启。
        """
        return pulumi.get(self, "tls_enable")

    @property
    @pulumi.getter(name="tlsFieldsConfig")
    def tls_fields_config(self) -> 'outputs.GetDomainTlsFieldsConfigResult':
        """
        日志字段配置详情。
        """
        return pulumi.get(self, "tls_fields_config")

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

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

    @property
    @pulumi.getter(name="wafEnable")
    def waf_enable(self) -> builtins.int:
        """
        是否开启WAF防护。
        """
        return pulumi.get(self, "waf_enable")

    @property
    @pulumi.getter(name="wafWhiteReqEnable")
    def waf_white_req_enable(self) -> builtins.int:
        """
        是否开启白名单请求防护。
        """
        return pulumi.get(self, "waf_white_req_enable")

    @property
    @pulumi.getter(name="whiteEnable")
    def white_enable(self) -> builtins.int:
        """
        是否开启白名单防护。
        """
        return pulumi.get(self, "white_enable")

    @property
    @pulumi.getter(name="whiteFieldEnable")
    def white_field_enable(self) -> builtins.int:
        """
        是否开启字段白名单防护。
        """
        return pulumi.get(self, "white_field_enable")


class AwaitableGetDomainResult(GetDomainResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetDomainResult(
            access_mode=self.access_mode,
            advanced_defense_ip=self.advanced_defense_ip,
            advanced_defense_ipv6=self.advanced_defense_ipv6,
            api_enable=self.api_enable,
            attack_status=self.attack_status,
            auto_cc_enable=self.auto_cc_enable,
            automatic_black_enable=self.automatic_black_enable,
            backend_groups=self.backend_groups,
            black_ip_enable=self.black_ip_enable,
            black_lct_enable=self.black_lct_enable,
            bot_dytoken_enable=self.bot_dytoken_enable,
            bot_frequency_enable=self.bot_frequency_enable,
            bot_repeat_enable=self.bot_repeat_enable,
            bot_sequence_default_action=self.bot_sequence_default_action,
            bot_sequence_enable=self.bot_sequence_enable,
            cc_enable=self.cc_enable,
            certificate_id=self.certificate_id,
            certificate_name=self.certificate_name,
            certificate_platform=self.certificate_platform,
            clb_instance_ids=self.clb_instance_ids,
            clb_listener_id=self.clb_listener_id,
            clb_pool_id=self.clb_pool_id,
            clb_server_id=self.clb_server_id,
            client_ip_location=self.client_ip_location,
            client_max_body_size=self.client_max_body_size,
            cloud_access_configs=self.cloud_access_configs,
            cname=self.cname,
            custom_bot_enable=self.custom_bot_enable,
            custom_headers=self.custom_headers,
            custom_rsp_enable=self.custom_rsp_enable,
            custom_sni=self.custom_sni,
            defence_mode=self.defence_mode,
            dlp_enable=self.dlp_enable,
            domain=self.domain,
            enable_custom_redirect=self.enable_custom_redirect,
            enable_http2=self.enable_http2,
            enable_ipv6=self.enable_ipv6,
            enable_sni=self.enable_sni,
            id=self.id,
            keep_alive_request=self.keep_alive_request,
            keep_alive_timeout=self.keep_alive_timeout,
            lb_algorithm=self.lb_algorithm,
            port=self.port,
            project_name=self.project_name,
            protocol_follow=self.protocol_follow,
            protocol_ports=self.protocol_ports,
            protocols=self.protocols,
            proxy_config=self.proxy_config,
            proxy_connect_timeout=self.proxy_connect_timeout,
            proxy_keep_alive=self.proxy_keep_alive,
            proxy_keep_alive_timeout=self.proxy_keep_alive_timeout,
            proxy_read_timeout=self.proxy_read_timeout,
            proxy_retry=self.proxy_retry,
            proxy_write_timeout=self.proxy_write_timeout,
            public_real_server=self.public_real_server,
            rsp_abnormal_enable=self.rsp_abnormal_enable,
            server_ips=self.server_ips,
            src_ips=self.src_ips,
            src_protocol=self.src_protocol,
            ssl_ciphers=self.ssl_ciphers,
            ssl_protocols=self.ssl_protocols,
            status=self.status,
            system_bot_enable=self.system_bot_enable,
            tamper_proof_enable=self.tamper_proof_enable,
            tcp_listener_configs=self.tcp_listener_configs,
            tls_enable=self.tls_enable,
            tls_fields_config=self.tls_fields_config,
            update_time=self.update_time,
            vpc_id=self.vpc_id,
            waf_enable=self.waf_enable,
            waf_white_req_enable=self.waf_white_req_enable,
            white_enable=self.white_enable,
            white_field_enable=self.white_field_enable)


def get_domain(id: Optional[builtins.str] = None,
               opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDomainResult:
    """
    Data Source schema for Byteplus::WAF::Domain


    :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:waf/getDomain:getDomain', __args__, opts=opts, typ=GetDomainResult).value

    return AwaitableGetDomainResult(
        access_mode=pulumi.get(__ret__, 'access_mode'),
        advanced_defense_ip=pulumi.get(__ret__, 'advanced_defense_ip'),
        advanced_defense_ipv6=pulumi.get(__ret__, 'advanced_defense_ipv6'),
        api_enable=pulumi.get(__ret__, 'api_enable'),
        attack_status=pulumi.get(__ret__, 'attack_status'),
        auto_cc_enable=pulumi.get(__ret__, 'auto_cc_enable'),
        automatic_black_enable=pulumi.get(__ret__, 'automatic_black_enable'),
        backend_groups=pulumi.get(__ret__, 'backend_groups'),
        black_ip_enable=pulumi.get(__ret__, 'black_ip_enable'),
        black_lct_enable=pulumi.get(__ret__, 'black_lct_enable'),
        bot_dytoken_enable=pulumi.get(__ret__, 'bot_dytoken_enable'),
        bot_frequency_enable=pulumi.get(__ret__, 'bot_frequency_enable'),
        bot_repeat_enable=pulumi.get(__ret__, 'bot_repeat_enable'),
        bot_sequence_default_action=pulumi.get(__ret__, 'bot_sequence_default_action'),
        bot_sequence_enable=pulumi.get(__ret__, 'bot_sequence_enable'),
        cc_enable=pulumi.get(__ret__, 'cc_enable'),
        certificate_id=pulumi.get(__ret__, 'certificate_id'),
        certificate_name=pulumi.get(__ret__, 'certificate_name'),
        certificate_platform=pulumi.get(__ret__, 'certificate_platform'),
        clb_instance_ids=pulumi.get(__ret__, 'clb_instance_ids'),
        clb_listener_id=pulumi.get(__ret__, 'clb_listener_id'),
        clb_pool_id=pulumi.get(__ret__, 'clb_pool_id'),
        clb_server_id=pulumi.get(__ret__, 'clb_server_id'),
        client_ip_location=pulumi.get(__ret__, 'client_ip_location'),
        client_max_body_size=pulumi.get(__ret__, 'client_max_body_size'),
        cloud_access_configs=pulumi.get(__ret__, 'cloud_access_configs'),
        cname=pulumi.get(__ret__, 'cname'),
        custom_bot_enable=pulumi.get(__ret__, 'custom_bot_enable'),
        custom_headers=pulumi.get(__ret__, 'custom_headers'),
        custom_rsp_enable=pulumi.get(__ret__, 'custom_rsp_enable'),
        custom_sni=pulumi.get(__ret__, 'custom_sni'),
        defence_mode=pulumi.get(__ret__, 'defence_mode'),
        dlp_enable=pulumi.get(__ret__, 'dlp_enable'),
        domain=pulumi.get(__ret__, 'domain'),
        enable_custom_redirect=pulumi.get(__ret__, 'enable_custom_redirect'),
        enable_http2=pulumi.get(__ret__, 'enable_http2'),
        enable_ipv6=pulumi.get(__ret__, 'enable_ipv6'),
        enable_sni=pulumi.get(__ret__, 'enable_sni'),
        id=pulumi.get(__ret__, 'id'),
        keep_alive_request=pulumi.get(__ret__, 'keep_alive_request'),
        keep_alive_timeout=pulumi.get(__ret__, 'keep_alive_timeout'),
        lb_algorithm=pulumi.get(__ret__, 'lb_algorithm'),
        port=pulumi.get(__ret__, 'port'),
        project_name=pulumi.get(__ret__, 'project_name'),
        protocol_follow=pulumi.get(__ret__, 'protocol_follow'),
        protocol_ports=pulumi.get(__ret__, 'protocol_ports'),
        protocols=pulumi.get(__ret__, 'protocols'),
        proxy_config=pulumi.get(__ret__, 'proxy_config'),
        proxy_connect_timeout=pulumi.get(__ret__, 'proxy_connect_timeout'),
        proxy_keep_alive=pulumi.get(__ret__, 'proxy_keep_alive'),
        proxy_keep_alive_timeout=pulumi.get(__ret__, 'proxy_keep_alive_timeout'),
        proxy_read_timeout=pulumi.get(__ret__, 'proxy_read_timeout'),
        proxy_retry=pulumi.get(__ret__, 'proxy_retry'),
        proxy_write_timeout=pulumi.get(__ret__, 'proxy_write_timeout'),
        public_real_server=pulumi.get(__ret__, 'public_real_server'),
        rsp_abnormal_enable=pulumi.get(__ret__, 'rsp_abnormal_enable'),
        server_ips=pulumi.get(__ret__, 'server_ips'),
        src_ips=pulumi.get(__ret__, 'src_ips'),
        src_protocol=pulumi.get(__ret__, 'src_protocol'),
        ssl_ciphers=pulumi.get(__ret__, 'ssl_ciphers'),
        ssl_protocols=pulumi.get(__ret__, 'ssl_protocols'),
        status=pulumi.get(__ret__, 'status'),
        system_bot_enable=pulumi.get(__ret__, 'system_bot_enable'),
        tamper_proof_enable=pulumi.get(__ret__, 'tamper_proof_enable'),
        tcp_listener_configs=pulumi.get(__ret__, 'tcp_listener_configs'),
        tls_enable=pulumi.get(__ret__, 'tls_enable'),
        tls_fields_config=pulumi.get(__ret__, 'tls_fields_config'),
        update_time=pulumi.get(__ret__, 'update_time'),
        vpc_id=pulumi.get(__ret__, 'vpc_id'),
        waf_enable=pulumi.get(__ret__, 'waf_enable'),
        waf_white_req_enable=pulumi.get(__ret__, 'waf_white_req_enable'),
        white_enable=pulumi.get(__ret__, 'white_enable'),
        white_field_enable=pulumi.get(__ret__, 'white_field_enable'))
def get_domain_output(id: Optional[pulumi.Input[builtins.str]] = None,
                      opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDomainResult]:
    """
    Data Source schema for Byteplus::WAF::Domain


    :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:waf/getDomain:getDomain', __args__, opts=opts, typ=GetDomainResult)
    return __ret__.apply(lambda __response__: GetDomainResult(
        access_mode=pulumi.get(__response__, 'access_mode'),
        advanced_defense_ip=pulumi.get(__response__, 'advanced_defense_ip'),
        advanced_defense_ipv6=pulumi.get(__response__, 'advanced_defense_ipv6'),
        api_enable=pulumi.get(__response__, 'api_enable'),
        attack_status=pulumi.get(__response__, 'attack_status'),
        auto_cc_enable=pulumi.get(__response__, 'auto_cc_enable'),
        automatic_black_enable=pulumi.get(__response__, 'automatic_black_enable'),
        backend_groups=pulumi.get(__response__, 'backend_groups'),
        black_ip_enable=pulumi.get(__response__, 'black_ip_enable'),
        black_lct_enable=pulumi.get(__response__, 'black_lct_enable'),
        bot_dytoken_enable=pulumi.get(__response__, 'bot_dytoken_enable'),
        bot_frequency_enable=pulumi.get(__response__, 'bot_frequency_enable'),
        bot_repeat_enable=pulumi.get(__response__, 'bot_repeat_enable'),
        bot_sequence_default_action=pulumi.get(__response__, 'bot_sequence_default_action'),
        bot_sequence_enable=pulumi.get(__response__, 'bot_sequence_enable'),
        cc_enable=pulumi.get(__response__, 'cc_enable'),
        certificate_id=pulumi.get(__response__, 'certificate_id'),
        certificate_name=pulumi.get(__response__, 'certificate_name'),
        certificate_platform=pulumi.get(__response__, 'certificate_platform'),
        clb_instance_ids=pulumi.get(__response__, 'clb_instance_ids'),
        clb_listener_id=pulumi.get(__response__, 'clb_listener_id'),
        clb_pool_id=pulumi.get(__response__, 'clb_pool_id'),
        clb_server_id=pulumi.get(__response__, 'clb_server_id'),
        client_ip_location=pulumi.get(__response__, 'client_ip_location'),
        client_max_body_size=pulumi.get(__response__, 'client_max_body_size'),
        cloud_access_configs=pulumi.get(__response__, 'cloud_access_configs'),
        cname=pulumi.get(__response__, 'cname'),
        custom_bot_enable=pulumi.get(__response__, 'custom_bot_enable'),
        custom_headers=pulumi.get(__response__, 'custom_headers'),
        custom_rsp_enable=pulumi.get(__response__, 'custom_rsp_enable'),
        custom_sni=pulumi.get(__response__, 'custom_sni'),
        defence_mode=pulumi.get(__response__, 'defence_mode'),
        dlp_enable=pulumi.get(__response__, 'dlp_enable'),
        domain=pulumi.get(__response__, 'domain'),
        enable_custom_redirect=pulumi.get(__response__, 'enable_custom_redirect'),
        enable_http2=pulumi.get(__response__, 'enable_http2'),
        enable_ipv6=pulumi.get(__response__, 'enable_ipv6'),
        enable_sni=pulumi.get(__response__, 'enable_sni'),
        id=pulumi.get(__response__, 'id'),
        keep_alive_request=pulumi.get(__response__, 'keep_alive_request'),
        keep_alive_timeout=pulumi.get(__response__, 'keep_alive_timeout'),
        lb_algorithm=pulumi.get(__response__, 'lb_algorithm'),
        port=pulumi.get(__response__, 'port'),
        project_name=pulumi.get(__response__, 'project_name'),
        protocol_follow=pulumi.get(__response__, 'protocol_follow'),
        protocol_ports=pulumi.get(__response__, 'protocol_ports'),
        protocols=pulumi.get(__response__, 'protocols'),
        proxy_config=pulumi.get(__response__, 'proxy_config'),
        proxy_connect_timeout=pulumi.get(__response__, 'proxy_connect_timeout'),
        proxy_keep_alive=pulumi.get(__response__, 'proxy_keep_alive'),
        proxy_keep_alive_timeout=pulumi.get(__response__, 'proxy_keep_alive_timeout'),
        proxy_read_timeout=pulumi.get(__response__, 'proxy_read_timeout'),
        proxy_retry=pulumi.get(__response__, 'proxy_retry'),
        proxy_write_timeout=pulumi.get(__response__, 'proxy_write_timeout'),
        public_real_server=pulumi.get(__response__, 'public_real_server'),
        rsp_abnormal_enable=pulumi.get(__response__, 'rsp_abnormal_enable'),
        server_ips=pulumi.get(__response__, 'server_ips'),
        src_ips=pulumi.get(__response__, 'src_ips'),
        src_protocol=pulumi.get(__response__, 'src_protocol'),
        ssl_ciphers=pulumi.get(__response__, 'ssl_ciphers'),
        ssl_protocols=pulumi.get(__response__, 'ssl_protocols'),
        status=pulumi.get(__response__, 'status'),
        system_bot_enable=pulumi.get(__response__, 'system_bot_enable'),
        tamper_proof_enable=pulumi.get(__response__, 'tamper_proof_enable'),
        tcp_listener_configs=pulumi.get(__response__, 'tcp_listener_configs'),
        tls_enable=pulumi.get(__response__, 'tls_enable'),
        tls_fields_config=pulumi.get(__response__, 'tls_fields_config'),
        update_time=pulumi.get(__response__, 'update_time'),
        vpc_id=pulumi.get(__response__, 'vpc_id'),
        waf_enable=pulumi.get(__response__, 'waf_enable'),
        waf_white_req_enable=pulumi.get(__response__, 'waf_white_req_enable'),
        white_enable=pulumi.get(__response__, 'white_enable'),
        white_field_enable=pulumi.get(__response__, 'white_field_enable')))
