# 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
from . import outputs

__all__ = [
    'DomainConfigFunctionArg',
    'DomainSource',
    'ErEnvConf',
    'ErEnvConfPresetCanaryAnhui',
    'ErEnvConfPresetCanaryBeijing',
    'ErEnvConfPresetCanaryChongqing',
    'ErEnvConfPresetCanaryFujian',
    'ErEnvConfPresetCanaryGansu',
    'ErEnvConfPresetCanaryGuangdong',
    'ErEnvConfPresetCanaryGuangxi',
    'ErEnvConfPresetCanaryGuizhou',
    'ErEnvConfPresetCanaryHainan',
    'ErEnvConfPresetCanaryHebei',
    'ErEnvConfPresetCanaryHeilongjiang',
    'ErEnvConfPresetCanaryHenan',
    'ErEnvConfPresetCanaryHongKong',
    'ErEnvConfPresetCanaryHubei',
    'ErEnvConfPresetCanaryHunan',
    'ErEnvConfPresetCanaryJiangsu',
    'ErEnvConfPresetCanaryJiangxi',
    'ErEnvConfPresetCanaryJilin',
    'ErEnvConfPresetCanaryLiaoning',
    'ErEnvConfPresetCanaryMacau',
    'ErEnvConfPresetCanaryNeimenggu',
    'ErEnvConfPresetCanaryNingxia',
    'ErEnvConfPresetCanaryOverseas',
    'ErEnvConfPresetCanaryQinghai',
    'ErEnvConfPresetCanaryShaanxi',
    'ErEnvConfPresetCanaryShandong',
    'ErEnvConfPresetCanaryShanghai',
    'ErEnvConfPresetCanaryShanxi',
    'ErEnvConfPresetCanarySichuan',
    'ErEnvConfPresetCanaryTaiwan',
    'ErEnvConfPresetCanaryTianjin',
    'ErEnvConfPresetCanaryXinjiang',
    'ErEnvConfPresetCanaryXizang',
    'ErEnvConfPresetCanaryYunnan',
    'ErEnvConfPresetCanaryZhejiang',
    'ErEnvConfProduction',
    'ErEnvConfStaging',
    'IpaDomainSource',
    'WafRuleCondition',
    'WafRuleRateLimit',
    'WafRuleRateLimitStatus',
    'GetDomainsDomainResult',
    'GetDomainsDomainSourceResult',
    'GetIpaDomainsDomainResult',
    'GetIpaDomainsDomainSourceResult',
    'GetWafDomainsDomainResult',
    'GetWafDomainsDomainDefenseSceneResult',
    'GetWafPoliciesPolicyResult',
    'GetWafRulesWafRuleResult',
    'GetWafRulesWafRuleConditionResult',
    'GetWafRulesWafRuleRateLimitResult',
    'GetWafRulesWafRuleRateLimitStatusResult',
]

@pulumi.output_type
class DomainConfigFunctionArg(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "argName":
            suggest = "arg_name"
        elif key == "argValue":
            suggest = "arg_value"

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

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

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

    def __init__(__self__, *,
                 arg_name: str,
                 arg_value: str):
        """
        :param str arg_name: The name of arg.
        :param 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) -> str:
        """
        The name of arg.
        """
        return pulumi.get(self, "arg_name")

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


@pulumi.output_type
class DomainSource(dict):
    def __init__(__self__, *,
                 content: Optional[str] = None,
                 port: Optional[int] = None,
                 priority: Optional[str] = None,
                 type: Optional[str] = None,
                 weight: Optional[str] = None):
        """
        :param str content: The address of the source station.
        :param int port: The port number. Valid values: `443` and `80`. Default to `80`.
        :param str priority: The priority of the origin if multiple origins are specified. Default to `20`.
        :param str type: The type of the origin. Valid values:
        :param str weight: The weight of the origin if multiple origins are specified. Default to `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[str]:
        """
        The address of the source station.
        """
        return pulumi.get(self, "content")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The port number. Valid values: `443` and `80`. Default to `80`.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def priority(self) -> Optional[str]:
        """
        The priority of the origin if multiple origins are specified. Default to `20`.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The type of the origin. Valid values:
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> Optional[str]:
        """
        The weight of the origin if multiple origins are specified. Default to `10`.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class ErEnvConf(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "presetCanaryAnhui":
            suggest = "preset_canary_anhui"
        elif key == "presetCanaryBeijing":
            suggest = "preset_canary_beijing"
        elif key == "presetCanaryChongqing":
            suggest = "preset_canary_chongqing"
        elif key == "presetCanaryFujian":
            suggest = "preset_canary_fujian"
        elif key == "presetCanaryGansu":
            suggest = "preset_canary_gansu"
        elif key == "presetCanaryGuangdong":
            suggest = "preset_canary_guangdong"
        elif key == "presetCanaryGuangxi":
            suggest = "preset_canary_guangxi"
        elif key == "presetCanaryGuizhou":
            suggest = "preset_canary_guizhou"
        elif key == "presetCanaryHainan":
            suggest = "preset_canary_hainan"
        elif key == "presetCanaryHebei":
            suggest = "preset_canary_hebei"
        elif key == "presetCanaryHeilongjiang":
            suggest = "preset_canary_heilongjiang"
        elif key == "presetCanaryHenan":
            suggest = "preset_canary_henan"
        elif key == "presetCanaryHongKong":
            suggest = "preset_canary_hong_kong"
        elif key == "presetCanaryHubei":
            suggest = "preset_canary_hubei"
        elif key == "presetCanaryHunan":
            suggest = "preset_canary_hunan"
        elif key == "presetCanaryJiangsu":
            suggest = "preset_canary_jiangsu"
        elif key == "presetCanaryJiangxi":
            suggest = "preset_canary_jiangxi"
        elif key == "presetCanaryJilin":
            suggest = "preset_canary_jilin"
        elif key == "presetCanaryLiaoning":
            suggest = "preset_canary_liaoning"
        elif key == "presetCanaryMacau":
            suggest = "preset_canary_macau"
        elif key == "presetCanaryNeimenggu":
            suggest = "preset_canary_neimenggu"
        elif key == "presetCanaryNingxia":
            suggest = "preset_canary_ningxia"
        elif key == "presetCanaryOverseas":
            suggest = "preset_canary_overseas"
        elif key == "presetCanaryQinghai":
            suggest = "preset_canary_qinghai"
        elif key == "presetCanaryShaanxi":
            suggest = "preset_canary_shaanxi"
        elif key == "presetCanaryShandong":
            suggest = "preset_canary_shandong"
        elif key == "presetCanaryShanghai":
            suggest = "preset_canary_shanghai"
        elif key == "presetCanaryShanxi":
            suggest = "preset_canary_shanxi"
        elif key == "presetCanarySichuan":
            suggest = "preset_canary_sichuan"
        elif key == "presetCanaryTaiwan":
            suggest = "preset_canary_taiwan"
        elif key == "presetCanaryTianjin":
            suggest = "preset_canary_tianjin"
        elif key == "presetCanaryXinjiang":
            suggest = "preset_canary_xinjiang"
        elif key == "presetCanaryXizang":
            suggest = "preset_canary_xizang"
        elif key == "presetCanaryYunnan":
            suggest = "preset_canary_yunnan"
        elif key == "presetCanaryZhejiang":
            suggest = "preset_canary_zhejiang"

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

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

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

    def __init__(__self__, *,
                 preset_canary_anhui: Optional['outputs.ErEnvConfPresetCanaryAnhui'] = None,
                 preset_canary_beijing: Optional['outputs.ErEnvConfPresetCanaryBeijing'] = None,
                 preset_canary_chongqing: Optional['outputs.ErEnvConfPresetCanaryChongqing'] = None,
                 preset_canary_fujian: Optional['outputs.ErEnvConfPresetCanaryFujian'] = None,
                 preset_canary_gansu: Optional['outputs.ErEnvConfPresetCanaryGansu'] = None,
                 preset_canary_guangdong: Optional['outputs.ErEnvConfPresetCanaryGuangdong'] = None,
                 preset_canary_guangxi: Optional['outputs.ErEnvConfPresetCanaryGuangxi'] = None,
                 preset_canary_guizhou: Optional['outputs.ErEnvConfPresetCanaryGuizhou'] = None,
                 preset_canary_hainan: Optional['outputs.ErEnvConfPresetCanaryHainan'] = None,
                 preset_canary_hebei: Optional['outputs.ErEnvConfPresetCanaryHebei'] = None,
                 preset_canary_heilongjiang: Optional['outputs.ErEnvConfPresetCanaryHeilongjiang'] = None,
                 preset_canary_henan: Optional['outputs.ErEnvConfPresetCanaryHenan'] = None,
                 preset_canary_hong_kong: Optional['outputs.ErEnvConfPresetCanaryHongKong'] = None,
                 preset_canary_hubei: Optional['outputs.ErEnvConfPresetCanaryHubei'] = None,
                 preset_canary_hunan: Optional['outputs.ErEnvConfPresetCanaryHunan'] = None,
                 preset_canary_jiangsu: Optional['outputs.ErEnvConfPresetCanaryJiangsu'] = None,
                 preset_canary_jiangxi: Optional['outputs.ErEnvConfPresetCanaryJiangxi'] = None,
                 preset_canary_jilin: Optional['outputs.ErEnvConfPresetCanaryJilin'] = None,
                 preset_canary_liaoning: Optional['outputs.ErEnvConfPresetCanaryLiaoning'] = None,
                 preset_canary_macau: Optional['outputs.ErEnvConfPresetCanaryMacau'] = None,
                 preset_canary_neimenggu: Optional['outputs.ErEnvConfPresetCanaryNeimenggu'] = None,
                 preset_canary_ningxia: Optional['outputs.ErEnvConfPresetCanaryNingxia'] = None,
                 preset_canary_overseas: Optional['outputs.ErEnvConfPresetCanaryOverseas'] = None,
                 preset_canary_qinghai: Optional['outputs.ErEnvConfPresetCanaryQinghai'] = None,
                 preset_canary_shaanxi: Optional['outputs.ErEnvConfPresetCanaryShaanxi'] = None,
                 preset_canary_shandong: Optional['outputs.ErEnvConfPresetCanaryShandong'] = None,
                 preset_canary_shanghai: Optional['outputs.ErEnvConfPresetCanaryShanghai'] = None,
                 preset_canary_shanxi: Optional['outputs.ErEnvConfPresetCanaryShanxi'] = None,
                 preset_canary_sichuan: Optional['outputs.ErEnvConfPresetCanarySichuan'] = None,
                 preset_canary_taiwan: Optional['outputs.ErEnvConfPresetCanaryTaiwan'] = None,
                 preset_canary_tianjin: Optional['outputs.ErEnvConfPresetCanaryTianjin'] = None,
                 preset_canary_xinjiang: Optional['outputs.ErEnvConfPresetCanaryXinjiang'] = None,
                 preset_canary_xizang: Optional['outputs.ErEnvConfPresetCanaryXizang'] = None,
                 preset_canary_yunnan: Optional['outputs.ErEnvConfPresetCanaryYunnan'] = None,
                 preset_canary_zhejiang: Optional['outputs.ErEnvConfPresetCanaryZhejiang'] = None,
                 production: Optional['outputs.ErEnvConfProduction'] = None,
                 staging: Optional['outputs.ErEnvConfStaging'] = None):
        """
        :param 'ErEnvConfPresetCanaryAnhuiArgs' preset_canary_anhui: The configuration of a presetCanaryAnhui environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryBeijingArgs' preset_canary_beijing: The configuration of a presetCanaryBeijing environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryChongqingArgs' preset_canary_chongqing: The configuration of a presetCanaryChongqing environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryFujianArgs' preset_canary_fujian: The configuration of a presetCanaryFujian environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryGansuArgs' preset_canary_gansu: The configuration of a presetCanaryGansu environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryGuangdongArgs' preset_canary_guangdong: The configuration of a presetCanaryGuangdong environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryGuangxiArgs' preset_canary_guangxi: The configuration of a presetCanaryGuangxi environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryGuizhouArgs' preset_canary_guizhou: The configuration of a presetCanaryGuizhou environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryHainanArgs' preset_canary_hainan: The configuration of a presetCanaryHainan environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryHebeiArgs' preset_canary_hebei: The configuration of a presetCanaryHebei environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryHeilongjiangArgs' preset_canary_heilongjiang: The configuration of a presetCanaryHeilongjiang environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryHenanArgs' preset_canary_henan: The configuration of a presetCanaryHenan environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryHongKongArgs' preset_canary_hong_kong: The configuration of a presetCanaryHongKong environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryHubeiArgs' preset_canary_hubei: The configuration of a presetCanaryHubei environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryHunanArgs' preset_canary_hunan: The configuration of a presetCanaryHunan environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryJiangsuArgs' preset_canary_jiangsu: The configuration of a presetCanaryJiangsu environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryJiangxiArgs' preset_canary_jiangxi: The configuration of a presetCanaryJiangxi environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryJilinArgs' preset_canary_jilin: The configuration of a presetCanaryJilin environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryLiaoningArgs' preset_canary_liaoning: The configuration of a presetCanaryLiaoning environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryMacauArgs' preset_canary_macau: The configuration of a presetCanaryMacau environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryNeimengguArgs' preset_canary_neimenggu: The configuration of a presetCanaryNeimenggu environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryNingxiaArgs' preset_canary_ningxia: The configuration of a presetCanaryNingxia environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryOverseasArgs' preset_canary_overseas: The configuration of a presetCanaryOverseas environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryQinghaiArgs' preset_canary_qinghai: The configuration of a presetCanaryQinghai environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryShaanxiArgs' preset_canary_shaanxi: The configuration of a presetCanaryShaanxi environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryShandongArgs' preset_canary_shandong: The configuration of a presetCanaryShandong environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryShanghaiArgs' preset_canary_shanghai: The configuration of a presetCanaryShanghai environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryShanxiArgs' preset_canary_shanxi: The configuration of a presetCanaryShanxi environment. See `staging` below.
        :param 'ErEnvConfPresetCanarySichuanArgs' preset_canary_sichuan: The configuration of a presetCanarySichuan environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryTaiwanArgs' preset_canary_taiwan: The configuration of a presetCanaryTaiwan environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryTianjinArgs' preset_canary_tianjin: The configuration of a presetCanaryTianjin environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryXinjiangArgs' preset_canary_xinjiang: The configuration of a presetCanaryXinjiang environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryXizangArgs' preset_canary_xizang: The configuration of a presetCanaryXizang environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryYunnanArgs' preset_canary_yunnan: The configuration of a presetCanaryYunnan environment. See `staging` below.
        :param 'ErEnvConfPresetCanaryZhejiangArgs' preset_canary_zhejiang: The configuration of a presetCanaryZhejiang environment. See `staging` below.
        :param 'ErEnvConfProductionArgs' production: The configuration of a production environment. See `staging` below.
        :param 'ErEnvConfStagingArgs' staging: The configuration of a staging environment. See `staging` below.
        """
        if preset_canary_anhui is not None:
            pulumi.set(__self__, "preset_canary_anhui", preset_canary_anhui)
        if preset_canary_beijing is not None:
            pulumi.set(__self__, "preset_canary_beijing", preset_canary_beijing)
        if preset_canary_chongqing is not None:
            pulumi.set(__self__, "preset_canary_chongqing", preset_canary_chongqing)
        if preset_canary_fujian is not None:
            pulumi.set(__self__, "preset_canary_fujian", preset_canary_fujian)
        if preset_canary_gansu is not None:
            pulumi.set(__self__, "preset_canary_gansu", preset_canary_gansu)
        if preset_canary_guangdong is not None:
            pulumi.set(__self__, "preset_canary_guangdong", preset_canary_guangdong)
        if preset_canary_guangxi is not None:
            pulumi.set(__self__, "preset_canary_guangxi", preset_canary_guangxi)
        if preset_canary_guizhou is not None:
            pulumi.set(__self__, "preset_canary_guizhou", preset_canary_guizhou)
        if preset_canary_hainan is not None:
            pulumi.set(__self__, "preset_canary_hainan", preset_canary_hainan)
        if preset_canary_hebei is not None:
            pulumi.set(__self__, "preset_canary_hebei", preset_canary_hebei)
        if preset_canary_heilongjiang is not None:
            pulumi.set(__self__, "preset_canary_heilongjiang", preset_canary_heilongjiang)
        if preset_canary_henan is not None:
            pulumi.set(__self__, "preset_canary_henan", preset_canary_henan)
        if preset_canary_hong_kong is not None:
            pulumi.set(__self__, "preset_canary_hong_kong", preset_canary_hong_kong)
        if preset_canary_hubei is not None:
            pulumi.set(__self__, "preset_canary_hubei", preset_canary_hubei)
        if preset_canary_hunan is not None:
            pulumi.set(__self__, "preset_canary_hunan", preset_canary_hunan)
        if preset_canary_jiangsu is not None:
            pulumi.set(__self__, "preset_canary_jiangsu", preset_canary_jiangsu)
        if preset_canary_jiangxi is not None:
            pulumi.set(__self__, "preset_canary_jiangxi", preset_canary_jiangxi)
        if preset_canary_jilin is not None:
            pulumi.set(__self__, "preset_canary_jilin", preset_canary_jilin)
        if preset_canary_liaoning is not None:
            pulumi.set(__self__, "preset_canary_liaoning", preset_canary_liaoning)
        if preset_canary_macau is not None:
            pulumi.set(__self__, "preset_canary_macau", preset_canary_macau)
        if preset_canary_neimenggu is not None:
            pulumi.set(__self__, "preset_canary_neimenggu", preset_canary_neimenggu)
        if preset_canary_ningxia is not None:
            pulumi.set(__self__, "preset_canary_ningxia", preset_canary_ningxia)
        if preset_canary_overseas is not None:
            pulumi.set(__self__, "preset_canary_overseas", preset_canary_overseas)
        if preset_canary_qinghai is not None:
            pulumi.set(__self__, "preset_canary_qinghai", preset_canary_qinghai)
        if preset_canary_shaanxi is not None:
            pulumi.set(__self__, "preset_canary_shaanxi", preset_canary_shaanxi)
        if preset_canary_shandong is not None:
            pulumi.set(__self__, "preset_canary_shandong", preset_canary_shandong)
        if preset_canary_shanghai is not None:
            pulumi.set(__self__, "preset_canary_shanghai", preset_canary_shanghai)
        if preset_canary_shanxi is not None:
            pulumi.set(__self__, "preset_canary_shanxi", preset_canary_shanxi)
        if preset_canary_sichuan is not None:
            pulumi.set(__self__, "preset_canary_sichuan", preset_canary_sichuan)
        if preset_canary_taiwan is not None:
            pulumi.set(__self__, "preset_canary_taiwan", preset_canary_taiwan)
        if preset_canary_tianjin is not None:
            pulumi.set(__self__, "preset_canary_tianjin", preset_canary_tianjin)
        if preset_canary_xinjiang is not None:
            pulumi.set(__self__, "preset_canary_xinjiang", preset_canary_xinjiang)
        if preset_canary_xizang is not None:
            pulumi.set(__self__, "preset_canary_xizang", preset_canary_xizang)
        if preset_canary_yunnan is not None:
            pulumi.set(__self__, "preset_canary_yunnan", preset_canary_yunnan)
        if preset_canary_zhejiang is not None:
            pulumi.set(__self__, "preset_canary_zhejiang", preset_canary_zhejiang)
        if production is not None:
            pulumi.set(__self__, "production", production)
        if staging is not None:
            pulumi.set(__self__, "staging", staging)

    @property
    @pulumi.getter(name="presetCanaryAnhui")
    def preset_canary_anhui(self) -> Optional['outputs.ErEnvConfPresetCanaryAnhui']:
        """
        The configuration of a presetCanaryAnhui environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_anhui")

    @property
    @pulumi.getter(name="presetCanaryBeijing")
    def preset_canary_beijing(self) -> Optional['outputs.ErEnvConfPresetCanaryBeijing']:
        """
        The configuration of a presetCanaryBeijing environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_beijing")

    @property
    @pulumi.getter(name="presetCanaryChongqing")
    def preset_canary_chongqing(self) -> Optional['outputs.ErEnvConfPresetCanaryChongqing']:
        """
        The configuration of a presetCanaryChongqing environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_chongqing")

    @property
    @pulumi.getter(name="presetCanaryFujian")
    def preset_canary_fujian(self) -> Optional['outputs.ErEnvConfPresetCanaryFujian']:
        """
        The configuration of a presetCanaryFujian environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_fujian")

    @property
    @pulumi.getter(name="presetCanaryGansu")
    def preset_canary_gansu(self) -> Optional['outputs.ErEnvConfPresetCanaryGansu']:
        """
        The configuration of a presetCanaryGansu environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_gansu")

    @property
    @pulumi.getter(name="presetCanaryGuangdong")
    def preset_canary_guangdong(self) -> Optional['outputs.ErEnvConfPresetCanaryGuangdong']:
        """
        The configuration of a presetCanaryGuangdong environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_guangdong")

    @property
    @pulumi.getter(name="presetCanaryGuangxi")
    def preset_canary_guangxi(self) -> Optional['outputs.ErEnvConfPresetCanaryGuangxi']:
        """
        The configuration of a presetCanaryGuangxi environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_guangxi")

    @property
    @pulumi.getter(name="presetCanaryGuizhou")
    def preset_canary_guizhou(self) -> Optional['outputs.ErEnvConfPresetCanaryGuizhou']:
        """
        The configuration of a presetCanaryGuizhou environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_guizhou")

    @property
    @pulumi.getter(name="presetCanaryHainan")
    def preset_canary_hainan(self) -> Optional['outputs.ErEnvConfPresetCanaryHainan']:
        """
        The configuration of a presetCanaryHainan environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_hainan")

    @property
    @pulumi.getter(name="presetCanaryHebei")
    def preset_canary_hebei(self) -> Optional['outputs.ErEnvConfPresetCanaryHebei']:
        """
        The configuration of a presetCanaryHebei environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_hebei")

    @property
    @pulumi.getter(name="presetCanaryHeilongjiang")
    def preset_canary_heilongjiang(self) -> Optional['outputs.ErEnvConfPresetCanaryHeilongjiang']:
        """
        The configuration of a presetCanaryHeilongjiang environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_heilongjiang")

    @property
    @pulumi.getter(name="presetCanaryHenan")
    def preset_canary_henan(self) -> Optional['outputs.ErEnvConfPresetCanaryHenan']:
        """
        The configuration of a presetCanaryHenan environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_henan")

    @property
    @pulumi.getter(name="presetCanaryHongKong")
    def preset_canary_hong_kong(self) -> Optional['outputs.ErEnvConfPresetCanaryHongKong']:
        """
        The configuration of a presetCanaryHongKong environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_hong_kong")

    @property
    @pulumi.getter(name="presetCanaryHubei")
    def preset_canary_hubei(self) -> Optional['outputs.ErEnvConfPresetCanaryHubei']:
        """
        The configuration of a presetCanaryHubei environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_hubei")

    @property
    @pulumi.getter(name="presetCanaryHunan")
    def preset_canary_hunan(self) -> Optional['outputs.ErEnvConfPresetCanaryHunan']:
        """
        The configuration of a presetCanaryHunan environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_hunan")

    @property
    @pulumi.getter(name="presetCanaryJiangsu")
    def preset_canary_jiangsu(self) -> Optional['outputs.ErEnvConfPresetCanaryJiangsu']:
        """
        The configuration of a presetCanaryJiangsu environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_jiangsu")

    @property
    @pulumi.getter(name="presetCanaryJiangxi")
    def preset_canary_jiangxi(self) -> Optional['outputs.ErEnvConfPresetCanaryJiangxi']:
        """
        The configuration of a presetCanaryJiangxi environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_jiangxi")

    @property
    @pulumi.getter(name="presetCanaryJilin")
    def preset_canary_jilin(self) -> Optional['outputs.ErEnvConfPresetCanaryJilin']:
        """
        The configuration of a presetCanaryJilin environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_jilin")

    @property
    @pulumi.getter(name="presetCanaryLiaoning")
    def preset_canary_liaoning(self) -> Optional['outputs.ErEnvConfPresetCanaryLiaoning']:
        """
        The configuration of a presetCanaryLiaoning environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_liaoning")

    @property
    @pulumi.getter(name="presetCanaryMacau")
    def preset_canary_macau(self) -> Optional['outputs.ErEnvConfPresetCanaryMacau']:
        """
        The configuration of a presetCanaryMacau environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_macau")

    @property
    @pulumi.getter(name="presetCanaryNeimenggu")
    def preset_canary_neimenggu(self) -> Optional['outputs.ErEnvConfPresetCanaryNeimenggu']:
        """
        The configuration of a presetCanaryNeimenggu environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_neimenggu")

    @property
    @pulumi.getter(name="presetCanaryNingxia")
    def preset_canary_ningxia(self) -> Optional['outputs.ErEnvConfPresetCanaryNingxia']:
        """
        The configuration of a presetCanaryNingxia environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_ningxia")

    @property
    @pulumi.getter(name="presetCanaryOverseas")
    def preset_canary_overseas(self) -> Optional['outputs.ErEnvConfPresetCanaryOverseas']:
        """
        The configuration of a presetCanaryOverseas environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_overseas")

    @property
    @pulumi.getter(name="presetCanaryQinghai")
    def preset_canary_qinghai(self) -> Optional['outputs.ErEnvConfPresetCanaryQinghai']:
        """
        The configuration of a presetCanaryQinghai environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_qinghai")

    @property
    @pulumi.getter(name="presetCanaryShaanxi")
    def preset_canary_shaanxi(self) -> Optional['outputs.ErEnvConfPresetCanaryShaanxi']:
        """
        The configuration of a presetCanaryShaanxi environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_shaanxi")

    @property
    @pulumi.getter(name="presetCanaryShandong")
    def preset_canary_shandong(self) -> Optional['outputs.ErEnvConfPresetCanaryShandong']:
        """
        The configuration of a presetCanaryShandong environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_shandong")

    @property
    @pulumi.getter(name="presetCanaryShanghai")
    def preset_canary_shanghai(self) -> Optional['outputs.ErEnvConfPresetCanaryShanghai']:
        """
        The configuration of a presetCanaryShanghai environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_shanghai")

    @property
    @pulumi.getter(name="presetCanaryShanxi")
    def preset_canary_shanxi(self) -> Optional['outputs.ErEnvConfPresetCanaryShanxi']:
        """
        The configuration of a presetCanaryShanxi environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_shanxi")

    @property
    @pulumi.getter(name="presetCanarySichuan")
    def preset_canary_sichuan(self) -> Optional['outputs.ErEnvConfPresetCanarySichuan']:
        """
        The configuration of a presetCanarySichuan environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_sichuan")

    @property
    @pulumi.getter(name="presetCanaryTaiwan")
    def preset_canary_taiwan(self) -> Optional['outputs.ErEnvConfPresetCanaryTaiwan']:
        """
        The configuration of a presetCanaryTaiwan environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_taiwan")

    @property
    @pulumi.getter(name="presetCanaryTianjin")
    def preset_canary_tianjin(self) -> Optional['outputs.ErEnvConfPresetCanaryTianjin']:
        """
        The configuration of a presetCanaryTianjin environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_tianjin")

    @property
    @pulumi.getter(name="presetCanaryXinjiang")
    def preset_canary_xinjiang(self) -> Optional['outputs.ErEnvConfPresetCanaryXinjiang']:
        """
        The configuration of a presetCanaryXinjiang environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_xinjiang")

    @property
    @pulumi.getter(name="presetCanaryXizang")
    def preset_canary_xizang(self) -> Optional['outputs.ErEnvConfPresetCanaryXizang']:
        """
        The configuration of a presetCanaryXizang environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_xizang")

    @property
    @pulumi.getter(name="presetCanaryYunnan")
    def preset_canary_yunnan(self) -> Optional['outputs.ErEnvConfPresetCanaryYunnan']:
        """
        The configuration of a presetCanaryYunnan environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_yunnan")

    @property
    @pulumi.getter(name="presetCanaryZhejiang")
    def preset_canary_zhejiang(self) -> Optional['outputs.ErEnvConfPresetCanaryZhejiang']:
        """
        The configuration of a presetCanaryZhejiang environment. See `staging` below.
        """
        return pulumi.get(self, "preset_canary_zhejiang")

    @property
    @pulumi.getter
    def production(self) -> Optional['outputs.ErEnvConfProduction']:
        """
        The configuration of a production environment. See `staging` below.
        """
        return pulumi.get(self, "production")

    @property
    @pulumi.getter
    def staging(self) -> Optional['outputs.ErEnvConfStaging']:
        """
        The configuration of a staging environment. See `staging` below.
        """
        return pulumi.get(self, "staging")


@pulumi.output_type
class ErEnvConfPresetCanaryAnhui(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryBeijing(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryChongqing(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryFujian(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryGansu(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryGuangdong(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryGuangxi(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryGuizhou(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryHainan(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryHebei(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryHeilongjiang(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryHenan(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryHongKong(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryHubei(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryHunan(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryJiangsu(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryJiangxi(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryJilin(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryLiaoning(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryMacau(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryNeimenggu(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryNingxia(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryOverseas(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryQinghai(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryShaanxi(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryShandong(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryShanghai(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryShanxi(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanarySichuan(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryTaiwan(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryTianjin(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryXinjiang(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryXizang(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryYunnan(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfPresetCanaryZhejiang(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfProduction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class ErEnvConfStaging(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHosts":
            suggest = "allowed_hosts"
        elif key == "codeRev":
            suggest = "code_rev"
        elif key == "specName":
            suggest = "spec_name"

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

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

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

    def __init__(__self__, *,
                 allowed_hosts: Optional[Sequence[str]] = None,
                 code_rev: Optional[str] = None,
                 spec_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_hosts: Allowed DCDN domain names.
        :param str code_rev: The version number of the code.
        :param str spec_name: The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        if allowed_hosts is not None:
            pulumi.set(__self__, "allowed_hosts", allowed_hosts)
        if code_rev is not None:
            pulumi.set(__self__, "code_rev", code_rev)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)

    @property
    @pulumi.getter(name="allowedHosts")
    def allowed_hosts(self) -> Optional[Sequence[str]]:
        """
        Allowed DCDN domain names.
        """
        return pulumi.get(self, "allowed_hosts")

    @property
    @pulumi.getter(name="codeRev")
    def code_rev(self) -> Optional[str]:
        """
        The version number of the code.
        """
        return pulumi.get(self, "code_rev")

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[str]:
        """
        The specification of the CPU time slice. Valid values: `5ms`, `50ms`, `100ms`.
        """
        return pulumi.get(self, "spec_name")


@pulumi.output_type
class IpaDomainSource(dict):
    def __init__(__self__, *,
                 content: str,
                 port: int,
                 priority: str,
                 type: str,
                 weight: int):
        """
        :param str content: The address of the origin server. You can specify an IP address or a domain name.
        :param int port: The custom port number. Valid values: `0` to `65535`.
        :param str priority: The priority of the origin server. Valid values: `20` and `30`. Default value: `20`. A value of 20 specifies that the origin is a primary origin. A value of 30 specifies that the origin is a secondary origin.
        :param str type: The type of the origin server. Valid values: `ipaddr`, `domain`, `oss`.
        :param int weight: The weight of the origin server. You must specify a value that is less than `100`. Default value: `10`.
        """
        pulumi.set(__self__, "content", content)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def content(self) -> str:
        """
        The address of the origin server. You can specify an IP address or a domain name.
        """
        return pulumi.get(self, "content")

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The custom port number. Valid values: `0` to `65535`.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def priority(self) -> str:
        """
        The priority of the origin server. Valid values: `20` and `30`. Default value: `20`. A value of 20 specifies that the origin is a primary origin. A value of 30 specifies that the origin is a secondary origin.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of the origin server. Valid values: `ipaddr`, `domain`, `oss`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        The weight of the origin server. You must specify a value that is less than `100`. Default value: `10`.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class WafRuleCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "opValue":
            suggest = "op_value"
        elif key == "subKey":
            suggest = "sub_key"

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

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

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

    def __init__(__self__, *,
                 key: str,
                 op_value: str,
                 sub_key: Optional[str] = None,
                 values: Optional[str] = None):
        """
        :param str key: The match field.
        :param str op_value: The logical symbol.
        :param str sub_key: The match subfield.
        :param str values: The match content. Separate multiple values with commas (,).
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "op_value", op_value)
        if sub_key is not None:
            pulumi.set(__self__, "sub_key", sub_key)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The match field.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter(name="opValue")
    def op_value(self) -> str:
        """
        The logical symbol.
        """
        return pulumi.get(self, "op_value")

    @property
    @pulumi.getter(name="subKey")
    def sub_key(self) -> Optional[str]:
        """
        The match subfield.
        """
        return pulumi.get(self, "sub_key")

    @property
    @pulumi.getter
    def values(self) -> Optional[str]:
        """
        The match content. Separate multiple values with commas (,).
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class WafRuleRateLimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subKey":
            suggest = "sub_key"

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

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

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

    def __init__(__self__, *,
                 interval: Optional[int] = None,
                 status: Optional['outputs.WafRuleRateLimitStatus'] = None,
                 sub_key: Optional[str] = None,
                 target: Optional[str] = None,
                 threshold: Optional[int] = None,
                 ttl: Optional[int] = None):
        """
        :param int interval: Statistical duration, 5-1800.
        :param 'WafRuleRateLimitStatusArgs' status: Response code statistics. See `status` below.
        :param str sub_key: The subfield of the target field. If you set `target` to `Header`, `Query String Parameter`, or `Cookie Name`, you must configure `sub_key`.
        :param str target: The statistical field for frequency control. Currently, `IP`, `Header`, `Query String Parameter`, `Cookie Name`, `Session` is supported.
        :param int threshold: The trigger threshold of rate limiting. Valid values: 2 to 500000. Unit: requests.
        :param int ttl: The validity period of the blacklist. Valid values: 60 to 86400. Unit: seconds.
        """
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if sub_key is not None:
            pulumi.set(__self__, "sub_key", sub_key)
        if target is not None:
            pulumi.set(__self__, "target", target)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)
        if ttl is not None:
            pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter
    def interval(self) -> Optional[int]:
        """
        Statistical duration, 5-1800.
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter
    def status(self) -> Optional['outputs.WafRuleRateLimitStatus']:
        """
        Response code statistics. See `status` below.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="subKey")
    def sub_key(self) -> Optional[str]:
        """
        The subfield of the target field. If you set `target` to `Header`, `Query String Parameter`, or `Cookie Name`, you must configure `sub_key`.
        """
        return pulumi.get(self, "sub_key")

    @property
    @pulumi.getter
    def target(self) -> Optional[str]:
        """
        The statistical field for frequency control. Currently, `IP`, `Header`, `Query String Parameter`, `Cookie Name`, `Session` is supported.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[int]:
        """
        The trigger threshold of rate limiting. Valid values: 2 to 500000. Unit: requests.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def ttl(self) -> Optional[int]:
        """
        The validity period of the blacklist. Valid values: 60 to 86400. Unit: seconds.
        """
        return pulumi.get(self, "ttl")


@pulumi.output_type
class WafRuleRateLimitStatus(dict):
    def __init__(__self__, *,
                 code: Optional[str] = None,
                 count: Optional[int] = None,
                 ratio: Optional[int] = None):
        """
        :param str code: The HTTP status code returned.
        :param int count: The number of times that the HTTP status code that was returned. Valid values: 2 to 50000. You can configure only one of the `ratio` and `count` fields.
        :param int ratio: The percentage of HTTP status codes. Valid values: 1 to 100. You can configure only one of the `ratio` and `count` fields.
        """
        if code is not None:
            pulumi.set(__self__, "code", code)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if ratio is not None:
            pulumi.set(__self__, "ratio", ratio)

    @property
    @pulumi.getter
    def code(self) -> Optional[str]:
        """
        The HTTP status code returned.
        """
        return pulumi.get(self, "code")

    @property
    @pulumi.getter
    def count(self) -> Optional[int]:
        """
        The number of times that the HTTP status code that was returned. Valid values: 2 to 50000. You can configure only one of the `ratio` and `count` fields.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def ratio(self) -> Optional[int]:
        """
        The percentage of HTTP status codes. Valid values: 1 to 100. You can configure only one of the `ratio` and `count` fields.
        """
        return pulumi.get(self, "ratio")


@pulumi.output_type
class GetDomainsDomainResult(dict):
    def __init__(__self__, *,
                 cert_name: str,
                 cname: str,
                 description: str,
                 domain_name: str,
                 gmt_modified: str,
                 id: str,
                 resource_group_id: str,
                 scope: str,
                 sources: Sequence['outputs.GetDomainsDomainSourceResult'],
                 ssl_protocol: str,
                 ssl_pub: str,
                 status: str):
        """
        :param str cert_name: Indicates the name of the certificate.
        :param str cname: The canonical name (CNAME) of the accelerated domain.
        :param str description: The reason that causes the review failure.
        :param str domain_name: The name of the DCDN Domain.
        :param str gmt_modified: The time when the accelerated domain was last modified.
        :param str id: The ID of the DCDN Domain.
        :param str resource_group_id: The ID of the resource group.
        :param str scope: The acceleration region.
        :param Sequence['GetDomainsDomainSourceArgs'] sources: The origin information.
        :param str ssl_protocol: Indicates whether the SSL certificate is enabled.
        :param str ssl_pub: Indicates the public key of the certificate.
        :param str status: The status of DCDN Domain.
        """
        pulumi.set(__self__, "cert_name", cert_name)
        pulumi.set(__self__, "cname", cname)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "domain_name", domain_name)
        pulumi.set(__self__, "gmt_modified", gmt_modified)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "scope", scope)
        pulumi.set(__self__, "sources", sources)
        pulumi.set(__self__, "ssl_protocol", ssl_protocol)
        pulumi.set(__self__, "ssl_pub", ssl_pub)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="certName")
    def cert_name(self) -> str:
        """
        Indicates the name of the certificate.
        """
        return pulumi.get(self, "cert_name")

    @property
    @pulumi.getter
    def cname(self) -> str:
        """
        The canonical name (CNAME) of the accelerated domain.
        """
        return pulumi.get(self, "cname")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The reason that causes the review failure.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> str:
        """
        The name of the DCDN Domain.
        """
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter(name="gmtModified")
    def gmt_modified(self) -> str:
        """
        The time when the accelerated domain was last modified.
        """
        return pulumi.get(self, "gmt_modified")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the DCDN Domain.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The ID of the resource group.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter
    def scope(self) -> str:
        """
        The acceleration region.
        """
        return pulumi.get(self, "scope")

    @property
    @pulumi.getter
    def sources(self) -> Sequence['outputs.GetDomainsDomainSourceResult']:
        """
        The origin information.
        """
        return pulumi.get(self, "sources")

    @property
    @pulumi.getter(name="sslProtocol")
    def ssl_protocol(self) -> str:
        """
        Indicates whether the SSL certificate is enabled.
        """
        return pulumi.get(self, "ssl_protocol")

    @property
    @pulumi.getter(name="sslPub")
    def ssl_pub(self) -> str:
        """
        Indicates the public key of the certificate.
        """
        return pulumi.get(self, "ssl_pub")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of DCDN Domain.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetDomainsDomainSourceResult(dict):
    def __init__(__self__, *,
                 content: str,
                 enabled: str,
                 port: int,
                 priority: str,
                 type: str,
                 weight: str):
        """
        :param str content: The origin address.
        :param str enabled: The status of the origin.
        :param int port: The port number.
        :param str priority: The priority of the origin if multiple origins are specified.
        :param str type: The type of the origin. Valid values:
        :param str weight: The weight of the origin if multiple origins are specified.
        """
        pulumi.set(__self__, "content", content)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def content(self) -> str:
        """
        The origin address.
        """
        return pulumi.get(self, "content")

    @property
    @pulumi.getter
    def enabled(self) -> str:
        """
        The status of the origin.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def priority(self) -> str:
        """
        The priority of the origin if multiple origins are specified.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of the origin. Valid values:
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> str:
        """
        The weight of the origin if multiple origins are specified.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetIpaDomainsDomainResult(dict):
    def __init__(__self__, *,
                 cert_name: str,
                 cname: str,
                 create_time: str,
                 description: str,
                 domain_name: str,
                 id: str,
                 resource_group_id: str,
                 scope: str,
                 sources: Sequence['outputs.GetIpaDomainsDomainSourceResult'],
                 ssl_protocol: str,
                 ssl_pub: str,
                 status: str):
        """
        :param str cert_name: CertName.
        :param str cname: The CNAME assigned to the domain name.
        :param str create_time: The time when the accelerated domain name was created.
        :param str description: The description.
        :param str domain_name: The accelerated domain names.
        :param str id: The ID of the Ipa Domain.
        :param str resource_group_id: The ID of the resource group.
        :param str scope: The accelerated region.
        :param Sequence['GetIpaDomainsDomainSourceArgs'] sources: The information about the origin server.
        :param str ssl_protocol: Indicates whether the Security Socket Layer (SSL) certificate is enabled.
        :param str ssl_pub: Indicates the public key of the certificate if the HTTPS protocol is enabled.
        :param str status: The status of the accelerated domain name.
        """
        pulumi.set(__self__, "cert_name", cert_name)
        pulumi.set(__self__, "cname", cname)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "domain_name", domain_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "scope", scope)
        pulumi.set(__self__, "sources", sources)
        pulumi.set(__self__, "ssl_protocol", ssl_protocol)
        pulumi.set(__self__, "ssl_pub", ssl_pub)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="certName")
    def cert_name(self) -> str:
        """
        CertName.
        """
        return pulumi.get(self, "cert_name")

    @property
    @pulumi.getter
    def cname(self) -> str:
        """
        The CNAME assigned to the domain name.
        """
        return pulumi.get(self, "cname")

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> str:
        """
        The time when the accelerated domain name was created.
        """
        return pulumi.get(self, "create_time")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> str:
        """
        The accelerated domain names.
        """
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Ipa Domain.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The ID of the resource group.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter
    def scope(self) -> str:
        """
        The accelerated region.
        """
        return pulumi.get(self, "scope")

    @property
    @pulumi.getter
    def sources(self) -> Sequence['outputs.GetIpaDomainsDomainSourceResult']:
        """
        The information about the origin server.
        """
        return pulumi.get(self, "sources")

    @property
    @pulumi.getter(name="sslProtocol")
    def ssl_protocol(self) -> str:
        """
        Indicates whether the Security Socket Layer (SSL) certificate is enabled.
        """
        return pulumi.get(self, "ssl_protocol")

    @property
    @pulumi.getter(name="sslPub")
    def ssl_pub(self) -> str:
        """
        Indicates the public key of the certificate if the HTTPS protocol is enabled.
        """
        return pulumi.get(self, "ssl_pub")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the accelerated domain name.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetIpaDomainsDomainSourceResult(dict):
    def __init__(__self__, *,
                 content: str,
                 port: int,
                 priority: str,
                 type: str,
                 weight: int):
        """
        :param str content: The address of the origin server.
        :param int port: The custom port.
        :param str priority: The priority of the origin server if multiple origin servers are specified.
        :param str type: The type of the origin server.
        :param int weight: The weight of the origin server if multiple origin servers are specified.
        """
        pulumi.set(__self__, "content", content)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def content(self) -> str:
        """
        The address of the origin server.
        """
        return pulumi.get(self, "content")

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The custom port.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def priority(self) -> str:
        """
        The priority of the origin server if multiple origin servers are specified.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of the origin server.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        The weight of the origin server if multiple origin servers are specified.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetWafDomainsDomainResult(dict):
    def __init__(__self__, *,
                 client_ip_tag: str,
                 defense_scenes: Sequence['outputs.GetWafDomainsDomainDefenseSceneResult'],
                 domain_name: str,
                 id: str):
        """
        :param str client_ip_tag: The client ip tag.
        :param Sequence['GetWafDomainsDomainDefenseSceneArgs'] defense_scenes: Protection policy type.
        :param str domain_name: The accelerated domain name.
        :param str id: The ID of the Waf Domain.
        """
        pulumi.set(__self__, "client_ip_tag", client_ip_tag)
        pulumi.set(__self__, "defense_scenes", defense_scenes)
        pulumi.set(__self__, "domain_name", domain_name)
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter(name="clientIpTag")
    def client_ip_tag(self) -> str:
        """
        The client ip tag.
        """
        return pulumi.get(self, "client_ip_tag")

    @property
    @pulumi.getter(name="defenseScenes")
    def defense_scenes(self) -> Sequence['outputs.GetWafDomainsDomainDefenseSceneResult']:
        """
        Protection policy type.
        """
        return pulumi.get(self, "defense_scenes")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> str:
        """
        The accelerated domain name.
        """
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Waf Domain.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetWafDomainsDomainDefenseSceneResult(dict):
    def __init__(__self__, *,
                 defense_scene: str,
                 policy_id: str):
        """
        :param str defense_scene: The type of protection policy.
        :param str policy_id: The protection policy ID.
        """
        pulumi.set(__self__, "defense_scene", defense_scene)
        pulumi.set(__self__, "policy_id", policy_id)

    @property
    @pulumi.getter(name="defenseScene")
    def defense_scene(self) -> str:
        """
        The type of protection policy.
        """
        return pulumi.get(self, "defense_scene")

    @property
    @pulumi.getter(name="policyId")
    def policy_id(self) -> str:
        """
        The protection policy ID.
        """
        return pulumi.get(self, "policy_id")


@pulumi.output_type
class GetWafPoliciesPolicyResult(dict):
    def __init__(__self__, *,
                 dcdn_waf_policy_id: str,
                 defense_scene: str,
                 domain_count: int,
                 gmt_modified: str,
                 id: str,
                 policy_name: str,
                 policy_type: str,
                 rule_count: str,
                 status: str):
        """
        :param str dcdn_waf_policy_id: The first ID of the resource.
        :param str defense_scene: The type of protection policy.
        :param int domain_count: The number of domain names that use this protection policy.
        :param str gmt_modified: The time when the protection policy was modified.
        :param str id: The ID of the Waf Policy.
        :param str policy_name: The name of the protection policy.
        :param str policy_type: The type of the protection policy.
        :param str rule_count: The number of protection rules in this protection policy.
        :param str status: The status of the resource.
        """
        pulumi.set(__self__, "dcdn_waf_policy_id", dcdn_waf_policy_id)
        pulumi.set(__self__, "defense_scene", defense_scene)
        pulumi.set(__self__, "domain_count", domain_count)
        pulumi.set(__self__, "gmt_modified", gmt_modified)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "policy_name", policy_name)
        pulumi.set(__self__, "policy_type", policy_type)
        pulumi.set(__self__, "rule_count", rule_count)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="dcdnWafPolicyId")
    def dcdn_waf_policy_id(self) -> str:
        """
        The first ID of the resource.
        """
        return pulumi.get(self, "dcdn_waf_policy_id")

    @property
    @pulumi.getter(name="defenseScene")
    def defense_scene(self) -> str:
        """
        The type of protection policy.
        """
        return pulumi.get(self, "defense_scene")

    @property
    @pulumi.getter(name="domainCount")
    def domain_count(self) -> int:
        """
        The number of domain names that use this protection policy.
        """
        return pulumi.get(self, "domain_count")

    @property
    @pulumi.getter(name="gmtModified")
    def gmt_modified(self) -> str:
        """
        The time when the protection policy was modified.
        """
        return pulumi.get(self, "gmt_modified")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Waf Policy.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="policyName")
    def policy_name(self) -> str:
        """
        The name of the protection policy.
        """
        return pulumi.get(self, "policy_name")

    @property
    @pulumi.getter(name="policyType")
    def policy_type(self) -> str:
        """
        The type of the protection policy.
        """
        return pulumi.get(self, "policy_type")

    @property
    @pulumi.getter(name="ruleCount")
    def rule_count(self) -> str:
        """
        The number of protection rules in this protection policy.
        """
        return pulumi.get(self, "rule_count")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the resource.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetWafRulesWafRuleResult(dict):
    def __init__(__self__, *,
                 action: str,
                 cc_status: str,
                 cn_region_list: str,
                 conditions: Sequence['outputs.GetWafRulesWafRuleConditionResult'],
                 defense_scene: str,
                 effect: str,
                 gmt_modified: str,
                 id: str,
                 other_region_list: str,
                 policy_id: str,
                 rate_limits: Sequence['outputs.GetWafRulesWafRuleRateLimitResult'],
                 regular_rules: Sequence[str],
                 regular_types: Sequence[str],
                 remote_addrs: Sequence[str],
                 rule_name: str,
                 scenes: Sequence[str],
                 status: str,
                 waf_group_ids: str,
                 waf_rule_id: str):
        """
        :param str action: Specifies the action of the rule.
        :param str cc_status: Whether to turn on Frequency Control, on/off
        :param str cn_region_list: The blocked regions in the Chinese mainland, separated by commas (,).
        :param Sequence['GetWafRulesWafRuleConditionArgs'] conditions: The trigger condition of the rule.
        :param str defense_scene: The type of protection policy. The following scenarios are supported:-waf_group:Web basic protection-custom_acl: Custom protection policy-whitelist: whitelist
        :param str effect: The effective range of the frequency control blacklist.
        :param str gmt_modified: Revised the time. The date format is based on ISO8601 notation and uses UTC +0 time in the format of yyyy-MM-ddTHH:mm:ssZ.
        :param str id: The ID of the Waf Rule.
        :param str other_region_list: The effective range of the frequency control blacklist.
        :param str policy_id: The protection policy ID.
        :param Sequence['GetWafRulesWafRuleRateLimitArgs'] rate_limits: The rules of rate limiting.
        :param Sequence[str] regular_rules: The regular expression.
        :param Sequence[str] regular_types: The type of the regular expression. If the value of the tags field contains waf_group, you can specify this field.
        :param Sequence[str] remote_addrs: Filter by IP address.
        :param str rule_name: The name of the protection rule.
        :param Sequence[str] scenes: List of protection scenarios
        :param str status: The information about the HTTP status code.
        :param str waf_group_ids: The id of the waf rule group.
        :param str waf_rule_id: The first ID of the resource
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "cc_status", cc_status)
        pulumi.set(__self__, "cn_region_list", cn_region_list)
        pulumi.set(__self__, "conditions", conditions)
        pulumi.set(__self__, "defense_scene", defense_scene)
        pulumi.set(__self__, "effect", effect)
        pulumi.set(__self__, "gmt_modified", gmt_modified)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "other_region_list", other_region_list)
        pulumi.set(__self__, "policy_id", policy_id)
        pulumi.set(__self__, "rate_limits", rate_limits)
        pulumi.set(__self__, "regular_rules", regular_rules)
        pulumi.set(__self__, "regular_types", regular_types)
        pulumi.set(__self__, "remote_addrs", remote_addrs)
        pulumi.set(__self__, "rule_name", rule_name)
        pulumi.set(__self__, "scenes", scenes)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "waf_group_ids", waf_group_ids)
        pulumi.set(__self__, "waf_rule_id", waf_rule_id)

    @property
    @pulumi.getter
    def action(self) -> str:
        """
        Specifies the action of the rule.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter(name="ccStatus")
    def cc_status(self) -> str:
        """
        Whether to turn on Frequency Control, on/off
        """
        return pulumi.get(self, "cc_status")

    @property
    @pulumi.getter(name="cnRegionList")
    def cn_region_list(self) -> str:
        """
        The blocked regions in the Chinese mainland, separated by commas (,).
        """
        return pulumi.get(self, "cn_region_list")

    @property
    @pulumi.getter
    def conditions(self) -> Sequence['outputs.GetWafRulesWafRuleConditionResult']:
        """
        The trigger condition of the rule.
        """
        return pulumi.get(self, "conditions")

    @property
    @pulumi.getter(name="defenseScene")
    def defense_scene(self) -> str:
        """
        The type of protection policy. The following scenarios are supported:-waf_group:Web basic protection-custom_acl: Custom protection policy-whitelist: whitelist
        """
        return pulumi.get(self, "defense_scene")

    @property
    @pulumi.getter
    def effect(self) -> str:
        """
        The effective range of the frequency control blacklist.
        """
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter(name="gmtModified")
    def gmt_modified(self) -> str:
        """
        Revised the time. The date format is based on ISO8601 notation and uses UTC +0 time in the format of yyyy-MM-ddTHH:mm:ssZ.
        """
        return pulumi.get(self, "gmt_modified")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Waf Rule.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="otherRegionList")
    def other_region_list(self) -> str:
        """
        The effective range of the frequency control blacklist.
        """
        return pulumi.get(self, "other_region_list")

    @property
    @pulumi.getter(name="policyId")
    def policy_id(self) -> str:
        """
        The protection policy ID.
        """
        return pulumi.get(self, "policy_id")

    @property
    @pulumi.getter(name="rateLimits")
    def rate_limits(self) -> Sequence['outputs.GetWafRulesWafRuleRateLimitResult']:
        """
        The rules of rate limiting.
        """
        return pulumi.get(self, "rate_limits")

    @property
    @pulumi.getter(name="regularRules")
    def regular_rules(self) -> Sequence[str]:
        """
        The regular expression.
        """
        return pulumi.get(self, "regular_rules")

    @property
    @pulumi.getter(name="regularTypes")
    def regular_types(self) -> Sequence[str]:
        """
        The type of the regular expression. If the value of the tags field contains waf_group, you can specify this field.
        """
        return pulumi.get(self, "regular_types")

    @property
    @pulumi.getter(name="remoteAddrs")
    def remote_addrs(self) -> Sequence[str]:
        """
        Filter by IP address.
        """
        return pulumi.get(self, "remote_addrs")

    @property
    @pulumi.getter(name="ruleName")
    def rule_name(self) -> str:
        """
        The name of the protection rule.
        """
        return pulumi.get(self, "rule_name")

    @property
    @pulumi.getter
    def scenes(self) -> Sequence[str]:
        """
        List of protection scenarios
        """
        return pulumi.get(self, "scenes")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The information about the HTTP status code.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="wafGroupIds")
    def waf_group_ids(self) -> str:
        """
        The id of the waf rule group.
        """
        return pulumi.get(self, "waf_group_ids")

    @property
    @pulumi.getter(name="wafRuleId")
    def waf_rule_id(self) -> str:
        """
        The first ID of the resource
        """
        return pulumi.get(self, "waf_rule_id")


@pulumi.output_type
class GetWafRulesWafRuleConditionResult(dict):
    def __init__(__self__, *,
                 key: str,
                 op_value: str,
                 sub_key: str,
                 values: str):
        """
        :param str key: The match field.
        :param str op_value: The logical symbol.
        :param str sub_key: The subfield of the target field.
        :param str values: The match content. Separate multiple values with commas (,).
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "op_value", op_value)
        pulumi.set(__self__, "sub_key", sub_key)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The match field.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter(name="opValue")
    def op_value(self) -> str:
        """
        The logical symbol.
        """
        return pulumi.get(self, "op_value")

    @property
    @pulumi.getter(name="subKey")
    def sub_key(self) -> str:
        """
        The subfield of the target field.
        """
        return pulumi.get(self, "sub_key")

    @property
    @pulumi.getter
    def values(self) -> str:
        """
        The match content. Separate multiple values with commas (,).
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetWafRulesWafRuleRateLimitResult(dict):
    def __init__(__self__, *,
                 interval: int,
                 statuses: Sequence['outputs.GetWafRulesWafRuleRateLimitStatusResult'],
                 sub_key: str,
                 target: str,
                 threshold: int,
                 ttl: int):
        """
        :param int interval: The statistical interval. Valid values: 5 to 1800. Unit: seconds.
        :param Sequence['GetWafRulesWafRuleRateLimitStatusArgs'] statuses: The information about the HTTP status code.
        :param str sub_key: The subfield of the target field.
        :param str target: The statistical field for frequency control.
        :param int threshold: The trigger threshold of rate limiting. Valid values: 2 to 500000. Unit: requests.
        :param int ttl: The validity period of the blacklist. Valid values: 60 to 86400. Unit: seconds.
        """
        pulumi.set(__self__, "interval", interval)
        pulumi.set(__self__, "statuses", statuses)
        pulumi.set(__self__, "sub_key", sub_key)
        pulumi.set(__self__, "target", target)
        pulumi.set(__self__, "threshold", threshold)
        pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter
    def interval(self) -> int:
        """
        The statistical interval. Valid values: 5 to 1800. Unit: seconds.
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter
    def statuses(self) -> Sequence['outputs.GetWafRulesWafRuleRateLimitStatusResult']:
        """
        The information about the HTTP status code.
        """
        return pulumi.get(self, "statuses")

    @property
    @pulumi.getter(name="subKey")
    def sub_key(self) -> str:
        """
        The subfield of the target field.
        """
        return pulumi.get(self, "sub_key")

    @property
    @pulumi.getter
    def target(self) -> str:
        """
        The statistical field for frequency control.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter
    def threshold(self) -> int:
        """
        The trigger threshold of rate limiting. Valid values: 2 to 500000. Unit: requests.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def ttl(self) -> int:
        """
        The validity period of the blacklist. Valid values: 60 to 86400. Unit: seconds.
        """
        return pulumi.get(self, "ttl")


@pulumi.output_type
class GetWafRulesWafRuleRateLimitStatusResult(dict):
    def __init__(__self__, *,
                 code: str,
                 count: int,
                 ratio: int):
        """
        :param str code: The HTTP status code returned.
        :param int count: The number of times that the HTTP status code that was returned.
        :param int ratio: The percentage of HTTP status codes.
        """
        pulumi.set(__self__, "code", code)
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "ratio", ratio)

    @property
    @pulumi.getter
    def code(self) -> str:
        """
        The HTTP status code returned.
        """
        return pulumi.get(self, "code")

    @property
    @pulumi.getter
    def count(self) -> int:
        """
        The number of times that the HTTP status code that was returned.
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def ratio(self) -> int:
        """
        The percentage of HTTP status codes.
        """
        return pulumi.get(self, "ratio")


