# 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 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__ = [
    'DomainAuthConfigArgs',
    'DomainAuthConfigArgsDict',
    'DomainCacheConfigArgs',
    'DomainCacheConfigArgsDict',
    'DomainCertificateConfigArgs',
    'DomainCertificateConfigArgsDict',
    'DomainConfigFunctionArgArgs',
    'DomainConfigFunctionArgArgsDict',
    'DomainHttpHeaderConfigArgs',
    'DomainHttpHeaderConfigArgsDict',
    'DomainNewCertificateConfigArgs',
    'DomainNewCertificateConfigArgsDict',
    'DomainNewSourceArgs',
    'DomainNewSourceArgsDict',
    'DomainPage404ConfigArgs',
    'DomainPage404ConfigArgsDict',
    'DomainParameterFilterConfigArgs',
    'DomainParameterFilterConfigArgsDict',
    'DomainReferConfigArgs',
    'DomainReferConfigArgsDict',
]

MYPY = False

if not MYPY:
    class DomainAuthConfigArgsDict(TypedDict):
        auth_type: NotRequired[pulumi.Input[str]]
        master_key: NotRequired[pulumi.Input[str]]
        slave_key: NotRequired[pulumi.Input[str]]
        timeout: NotRequired[pulumi.Input[int]]
elif False:
    DomainAuthConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DomainAuthConfigArgs:
    def __init__(__self__, *,
                 auth_type: Optional[pulumi.Input[str]] = None,
                 master_key: Optional[pulumi.Input[str]] = None,
                 slave_key: Optional[pulumi.Input[str]] = None,
                 timeout: Optional[pulumi.Input[int]] = None):
        if auth_type is not None:
            pulumi.set(__self__, "auth_type", auth_type)
        if master_key is not None:
            pulumi.set(__self__, "master_key", master_key)
        if slave_key is not None:
            pulumi.set(__self__, "slave_key", slave_key)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

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

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

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

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

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

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

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "timeout")

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


if not MYPY:
    class DomainCacheConfigArgsDict(TypedDict):
        cache_content: pulumi.Input[str]
        cache_type: pulumi.Input[str]
        ttl: pulumi.Input[int]
        cache_id: NotRequired[pulumi.Input[str]]
        weight: NotRequired[pulumi.Input[int]]
elif False:
    DomainCacheConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DomainCacheConfigArgs:
    def __init__(__self__, *,
                 cache_content: pulumi.Input[str],
                 cache_type: pulumi.Input[str],
                 ttl: pulumi.Input[int],
                 cache_id: Optional[pulumi.Input[str]] = None,
                 weight: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "cache_content", cache_content)
        pulumi.set(__self__, "cache_type", cache_type)
        pulumi.set(__self__, "ttl", ttl)
        if cache_id is not None:
            pulumi.set(__self__, "cache_id", cache_id)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="cacheContent")
    def cache_content(self) -> pulumi.Input[str]:
        return pulumi.get(self, "cache_content")

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

    @property
    @pulumi.getter(name="cacheType")
    def cache_type(self) -> pulumi.Input[str]:
        return pulumi.get(self, "cache_type")

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

    @property
    @pulumi.getter
    def ttl(self) -> pulumi.Input[int]:
        return pulumi.get(self, "ttl")

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

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

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

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "weight")

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


if not MYPY:
    class DomainCertificateConfigArgsDict(TypedDict):
        private_key: NotRequired[pulumi.Input[str]]
        server_certificate: NotRequired[pulumi.Input[str]]
        server_certificate_status: NotRequired[pulumi.Input[str]]
elif False:
    DomainCertificateConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DomainCertificateConfigArgs:
    def __init__(__self__, *,
                 private_key: Optional[pulumi.Input[str]] = None,
                 server_certificate: Optional[pulumi.Input[str]] = None,
                 server_certificate_status: Optional[pulumi.Input[str]] = None):
        if private_key is not None:
            pulumi.set(__self__, "private_key", private_key)
        if server_certificate is not None:
            pulumi.set(__self__, "server_certificate", server_certificate)
        if server_certificate_status is not None:
            pulumi.set(__self__, "server_certificate_status", server_certificate_status)

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

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

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

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

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

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


if not MYPY:
    class DomainConfigFunctionArgArgsDict(TypedDict):
        arg_name: pulumi.Input[str]
        """
        The name of arg.
        """
        arg_value: pulumi.Input[str]
        """
        The value of arg.
        """
elif False:
    DomainConfigFunctionArgArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DomainConfigFunctionArgArgs:
    def __init__(__self__, *,
                 arg_name: pulumi.Input[str],
                 arg_value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] arg_name: The name of arg.
        :param pulumi.Input[str] arg_value: The value of arg.
        """
        pulumi.set(__self__, "arg_name", arg_name)
        pulumi.set(__self__, "arg_value", arg_value)

    @property
    @pulumi.getter(name="argName")
    def arg_name(self) -> pulumi.Input[str]:
        """
        The name of arg.
        """
        return pulumi.get(self, "arg_name")

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

    @property
    @pulumi.getter(name="argValue")
    def arg_value(self) -> pulumi.Input[str]:
        """
        The value of arg.
        """
        return pulumi.get(self, "arg_value")

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


if not MYPY:
    class DomainHttpHeaderConfigArgsDict(TypedDict):
        header_key: pulumi.Input[str]
        header_value: pulumi.Input[str]
        header_id: NotRequired[pulumi.Input[str]]
elif False:
    DomainHttpHeaderConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DomainHttpHeaderConfigArgs:
    def __init__(__self__, *,
                 header_key: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 header_id: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "header_key", header_key)
        pulumi.set(__self__, "header_value", header_value)
        if header_id is not None:
            pulumi.set(__self__, "header_id", header_id)

    @property
    @pulumi.getter(name="headerKey")
    def header_key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "header_key")

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

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        return pulumi.get(self, "header_value")

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

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

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


if not MYPY:
    class DomainNewCertificateConfigArgsDict(TypedDict):
        cert_id: NotRequired[pulumi.Input[str]]
        """
        The ID of the certificate. It takes effect only when CertType = cas.
        """
        cert_name: NotRequired[pulumi.Input[str]]
        """
        Certificate name, only flyer names are supported.
        """
        cert_region: NotRequired[pulumi.Input[str]]
        """
        The certificate region, which takes effect only when CertType = cas, supports cn-hangzhou (domestic) and ap-southeast-1 (International), and is cn-hangzhou by default.
        """
        cert_type: NotRequired[pulumi.Input[str]]
        """
        Certificate type. Value:
        - **upload**: upload certificate.
        - **cas**: Cloud Shield certificate.
        - **free**: free certificate.
        > If the certificate type is **cas**, **PrivateKey** does not need to pass parameters.
        """
        force_set: NotRequired[pulumi.Input[str]]
        """
        The force set of the security certificate.
        """
        private_key: NotRequired[pulumi.Input[str]]
        """
        The content of the private key. If the certificate is not enabled, you do not need to enter the content of the private key. To configure the certificate, enter the content of the private key.
        """
        server_certificate: NotRequired[pulumi.Input[str]]
        """
        The content of the security certificate. If the certificate is not enabled, you do not need to enter the content of the security certificate. Please enter the content of the certificate to configure the certificate.
        """
        server_certificate_status: NotRequired[pulumi.Input[str]]
        """
        Whether the HTTPS certificate is enabled. Value:
        - **on**(default): enabled.
        - **off** : not enabled.
        """
elif False:
    DomainNewCertificateConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DomainNewCertificateConfigArgs:
    def __init__(__self__, *,
                 cert_id: Optional[pulumi.Input[str]] = None,
                 cert_name: Optional[pulumi.Input[str]] = None,
                 cert_region: Optional[pulumi.Input[str]] = None,
                 cert_type: Optional[pulumi.Input[str]] = None,
                 force_set: Optional[pulumi.Input[str]] = None,
                 private_key: Optional[pulumi.Input[str]] = None,
                 server_certificate: Optional[pulumi.Input[str]] = None,
                 server_certificate_status: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cert_id: The ID of the certificate. It takes effect only when CertType = cas.
        :param pulumi.Input[str] cert_name: Certificate name, only flyer names are supported.
        :param pulumi.Input[str] cert_region: The certificate region, which takes effect only when CertType = cas, supports cn-hangzhou (domestic) and ap-southeast-1 (International), and is cn-hangzhou by default.
        :param pulumi.Input[str] cert_type: Certificate type. Value:
               - **upload**: upload certificate.
               - **cas**: Cloud Shield certificate.
               - **free**: free certificate.
               > If the certificate type is **cas**, **PrivateKey** does not need to pass parameters.
        :param pulumi.Input[str] force_set: The force set of the security certificate.
        :param pulumi.Input[str] private_key: The content of the private key. If the certificate is not enabled, you do not need to enter the content of the private key. To configure the certificate, enter the content of the private key.
        :param pulumi.Input[str] server_certificate: The content of the security certificate. If the certificate is not enabled, you do not need to enter the content of the security certificate. Please enter the content of the certificate to configure the certificate.
        :param pulumi.Input[str] server_certificate_status: Whether the HTTPS certificate is enabled. Value:
               - **on**(default): enabled.
               - **off** : not enabled.
        """
        if cert_id is not None:
            pulumi.set(__self__, "cert_id", cert_id)
        if cert_name is not None:
            pulumi.set(__self__, "cert_name", cert_name)
        if cert_region is not None:
            pulumi.set(__self__, "cert_region", cert_region)
        if cert_type is not None:
            pulumi.set(__self__, "cert_type", cert_type)
        if force_set is not None:
            pulumi.set(__self__, "force_set", force_set)
        if private_key is not None:
            pulumi.set(__self__, "private_key", private_key)
        if server_certificate is not None:
            pulumi.set(__self__, "server_certificate", server_certificate)
        if server_certificate_status is not None:
            pulumi.set(__self__, "server_certificate_status", server_certificate_status)

    @property
    @pulumi.getter(name="certId")
    def cert_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the certificate. It takes effect only when CertType = cas.
        """
        return pulumi.get(self, "cert_id")

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

    @property
    @pulumi.getter(name="certName")
    def cert_name(self) -> Optional[pulumi.Input[str]]:
        """
        Certificate name, only flyer names are supported.
        """
        return pulumi.get(self, "cert_name")

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

    @property
    @pulumi.getter(name="certRegion")
    def cert_region(self) -> Optional[pulumi.Input[str]]:
        """
        The certificate region, which takes effect only when CertType = cas, supports cn-hangzhou (domestic) and ap-southeast-1 (International), and is cn-hangzhou by default.
        """
        return pulumi.get(self, "cert_region")

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

    @property
    @pulumi.getter(name="certType")
    def cert_type(self) -> Optional[pulumi.Input[str]]:
        """
        Certificate type. Value:
        - **upload**: upload certificate.
        - **cas**: Cloud Shield certificate.
        - **free**: free certificate.
        > If the certificate type is **cas**, **PrivateKey** does not need to pass parameters.
        """
        return pulumi.get(self, "cert_type")

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

    @property
    @pulumi.getter(name="forceSet")
    def force_set(self) -> Optional[pulumi.Input[str]]:
        """
        The force set of the security certificate.
        """
        return pulumi.get(self, "force_set")

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

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> Optional[pulumi.Input[str]]:
        """
        The content of the private key. If the certificate is not enabled, you do not need to enter the content of the private key. To configure the certificate, enter the content of the private key.
        """
        return pulumi.get(self, "private_key")

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

    @property
    @pulumi.getter(name="serverCertificate")
    def server_certificate(self) -> Optional[pulumi.Input[str]]:
        """
        The content of the security certificate. If the certificate is not enabled, you do not need to enter the content of the security certificate. Please enter the content of the certificate to configure the certificate.
        """
        return pulumi.get(self, "server_certificate")

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

    @property
    @pulumi.getter(name="serverCertificateStatus")
    def server_certificate_status(self) -> Optional[pulumi.Input[str]]:
        """
        Whether the HTTPS certificate is enabled. Value:
        - **on**(default): enabled.
        - **off** : not enabled.
        """
        return pulumi.get(self, "server_certificate_status")

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


if not MYPY:
    class DomainNewSourceArgsDict(TypedDict):
        content: NotRequired[pulumi.Input[str]]
        """
        The address of source. Valid values can be ip or doaminName. Each item's `content` can not be repeated.
        """
        port: NotRequired[pulumi.Input[int]]
        """
        The port of source. Valid values are `443` and `80`. Default value is `80`.
        """
        priority: NotRequired[pulumi.Input[int]]
        """
        Priority of the source. Valid values are `0` and `100`. Default value is `20`.
        """
        type: NotRequired[pulumi.Input[str]]
        """
        The type of the source. Valid values are `ipaddr`, `domain` and `oss`.
        """
        weight: NotRequired[pulumi.Input[int]]
        """
        Weight of the source. Valid values are from `0` to `100`. Default value is `10`, but if type is `ipaddr`, the value can only be `10`. .
        """
elif False:
    DomainNewSourceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DomainNewSourceArgs:
    def __init__(__self__, *,
                 content: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 priority: Optional[pulumi.Input[int]] = None,
                 type: Optional[pulumi.Input[str]] = None,
                 weight: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] content: The address of source. Valid values can be ip or doaminName. Each item's `content` can not be repeated.
        :param pulumi.Input[int] port: The port of source. Valid values are `443` and `80`. Default value is `80`.
        :param pulumi.Input[int] priority: Priority of the source. Valid values are `0` and `100`. Default value is `20`.
        :param pulumi.Input[str] type: The type of the source. Valid values are `ipaddr`, `domain` and `oss`.
        :param pulumi.Input[int] weight: Weight of the source. Valid values are from `0` to `100`. Default value is `10`, but if type is `ipaddr`, the value can only be `10`. .
        """
        if content is not None:
            pulumi.set(__self__, "content", content)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def content(self) -> Optional[pulumi.Input[str]]:
        """
        The address of source. Valid values can be ip or doaminName. Each item's `content` can not be repeated.
        """
        return pulumi.get(self, "content")

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

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[int]]:
        """
        The port of source. Valid values are `443` and `80`. Default value is `80`.
        """
        return pulumi.get(self, "port")

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

    @property
    @pulumi.getter
    def priority(self) -> Optional[pulumi.Input[int]]:
        """
        Priority of the source. Valid values are `0` and `100`. Default value is `20`.
        """
        return pulumi.get(self, "priority")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of the source. Valid values are `ipaddr`, `domain` and `oss`.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[int]]:
        """
        Weight of the source. Valid values are from `0` to `100`. Default value is `10`, but if type is `ipaddr`, the value can only be `10`. .
        """
        return pulumi.get(self, "weight")

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


if not MYPY:
    class DomainPage404ConfigArgsDict(TypedDict):
        custom_page_url: NotRequired[pulumi.Input[str]]
        error_code: NotRequired[pulumi.Input[str]]
        page_type: NotRequired[pulumi.Input[str]]
elif False:
    DomainPage404ConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DomainPage404ConfigArgs:
    def __init__(__self__, *,
                 custom_page_url: Optional[pulumi.Input[str]] = None,
                 error_code: Optional[pulumi.Input[str]] = None,
                 page_type: Optional[pulumi.Input[str]] = None):
        if custom_page_url is not None:
            pulumi.set(__self__, "custom_page_url", custom_page_url)
        if error_code is not None:
            pulumi.set(__self__, "error_code", error_code)
        if page_type is not None:
            pulumi.set(__self__, "page_type", page_type)

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

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

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

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

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

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


if not MYPY:
    class DomainParameterFilterConfigArgsDict(TypedDict):
        enable: NotRequired[pulumi.Input[str]]
        hash_key_args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
elif False:
    DomainParameterFilterConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DomainParameterFilterConfigArgs:
    def __init__(__self__, *,
                 enable: Optional[pulumi.Input[str]] = None,
                 hash_key_args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if hash_key_args is not None:
            pulumi.set(__self__, "hash_key_args", hash_key_args)

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

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

    @property
    @pulumi.getter(name="hashKeyArgs")
    def hash_key_args(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "hash_key_args")

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


if not MYPY:
    class DomainReferConfigArgsDict(TypedDict):
        refer_lists: pulumi.Input[Sequence[pulumi.Input[str]]]
        allow_empty: NotRequired[pulumi.Input[str]]
        refer_type: NotRequired[pulumi.Input[str]]
elif False:
    DomainReferConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DomainReferConfigArgs:
    def __init__(__self__, *,
                 refer_lists: pulumi.Input[Sequence[pulumi.Input[str]]],
                 allow_empty: Optional[pulumi.Input[str]] = None,
                 refer_type: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "refer_lists", refer_lists)
        if allow_empty is not None:
            pulumi.set(__self__, "allow_empty", allow_empty)
        if refer_type is not None:
            pulumi.set(__self__, "refer_type", refer_type)

    @property
    @pulumi.getter(name="referLists")
    def refer_lists(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "refer_lists")

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

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

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

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

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


