pulumi-alicloud 3.53.0a1713354491__py3-none-any.whl → 3.73.0a1736832142__py3-none-any.whl

pulumi_alicloud/ddos/outputs.py

@@ -4,14 +4,27 @@
 
 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__ = [
+    'BgpPolicyContent',
+    'BgpPolicyContentFingerPrintRuleList',
+    'BgpPolicyContentLayer4RuleList',
+    'BgpPolicyContentLayer4RuleListConditionList',
+    'BgpPolicyContentPortRuleList',
+    'BgpPolicyContentSourceBlockList',
+    'BgpPolicyContentSourceLimit',
     'DomainResourceProxyType',
+    'PortConfig',
     'SchedulerRuleRule',
     'GetDdosBgpInstancesInstanceResult',
     'GetDdosBgpIpsIpResult',
@@ -21,6 +34,827 @@ __all__ = [
     'GetDdosCooPortsPortResult',
 ]
 
+@pulumi.output_type
+class BgpPolicyContent(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "blackIpListExpireAt":
+            suggest = "black_ip_list_expire_at"
+        elif key == "enableDefense":
+            suggest = "enable_defense"
+        elif key == "enableDropIcmp":
+            suggest = "enable_drop_icmp"
+        elif key == "enableIntelligence":
+            suggest = "enable_intelligence"
+        elif key == "fingerPrintRuleLists":
+            suggest = "finger_print_rule_lists"
+        elif key == "intelligenceLevel":
+            suggest = "intelligence_level"
+        elif key == "layer4RuleLists":
+            suggest = "layer4_rule_lists"
+        elif key == "portRuleLists":
+            suggest = "port_rule_lists"
+        elif key == "reflectBlockUdpPortLists":
+            suggest = "reflect_block_udp_port_lists"
+        elif key == "regionBlockCountryLists":
+            suggest = "region_block_country_lists"
+        elif key == "regionBlockProvinceLists":
+            suggest = "region_block_province_lists"
+        elif key == "sourceBlockLists":
+            suggest = "source_block_lists"
+        elif key == "sourceLimit":
+            suggest = "source_limit"
+        elif key == "whitenGfbrNets":
+            suggest = "whiten_gfbr_nets"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BgpPolicyContent. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BgpPolicyContent.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BgpPolicyContent.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 black_ip_list_expire_at: Optional[int] = None,
+                 enable_defense: Optional[bool] = None,
+                 enable_drop_icmp: Optional[bool] = None,
+                 enable_intelligence: Optional[bool] = None,
+                 finger_print_rule_lists: Optional[Sequence['outputs.BgpPolicyContentFingerPrintRuleList']] = None,
+                 intelligence_level: Optional[str] = None,
+                 layer4_rule_lists: Optional[Sequence['outputs.BgpPolicyContentLayer4RuleList']] = None,
+                 port_rule_lists: Optional[Sequence['outputs.BgpPolicyContentPortRuleList']] = None,
+                 reflect_block_udp_port_lists: Optional[Sequence[int]] = None,
+                 region_block_country_lists: Optional[Sequence[int]] = None,
+                 region_block_province_lists: Optional[Sequence[int]] = None,
+                 source_block_lists: Optional[Sequence['outputs.BgpPolicyContentSourceBlockList']] = None,
+                 source_limit: Optional['outputs.BgpPolicyContentSourceLimit'] = None,
+                 whiten_gfbr_nets: Optional[bool] = None):
+        """
+        :param int black_ip_list_expire_at: Blacklist and whitelist timeout.
+        :param bool enable_defense: Whether to enable L4 protection.
+        :param bool enable_drop_icmp: Switch to discard ICMP.
+        :param bool enable_intelligence: Whether the intelligent switch is on.
+        :param Sequence['BgpPolicyContentFingerPrintRuleListArgs'] finger_print_rule_lists: Fingerprint Rules. See `finger_print_rule_list` below.
+        :param str intelligence_level: Smart mode. Valid values: weak, hard, and default.
+        :param Sequence['BgpPolicyContentLayer4RuleListArgs'] layer4_rule_lists: L4 protection rules. See `layer4_rule_list` below.
+        :param Sequence['BgpPolicyContentPortRuleListArgs'] port_rule_lists: Port Rule List. See `port_rule_list` below.
+        :param Sequence[int] reflect_block_udp_port_lists: Reflective port filtering.
+        :param Sequence[int] region_block_country_lists: List of Regional Banned Countries.
+        :param Sequence[int] region_block_province_lists: List of Prohibited Provinces by Region.
+        :param Sequence['BgpPolicyContentSourceBlockListArgs'] source_block_lists: Source pull Black. See `source_block_list` below.
+        :param 'BgpPolicyContentSourceLimitArgs' source_limit: Do not fill in when the source speed limit is deleted. See `source_limit` below.
+        :param bool whiten_gfbr_nets: Add white high protection back to source network segment switch.
+        """
+        if black_ip_list_expire_at is not None:
+            pulumi.set(__self__, "black_ip_list_expire_at", black_ip_list_expire_at)
+        if enable_defense is not None:
+            pulumi.set(__self__, "enable_defense", enable_defense)
+        if enable_drop_icmp is not None:
+            pulumi.set(__self__, "enable_drop_icmp", enable_drop_icmp)
+        if enable_intelligence is not None:
+            pulumi.set(__self__, "enable_intelligence", enable_intelligence)
+        if finger_print_rule_lists is not None:
+            pulumi.set(__self__, "finger_print_rule_lists", finger_print_rule_lists)
+        if intelligence_level is not None:
+            pulumi.set(__self__, "intelligence_level", intelligence_level)
+        if layer4_rule_lists is not None:
+            pulumi.set(__self__, "layer4_rule_lists", layer4_rule_lists)
+        if port_rule_lists is not None:
+            pulumi.set(__self__, "port_rule_lists", port_rule_lists)
+        if reflect_block_udp_port_lists is not None:
+            pulumi.set(__self__, "reflect_block_udp_port_lists", reflect_block_udp_port_lists)
+        if region_block_country_lists is not None:
+            pulumi.set(__self__, "region_block_country_lists", region_block_country_lists)
+        if region_block_province_lists is not None:
+            pulumi.set(__self__, "region_block_province_lists", region_block_province_lists)
+        if source_block_lists is not None:
+            pulumi.set(__self__, "source_block_lists", source_block_lists)
+        if source_limit is not None:
+            pulumi.set(__self__, "source_limit", source_limit)
+        if whiten_gfbr_nets is not None:
+            pulumi.set(__self__, "whiten_gfbr_nets", whiten_gfbr_nets)
+
+    @property
+    @pulumi.getter(name="blackIpListExpireAt")
+    def black_ip_list_expire_at(self) -> Optional[int]:
+        """
+        Blacklist and whitelist timeout.
+        """
+        return pulumi.get(self, "black_ip_list_expire_at")
+
+    @property
+    @pulumi.getter(name="enableDefense")
+    def enable_defense(self) -> Optional[bool]:
+        """
+        Whether to enable L4 protection.
+        """
+        return pulumi.get(self, "enable_defense")
+
+    @property
+    @pulumi.getter(name="enableDropIcmp")
+    def enable_drop_icmp(self) -> Optional[bool]:
+        """
+        Switch to discard ICMP.
+        """
+        return pulumi.get(self, "enable_drop_icmp")
+
+    @property
+    @pulumi.getter(name="enableIntelligence")
+    def enable_intelligence(self) -> Optional[bool]:
+        """
+        Whether the intelligent switch is on.
+        """
+        return pulumi.get(self, "enable_intelligence")
+
+    @property
+    @pulumi.getter(name="fingerPrintRuleLists")
+    def finger_print_rule_lists(self) -> Optional[Sequence['outputs.BgpPolicyContentFingerPrintRuleList']]:
+        """
+        Fingerprint Rules. See `finger_print_rule_list` below.
+        """
+        return pulumi.get(self, "finger_print_rule_lists")
+
+    @property
+    @pulumi.getter(name="intelligenceLevel")
+    def intelligence_level(self) -> Optional[str]:
+        """
+        Smart mode. Valid values: weak, hard, and default.
+        """
+        return pulumi.get(self, "intelligence_level")
+
+    @property
+    @pulumi.getter(name="layer4RuleLists")
+    def layer4_rule_lists(self) -> Optional[Sequence['outputs.BgpPolicyContentLayer4RuleList']]:
+        """
+        L4 protection rules. See `layer4_rule_list` below.
+        """
+        return pulumi.get(self, "layer4_rule_lists")
+
+    @property
+    @pulumi.getter(name="portRuleLists")
+    def port_rule_lists(self) -> Optional[Sequence['outputs.BgpPolicyContentPortRuleList']]:
+        """
+        Port Rule List. See `port_rule_list` below.
+        """
+        return pulumi.get(self, "port_rule_lists")
+
+    @property
+    @pulumi.getter(name="reflectBlockUdpPortLists")
+    def reflect_block_udp_port_lists(self) -> Optional[Sequence[int]]:
+        """
+        Reflective port filtering.
+        """
+        return pulumi.get(self, "reflect_block_udp_port_lists")
+
+    @property
+    @pulumi.getter(name="regionBlockCountryLists")
+    def region_block_country_lists(self) -> Optional[Sequence[int]]:
+        """
+        List of Regional Banned Countries.
+        """
+        return pulumi.get(self, "region_block_country_lists")
+
+    @property
+    @pulumi.getter(name="regionBlockProvinceLists")
+    def region_block_province_lists(self) -> Optional[Sequence[int]]:
+        """
+        List of Prohibited Provinces by Region.
+        """
+        return pulumi.get(self, "region_block_province_lists")
+
+    @property
+    @pulumi.getter(name="sourceBlockLists")
+    def source_block_lists(self) -> Optional[Sequence['outputs.BgpPolicyContentSourceBlockList']]:
+        """
+        Source pull Black. See `source_block_list` below.
+        """
+        return pulumi.get(self, "source_block_lists")
+
+    @property
+    @pulumi.getter(name="sourceLimit")
+    def source_limit(self) -> Optional['outputs.BgpPolicyContentSourceLimit']:
+        """
+        Do not fill in when the source speed limit is deleted. See `source_limit` below.
+        """
+        return pulumi.get(self, "source_limit")
+
+    @property
+    @pulumi.getter(name="whitenGfbrNets")
+    def whiten_gfbr_nets(self) -> Optional[bool]:
+        """
+        Add white high protection back to source network segment switch.
+        """
+        return pulumi.get(self, "whiten_gfbr_nets")
+
+
+@pulumi.output_type
+class BgpPolicyContentFingerPrintRuleList(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dstPortEnd":
+            suggest = "dst_port_end"
+        elif key == "dstPortStart":
+            suggest = "dst_port_start"
+        elif key == "matchAction":
+            suggest = "match_action"
+        elif key == "maxPktLen":
+            suggest = "max_pkt_len"
+        elif key == "minPktLen":
+            suggest = "min_pkt_len"
+        elif key == "seqNo":
+            suggest = "seq_no"
+        elif key == "srcPortEnd":
+            suggest = "src_port_end"
+        elif key == "srcPortStart":
+            suggest = "src_port_start"
+        elif key == "fingerPrintRuleId":
+            suggest = "finger_print_rule_id"
+        elif key == "payloadBytes":
+            suggest = "payload_bytes"
+        elif key == "rateValue":
+            suggest = "rate_value"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BgpPolicyContentFingerPrintRuleList. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BgpPolicyContentFingerPrintRuleList.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BgpPolicyContentFingerPrintRuleList.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dst_port_end: int,
+                 dst_port_start: int,
+                 match_action: str,
+                 max_pkt_len: int,
+                 min_pkt_len: int,
+                 protocol: str,
+                 seq_no: int,
+                 src_port_end: int,
+                 src_port_start: int,
+                 finger_print_rule_id: Optional[str] = None,
+                 offset: Optional[int] = None,
+                 payload_bytes: Optional[str] = None,
+                 rate_value: Optional[int] = None):
+        """
+        :param int dst_port_end: End of destination port 0-65535.
+        :param int dst_port_start: Destination Port start 0-65535.
+        :param str match_action: Action. Currently, only drop is supported.
+        :param int max_pkt_len: Maximum bag length.
+        :param int min_pkt_len: Minimum package length.
+        :param str protocol: Protocol, tcp or udp.
+        :param int seq_no: Serial number 1-100 ● Affects the order issued by the bottom layer ● The larger the number, the lower it is.
+        :param int src_port_end: Source Port end 0-65535.
+        :param int src_port_start: Source port start 0-65535.
+        :param str finger_print_rule_id: The UUID of the rule is required to be deleted and modified, and it is not required to be created.
+        :param int offset: Offset.
+        :param str payload_bytes: Load match, hexadecimal string; Similar to 'abcd'.
+        :param int rate_value: Speed limit value 1-100000.
+        """
+        pulumi.set(__self__, "dst_port_end", dst_port_end)
+        pulumi.set(__self__, "dst_port_start", dst_port_start)
+        pulumi.set(__self__, "match_action", match_action)
+        pulumi.set(__self__, "max_pkt_len", max_pkt_len)
+        pulumi.set(__self__, "min_pkt_len", min_pkt_len)
+        pulumi.set(__self__, "protocol", protocol)
+        pulumi.set(__self__, "seq_no", seq_no)
+        pulumi.set(__self__, "src_port_end", src_port_end)
+        pulumi.set(__self__, "src_port_start", src_port_start)
+        if finger_print_rule_id is not None:
+            pulumi.set(__self__, "finger_print_rule_id", finger_print_rule_id)
+        if offset is not None:
+            pulumi.set(__self__, "offset", offset)
+        if payload_bytes is not None:
+            pulumi.set(__self__, "payload_bytes", payload_bytes)
+        if rate_value is not None:
+            pulumi.set(__self__, "rate_value", rate_value)
+
+    @property
+    @pulumi.getter(name="dstPortEnd")
+    def dst_port_end(self) -> int:
+        """
+        End of destination port 0-65535.
+        """
+        return pulumi.get(self, "dst_port_end")
+
+    @property
+    @pulumi.getter(name="dstPortStart")
+    def dst_port_start(self) -> int:
+        """
+        Destination Port start 0-65535.
+        """
+        return pulumi.get(self, "dst_port_start")
+
+    @property
+    @pulumi.getter(name="matchAction")
+    def match_action(self) -> str:
+        """
+        Action. Currently, only drop is supported.
+        """
+        return pulumi.get(self, "match_action")
+
+    @property
+    @pulumi.getter(name="maxPktLen")
+    def max_pkt_len(self) -> int:
+        """
+        Maximum bag length.
+        """
+        return pulumi.get(self, "max_pkt_len")
+
+    @property
+    @pulumi.getter(name="minPktLen")
+    def min_pkt_len(self) -> int:
+        """
+        Minimum package length.
+        """
+        return pulumi.get(self, "min_pkt_len")
+
+    @property
+    @pulumi.getter
+    def protocol(self) -> str:
+        """
+        Protocol, tcp or udp.
+        """
+        return pulumi.get(self, "protocol")
+
+    @property
+    @pulumi.getter(name="seqNo")
+    def seq_no(self) -> int:
+        """
+        Serial number 1-100 ● Affects the order issued by the bottom layer ● The larger the number, the lower it is.
+        """
+        return pulumi.get(self, "seq_no")
+
+    @property
+    @pulumi.getter(name="srcPortEnd")
+    def src_port_end(self) -> int:
+        """
+        Source Port end 0-65535.
+        """
+        return pulumi.get(self, "src_port_end")
+
+    @property
+    @pulumi.getter(name="srcPortStart")
+    def src_port_start(self) -> int:
+        """
+        Source port start 0-65535.
+        """
+        return pulumi.get(self, "src_port_start")
+
+    @property
+    @pulumi.getter(name="fingerPrintRuleId")
+    def finger_print_rule_id(self) -> Optional[str]:
+        """
+        The UUID of the rule is required to be deleted and modified, and it is not required to be created.
+        """
+        return pulumi.get(self, "finger_print_rule_id")
+
+    @property
+    @pulumi.getter
+    def offset(self) -> Optional[int]:
+        """
+        Offset.
+        """
+        return pulumi.get(self, "offset")
+
+    @property
+    @pulumi.getter(name="payloadBytes")
+    def payload_bytes(self) -> Optional[str]:
+        """
+        Load match, hexadecimal string; Similar to 'abcd'.
+        """
+        return pulumi.get(self, "payload_bytes")
+
+    @property
+    @pulumi.getter(name="rateValue")
+    def rate_value(self) -> Optional[int]:
+        """
+        Speed limit value 1-100000.
+        """
+        return pulumi.get(self, "rate_value")
+
+
+@pulumi.output_type
+class BgpPolicyContentLayer4RuleList(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "conditionLists":
+            suggest = "condition_lists"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BgpPolicyContentLayer4RuleList. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BgpPolicyContentLayer4RuleList.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BgpPolicyContentLayer4RuleList.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 action: str,
+                 condition_lists: Sequence['outputs.BgpPolicyContentLayer4RuleListConditionList'],
+                 limited: int,
+                 match: str,
+                 method: str,
+                 name: str,
+                 priority: int):
+        """
+        :param str action: 1 for observation 2 for blocking.
+        :param Sequence['BgpPolicyContentLayer4RuleListConditionListArgs'] condition_lists: Matching Condition. See `condition_list` below.
+        :param int limited: .
+        :param str match: 0 indicates that the condition is not met 1 indicates that the condition is met.
+        :param str method: Char indicates a string match hex match.
+        :param str name: Rule Name.
+        :param int priority: 1-100, priority, the lower the number, the higher the priority.
+        """
+        pulumi.set(__self__, "action", action)
+        pulumi.set(__self__, "condition_lists", condition_lists)
+        pulumi.set(__self__, "limited", limited)
+        pulumi.set(__self__, "match", match)
+        pulumi.set(__self__, "method", method)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "priority", priority)
+
+    @property
+    @pulumi.getter
+    def action(self) -> str:
+        """
+        1 for observation 2 for blocking.
+        """
+        return pulumi.get(self, "action")
+
+    @property
+    @pulumi.getter(name="conditionLists")
+    def condition_lists(self) -> Sequence['outputs.BgpPolicyContentLayer4RuleListConditionList']:
+        """
+        Matching Condition. See `condition_list` below.
+        """
+        return pulumi.get(self, "condition_lists")
+
+    @property
+    @pulumi.getter
+    def limited(self) -> int:
+        """
+        .
+        """
+        return pulumi.get(self, "limited")
+
+    @property
+    @pulumi.getter
+    def match(self) -> str:
+        """
+        0 indicates that the condition is not met 1 indicates that the condition is met.
+        """
+        return pulumi.get(self, "match")
+
+    @property
+    @pulumi.getter
+    def method(self) -> str:
+        """
+        Char indicates a string match hex match.
+        """
+        return pulumi.get(self, "method")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Rule Name.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def priority(self) -> int:
+        """
+        1-100, priority, the lower the number, the higher the priority.
+        """
+        return pulumi.get(self, "priority")
+
+
+@pulumi.output_type
+class BgpPolicyContentLayer4RuleListConditionList(dict):
+    def __init__(__self__, *,
+                 arg: str,
+                 depth: int,
+                 position: int):
+        """
+        :param str arg: Matching target character.
+        :param int depth: Depth of Matching.
+        :param int position: Position to start matching, starting from 0.
+        """
+        pulumi.set(__self__, "arg", arg)
+        pulumi.set(__self__, "depth", depth)
+        pulumi.set(__self__, "position", position)
+
+    @property
+    @pulumi.getter
+    def arg(self) -> str:
+        """
+        Matching target character.
+        """
+        return pulumi.get(self, "arg")
+
+    @property
+    @pulumi.getter
+    def depth(self) -> int:
+        """
+        Depth of Matching.
+        """
+        return pulumi.get(self, "depth")
+
+    @property
+    @pulumi.getter
+    def position(self) -> int:
+        """
+        Position to start matching, starting from 0.
+        """
+        return pulumi.get(self, "position")
+
+
+@pulumi.output_type
+class BgpPolicyContentPortRuleList(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dstPortEnd":
+            suggest = "dst_port_end"
+        elif key == "dstPortStart":
+            suggest = "dst_port_start"
+        elif key == "matchAction":
+            suggest = "match_action"
+        elif key == "seqNo":
+            suggest = "seq_no"
+        elif key == "srcPortEnd":
+            suggest = "src_port_end"
+        elif key == "srcPortStart":
+            suggest = "src_port_start"
+        elif key == "portRuleId":
+            suggest = "port_rule_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BgpPolicyContentPortRuleList. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BgpPolicyContentPortRuleList.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BgpPolicyContentPortRuleList.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dst_port_end: int,
+                 dst_port_start: int,
+                 match_action: str,
+                 protocol: str,
+                 seq_no: int,
+                 src_port_end: int,
+                 src_port_start: int,
+                 port_rule_id: Optional[str] = None):
+        """
+        :param int dst_port_end: End of destination port 0-65535.
+        :param int dst_port_start: Destination Port start 0-65535.
+        :param str match_action: Action. Currently, only drop is supported.
+        :param str protocol: Protocol, tcp or udp.
+        :param int seq_no: Serial number 1-100 ● Affects the order issued by the bottom layer ● The larger the number, the lower it is.
+        :param int src_port_end: Source Port end 0-65535.
+        :param int src_port_start: Source port start 0-65535.
+        :param str port_rule_id: Rule UUID is required to be deleted and modified, and is not required to be created.
+        """
+        pulumi.set(__self__, "dst_port_end", dst_port_end)
+        pulumi.set(__self__, "dst_port_start", dst_port_start)
+        pulumi.set(__self__, "match_action", match_action)
+        pulumi.set(__self__, "protocol", protocol)
+        pulumi.set(__self__, "seq_no", seq_no)
+        pulumi.set(__self__, "src_port_end", src_port_end)
+        pulumi.set(__self__, "src_port_start", src_port_start)
+        if port_rule_id is not None:
+            pulumi.set(__self__, "port_rule_id", port_rule_id)
+
+    @property
+    @pulumi.getter(name="dstPortEnd")
+    def dst_port_end(self) -> int:
+        """
+        End of destination port 0-65535.
+        """
+        return pulumi.get(self, "dst_port_end")
+
+    @property
+    @pulumi.getter(name="dstPortStart")
+    def dst_port_start(self) -> int:
+        """
+        Destination Port start 0-65535.
+        """
+        return pulumi.get(self, "dst_port_start")
+
+    @property
+    @pulumi.getter(name="matchAction")
+    def match_action(self) -> str:
+        """
+        Action. Currently, only drop is supported.
+        """
+        return pulumi.get(self, "match_action")
+
+    @property
+    @pulumi.getter
+    def protocol(self) -> str:
+        """
+        Protocol, tcp or udp.
+        """
+        return pulumi.get(self, "protocol")
+
+    @property
+    @pulumi.getter(name="seqNo")
+    def seq_no(self) -> int:
+        """
+        Serial number 1-100 ● Affects the order issued by the bottom layer ● The larger the number, the lower it is.
+        """
+        return pulumi.get(self, "seq_no")
+
+    @property
+    @pulumi.getter(name="srcPortEnd")
+    def src_port_end(self) -> int:
+        """
+        Source Port end 0-65535.
+        """
+        return pulumi.get(self, "src_port_end")
+
+    @property
+    @pulumi.getter(name="srcPortStart")
+    def src_port_start(self) -> int:
+        """
+        Source port start 0-65535.
+        """
+        return pulumi.get(self, "src_port_start")
+
+    @property
+    @pulumi.getter(name="portRuleId")
+    def port_rule_id(self) -> Optional[str]:
+        """
+        Rule UUID is required to be deleted and modified, and is not required to be created.
+        """
+        return pulumi.get(self, "port_rule_id")
+
+
+@pulumi.output_type
+class BgpPolicyContentSourceBlockList(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "blockExpireSeconds":
+            suggest = "block_expire_seconds"
+        elif key == "everySeconds":
+            suggest = "every_seconds"
+        elif key == "exceedLimitTimes":
+            suggest = "exceed_limit_times"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BgpPolicyContentSourceBlockList. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BgpPolicyContentSourceBlockList.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BgpPolicyContentSourceBlockList.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 block_expire_seconds: int,
+                 every_seconds: int,
+                 exceed_limit_times: int,
+                 type: int):
+        """
+        :param int block_expire_seconds: Statistical cycle range 60-1200.
+        :param int every_seconds: The time (unit second) for automatically releasing the black after triggering the speed limit is 60~2592000.
+        :param int exceed_limit_times: The number of times the speed limit is exceeded in a statistical period ranges from 1 to 1200.
+        :param int type: Type
+        """
+        pulumi.set(__self__, "block_expire_seconds", block_expire_seconds)
+        pulumi.set(__self__, "every_seconds", every_seconds)
+        pulumi.set(__self__, "exceed_limit_times", exceed_limit_times)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter(name="blockExpireSeconds")
+    def block_expire_seconds(self) -> int:
+        """
+        Statistical cycle range 60-1200.
+        """
+        return pulumi.get(self, "block_expire_seconds")
+
+    @property
+    @pulumi.getter(name="everySeconds")
+    def every_seconds(self) -> int:
+        """
+        The time (unit second) for automatically releasing the black after triggering the speed limit is 60~2592000.
+        """
+        return pulumi.get(self, "every_seconds")
+
+    @property
+    @pulumi.getter(name="exceedLimitTimes")
+    def exceed_limit_times(self) -> int:
+        """
+        The number of times the speed limit is exceeded in a statistical period ranges from 1 to 1200.
+        """
+        return pulumi.get(self, "exceed_limit_times")
+
+    @property
+    @pulumi.getter
+    def type(self) -> int:
+        """
+        Type
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class BgpPolicyContentSourceLimit(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "synBps":
+            suggest = "syn_bps"
+        elif key == "synPps":
+            suggest = "syn_pps"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BgpPolicyContentSourceLimit. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BgpPolicyContentSourceLimit.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BgpPolicyContentSourceLimit.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bps: Optional[int] = None,
+                 pps: Optional[int] = None,
+                 syn_bps: Optional[int] = None,
+                 syn_pps: Optional[int] = None):
+        """
+        :param int bps: bps range 1024~268435456.
+        :param int pps: Pps range 32~500000.
+        :param int syn_bps: SynBps range 1024~268435456.
+        :param int syn_pps: SynPps range 1~100000.
+        """
+        if bps is not None:
+            pulumi.set(__self__, "bps", bps)
+        if pps is not None:
+            pulumi.set(__self__, "pps", pps)
+        if syn_bps is not None:
+            pulumi.set(__self__, "syn_bps", syn_bps)
+        if syn_pps is not None:
+            pulumi.set(__self__, "syn_pps", syn_pps)
+
+    @property
+    @pulumi.getter
+    def bps(self) -> Optional[int]:
+        """
+        bps range 1024~268435456.
+        """
+        return pulumi.get(self, "bps")
+
+    @property
+    @pulumi.getter
+    def pps(self) -> Optional[int]:
+        """
+        Pps range 32~500000.
+        """
+        return pulumi.get(self, "pps")
+
+    @property
+    @pulumi.getter(name="synBps")
+    def syn_bps(self) -> Optional[int]:
+        """
+        SynBps range 1024~268435456.
+        """
+        return pulumi.get(self, "syn_bps")
+
+    @property
+    @pulumi.getter(name="synPps")
+    def syn_pps(self) -> Optional[int]:
+        """
+        SynPps range 1~100000.
+        """
+        return pulumi.get(self, "syn_pps")
+
+
 @pulumi.output_type
 class DomainResourceProxyType(dict):
     @staticmethod
@@ -43,22 +877,21 @@ class DomainResourceProxyType(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 proxy_ports: Optional[Sequence[int]] = None,
+                 proxy_ports: Sequence[int],
                  proxy_type: Optional[str] = None):
         """
-        :param Sequence[int] proxy_ports: the port number. This field is required and must be an integer. **NOTE:** From version 1.206.0, `proxy_ports` can be modified.
-        :param str proxy_type: the protocol type. This field is required and must be a string. Valid values: `http`, `https`, `websocket`, and `websockets`.
+        :param Sequence[int] proxy_ports: The port numbers.
+        :param str proxy_type: The type of the protocol. Valid values:
         """
-        if proxy_ports is not None:
-            pulumi.set(__self__, "proxy_ports", proxy_ports)
+        pulumi.set(__self__, "proxy_ports", proxy_ports)
         if proxy_type is not None:
             pulumi.set(__self__, "proxy_type", proxy_type)
 
     @property
     @pulumi.getter(name="proxyPorts")
-    def proxy_ports(self) -> Optional[Sequence[int]]:
+    def proxy_ports(self) -> Sequence[int]:
         """
-        the port number. This field is required and must be an integer. **NOTE:** From version 1.206.0, `proxy_ports` can be modified.
+        The port numbers.
         """
         return pulumi.get(self, "proxy_ports")
 
@@ -66,11 +899,47 @@ class DomainResourceProxyType(dict):
     @pulumi.getter(name="proxyType")
     def proxy_type(self) -> Optional[str]:
         """
-        the protocol type. This field is required and must be a string. Valid values: `http`, `https`, `websocket`, and `websockets`.
+        The type of the protocol. Valid values:
         """
         return pulumi.get(self, "proxy_type")
 
 
+@pulumi.output_type
+class PortConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "persistenceTimeout":
+            suggest = "persistence_timeout"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PortConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PortConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PortConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 persistence_timeout: Optional[int] = None):
+        """
+        :param int persistence_timeout: The timeout period for session retention. Value range: 30~3600, unit: second. The default is 0, which means off.
+        """
+        if persistence_timeout is not None:
+            pulumi.set(__self__, "persistence_timeout", persistence_timeout)
+
+    @property
+    @pulumi.getter(name="persistenceTimeout")
+    def persistence_timeout(self) -> Optional[int]:
+        """
+        The timeout period for session retention. Value range: 30~3600, unit: second. The default is 0, which means off.
+        """
+        return pulumi.get(self, "persistence_timeout")
+
+
 @pulumi.output_type
 class SchedulerRuleRule(dict):
     @staticmethod
@@ -380,7 +1249,7 @@ class GetDdosCooDomainResourcesResourceResult(dict):
         :param bool http2_enable: Whether Http2.0 is enabled.
         :param str https_ext: The advanced HTTPS settings.
         :param str id: The ID of the Domain Resource.
-        :param Sequence[str] instance_ids: A list ID of instance that you want to associate.
+        :param Sequence[str] instance_ids: A ID list of Ddoscoo instance.
         :param str policy_mode: The type of backload algorithm.
         :param bool proxy_enabled: Whether the website service forwarding rules have been turned on.
         :param Sequence['GetDdosCooDomainResourcesResourceProxyTypeArgs'] proxy_types: Protocol type and port number information.
@@ -485,7 +1354,7 @@ class GetDdosCooDomainResourcesResourceResult(dict):
     @pulumi.getter(name="instanceIds")
     def instance_ids(self) -> Sequence[str]:
         """
-        A list ID of instance that you want to associate.
+        A ID list of Ddoscoo instance.
         """
         return pulumi.get(self, "instance_ids")
 
@@ -778,9 +1647,9 @@ class GetDdosCooPortsPortResult(dict):
         """
         :param str backend_port: The source station port.
         :param str frontend_port: The forwarding port.
-        :param str frontend_protocol: The forwarding protocol.
+        :param str frontend_protocol: The forwarding protocol. Valid values `tcp` and `udp`.
         :param str id: The ID of the Port.
-        :param str instance_id: The Ddoscoo instance ID.
+        :param str instance_id: The DdosCoo instance ID.
         :param Sequence[str] real_servers: List of source IP addresses.
         """
         pulumi.set(__self__, "backend_port", backend_port)
@@ -810,7 +1679,7 @@ class GetDdosCooPortsPortResult(dict):
     @pulumi.getter(name="frontendProtocol")
     def frontend_protocol(self) -> str:
         """
-        The forwarding protocol.
+        The forwarding protocol. Valid values `tcp` and `udp`.
         """
         return pulumi.get(self, "frontend_protocol")
 
@@ -826,7 +1695,7 @@ class GetDdosCooPortsPortResult(dict):
     @pulumi.getter(name="instanceId")
     def instance_id(self) -> str:
         """
-        The Ddoscoo instance ID.
+        The DdosCoo instance ID.
         """
         return pulumi.get(self, "instance_id")