pulumi-alicloud 3.58.0a1719956927__py3-none-any.whl → 3.59.0__py3-none-any.whl

pulumi_alicloud/ddos/_inputs.py

@@ -10,10 +10,722 @@ from typing import Any, Mapping, Optional, Sequence, Union, overload
 from .. import _utilities
 
 __all__ = [
+    'BgpPolicyContentArgs',
+    'BgpPolicyContentFingerPrintRuleListArgs',
+    'BgpPolicyContentLayer4RuleListArgs',
+    'BgpPolicyContentLayer4RuleListConditionListArgs',
+    'BgpPolicyContentPortRuleListArgs',
+    'BgpPolicyContentSourceBlockListArgs',
+    'BgpPolicyContentSourceLimitArgs',
     'DomainResourceProxyTypeArgs',
     'SchedulerRuleRuleArgs',
 ]
 
+@pulumi.input_type
+class BgpPolicyContentArgs:
+    def __init__(__self__, *,
+                 black_ip_list_expire_at: Optional[pulumi.Input[int]] = None,
+                 enable_defense: Optional[pulumi.Input[bool]] = None,
+                 enable_drop_icmp: Optional[pulumi.Input[bool]] = None,
+                 enable_intelligence: Optional[pulumi.Input[bool]] = None,
+                 finger_print_rule_lists: Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentFingerPrintRuleListArgs']]]] = None,
+                 intelligence_level: Optional[pulumi.Input[str]] = None,
+                 layer4_rule_lists: Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentLayer4RuleListArgs']]]] = None,
+                 port_rule_lists: Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentPortRuleListArgs']]]] = None,
+                 reflect_block_udp_port_lists: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
+                 region_block_country_lists: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
+                 region_block_province_lists: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
+                 source_block_lists: Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentSourceBlockListArgs']]]] = None,
+                 source_limit: Optional[pulumi.Input['BgpPolicyContentSourceLimitArgs']] = None,
+                 whiten_gfbr_nets: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[int] black_ip_list_expire_at: Blacklist and whitelist timeout.
+        :param pulumi.Input[bool] enable_defense: Whether to enable L4 protection.
+        :param pulumi.Input[bool] enable_drop_icmp: Switch to discard ICMP.
+        :param pulumi.Input[bool] enable_intelligence: Whether the intelligent switch is on.
+        :param pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentFingerPrintRuleListArgs']]] finger_print_rule_lists: Fingerprint Rules. See `finger_print_rule_list` below.
+        :param pulumi.Input[str] intelligence_level: Smart mode. Valid values: weak, hard, and default.
+        :param pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentLayer4RuleListArgs']]] layer4_rule_lists: L4 protection rules. See `layer4_rule_list` below.
+        :param pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentPortRuleListArgs']]] port_rule_lists: Port Rule List. See `port_rule_list` below.
+        :param pulumi.Input[Sequence[pulumi.Input[int]]] reflect_block_udp_port_lists: Reflective port filtering.
+        :param pulumi.Input[Sequence[pulumi.Input[int]]] region_block_country_lists: List of Regional Banned Countries.
+        :param pulumi.Input[Sequence[pulumi.Input[int]]] region_block_province_lists: List of Prohibited Provinces by Region.
+        :param pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentSourceBlockListArgs']]] source_block_lists: Source pull Black. See `source_block_list` below.
+        :param pulumi.Input['BgpPolicyContentSourceLimitArgs'] source_limit: Do not fill in when the source speed limit is deleted. See `source_limit` below.
+        :param pulumi.Input[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[pulumi.Input[int]]:
+        """
+        Blacklist and whitelist timeout.
+        """
+        return pulumi.get(self, "black_ip_list_expire_at")
+
+    @black_ip_list_expire_at.setter
+    def black_ip_list_expire_at(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "black_ip_list_expire_at", value)
+
+    @property
+    @pulumi.getter(name="enableDefense")
+    def enable_defense(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether to enable L4 protection.
+        """
+        return pulumi.get(self, "enable_defense")
+
+    @enable_defense.setter
+    def enable_defense(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enable_defense", value)
+
+    @property
+    @pulumi.getter(name="enableDropIcmp")
+    def enable_drop_icmp(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Switch to discard ICMP.
+        """
+        return pulumi.get(self, "enable_drop_icmp")
+
+    @enable_drop_icmp.setter
+    def enable_drop_icmp(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enable_drop_icmp", value)
+
+    @property
+    @pulumi.getter(name="enableIntelligence")
+    def enable_intelligence(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether the intelligent switch is on.
+        """
+        return pulumi.get(self, "enable_intelligence")
+
+    @enable_intelligence.setter
+    def enable_intelligence(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enable_intelligence", value)
+
+    @property
+    @pulumi.getter(name="fingerPrintRuleLists")
+    def finger_print_rule_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentFingerPrintRuleListArgs']]]]:
+        """
+        Fingerprint Rules. See `finger_print_rule_list` below.
+        """
+        return pulumi.get(self, "finger_print_rule_lists")
+
+    @finger_print_rule_lists.setter
+    def finger_print_rule_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentFingerPrintRuleListArgs']]]]):
+        pulumi.set(self, "finger_print_rule_lists", value)
+
+    @property
+    @pulumi.getter(name="intelligenceLevel")
+    def intelligence_level(self) -> Optional[pulumi.Input[str]]:
+        """
+        Smart mode. Valid values: weak, hard, and default.
+        """
+        return pulumi.get(self, "intelligence_level")
+
+    @intelligence_level.setter
+    def intelligence_level(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "intelligence_level", value)
+
+    @property
+    @pulumi.getter(name="layer4RuleLists")
+    def layer4_rule_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentLayer4RuleListArgs']]]]:
+        """
+        L4 protection rules. See `layer4_rule_list` below.
+        """
+        return pulumi.get(self, "layer4_rule_lists")
+
+    @layer4_rule_lists.setter
+    def layer4_rule_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentLayer4RuleListArgs']]]]):
+        pulumi.set(self, "layer4_rule_lists", value)
+
+    @property
+    @pulumi.getter(name="portRuleLists")
+    def port_rule_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentPortRuleListArgs']]]]:
+        """
+        Port Rule List. See `port_rule_list` below.
+        """
+        return pulumi.get(self, "port_rule_lists")
+
+    @port_rule_lists.setter
+    def port_rule_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentPortRuleListArgs']]]]):
+        pulumi.set(self, "port_rule_lists", value)
+
+    @property
+    @pulumi.getter(name="reflectBlockUdpPortLists")
+    def reflect_block_udp_port_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
+        """
+        Reflective port filtering.
+        """
+        return pulumi.get(self, "reflect_block_udp_port_lists")
+
+    @reflect_block_udp_port_lists.setter
+    def reflect_block_udp_port_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
+        pulumi.set(self, "reflect_block_udp_port_lists", value)
+
+    @property
+    @pulumi.getter(name="regionBlockCountryLists")
+    def region_block_country_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
+        """
+        List of Regional Banned Countries.
+        """
+        return pulumi.get(self, "region_block_country_lists")
+
+    @region_block_country_lists.setter
+    def region_block_country_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
+        pulumi.set(self, "region_block_country_lists", value)
+
+    @property
+    @pulumi.getter(name="regionBlockProvinceLists")
+    def region_block_province_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
+        """
+        List of Prohibited Provinces by Region.
+        """
+        return pulumi.get(self, "region_block_province_lists")
+
+    @region_block_province_lists.setter
+    def region_block_province_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
+        pulumi.set(self, "region_block_province_lists", value)
+
+    @property
+    @pulumi.getter(name="sourceBlockLists")
+    def source_block_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentSourceBlockListArgs']]]]:
+        """
+        Source pull Black. See `source_block_list` below.
+        """
+        return pulumi.get(self, "source_block_lists")
+
+    @source_block_lists.setter
+    def source_block_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentSourceBlockListArgs']]]]):
+        pulumi.set(self, "source_block_lists", value)
+
+    @property
+    @pulumi.getter(name="sourceLimit")
+    def source_limit(self) -> Optional[pulumi.Input['BgpPolicyContentSourceLimitArgs']]:
+        """
+        Do not fill in when the source speed limit is deleted. See `source_limit` below.
+        """
+        return pulumi.get(self, "source_limit")
+
+    @source_limit.setter
+    def source_limit(self, value: Optional[pulumi.Input['BgpPolicyContentSourceLimitArgs']]):
+        pulumi.set(self, "source_limit", value)
+
+    @property
+    @pulumi.getter(name="whitenGfbrNets")
+    def whiten_gfbr_nets(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Add white high protection back to source network segment switch.
+        """
+        return pulumi.get(self, "whiten_gfbr_nets")
+
+    @whiten_gfbr_nets.setter
+    def whiten_gfbr_nets(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "whiten_gfbr_nets", value)
+
+
+@pulumi.input_type
+class BgpPolicyContentFingerPrintRuleListArgs:
+    def __init__(__self__, *,
+                 dst_port_end: pulumi.Input[int],
+                 dst_port_start: pulumi.Input[int],
+                 match_action: pulumi.Input[str],
+                 max_pkt_len: pulumi.Input[int],
+                 min_pkt_len: pulumi.Input[int],
+                 protocol: pulumi.Input[str],
+                 seq_no: pulumi.Input[int],
+                 src_port_end: pulumi.Input[int],
+                 src_port_start: pulumi.Input[int],
+                 finger_print_rule_id: Optional[pulumi.Input[str]] = None,
+                 offset: Optional[pulumi.Input[int]] = None,
+                 payload_bytes: Optional[pulumi.Input[str]] = None,
+                 rate_value: Optional[pulumi.Input[int]] = None):
+        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) -> pulumi.Input[int]:
+        return pulumi.get(self, "dst_port_end")
+
+    @dst_port_end.setter
+    def dst_port_end(self, value: pulumi.Input[int]):
+        pulumi.set(self, "dst_port_end", value)
+
+    @property
+    @pulumi.getter(name="dstPortStart")
+    def dst_port_start(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "dst_port_start")
+
+    @dst_port_start.setter
+    def dst_port_start(self, value: pulumi.Input[int]):
+        pulumi.set(self, "dst_port_start", value)
+
+    @property
+    @pulumi.getter(name="matchAction")
+    def match_action(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "match_action")
+
+    @match_action.setter
+    def match_action(self, value: pulumi.Input[str]):
+        pulumi.set(self, "match_action", value)
+
+    @property
+    @pulumi.getter(name="maxPktLen")
+    def max_pkt_len(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "max_pkt_len")
+
+    @max_pkt_len.setter
+    def max_pkt_len(self, value: pulumi.Input[int]):
+        pulumi.set(self, "max_pkt_len", value)
+
+    @property
+    @pulumi.getter(name="minPktLen")
+    def min_pkt_len(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "min_pkt_len")
+
+    @min_pkt_len.setter
+    def min_pkt_len(self, value: pulumi.Input[int]):
+        pulumi.set(self, "min_pkt_len", value)
+
+    @property
+    @pulumi.getter
+    def protocol(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "protocol")
+
+    @protocol.setter
+    def protocol(self, value: pulumi.Input[str]):
+        pulumi.set(self, "protocol", value)
+
+    @property
+    @pulumi.getter(name="seqNo")
+    def seq_no(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "seq_no")
+
+    @seq_no.setter
+    def seq_no(self, value: pulumi.Input[int]):
+        pulumi.set(self, "seq_no", value)
+
+    @property
+    @pulumi.getter(name="srcPortEnd")
+    def src_port_end(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "src_port_end")
+
+    @src_port_end.setter
+    def src_port_end(self, value: pulumi.Input[int]):
+        pulumi.set(self, "src_port_end", value)
+
+    @property
+    @pulumi.getter(name="srcPortStart")
+    def src_port_start(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "src_port_start")
+
+    @src_port_start.setter
+    def src_port_start(self, value: pulumi.Input[int]):
+        pulumi.set(self, "src_port_start", value)
+
+    @property
+    @pulumi.getter(name="fingerPrintRuleId")
+    def finger_print_rule_id(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "finger_print_rule_id")
+
+    @finger_print_rule_id.setter
+    def finger_print_rule_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "finger_print_rule_id", value)
+
+    @property
+    @pulumi.getter
+    def offset(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "offset")
+
+    @offset.setter
+    def offset(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "offset", value)
+
+    @property
+    @pulumi.getter(name="payloadBytes")
+    def payload_bytes(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "payload_bytes")
+
+    @payload_bytes.setter
+    def payload_bytes(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "payload_bytes", value)
+
+    @property
+    @pulumi.getter(name="rateValue")
+    def rate_value(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "rate_value")
+
+    @rate_value.setter
+    def rate_value(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "rate_value", value)
+
+
+@pulumi.input_type
+class BgpPolicyContentLayer4RuleListArgs:
+    def __init__(__self__, *,
+                 action: pulumi.Input[str],
+                 condition_lists: pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentLayer4RuleListConditionListArgs']]],
+                 limited: pulumi.Input[int],
+                 match: pulumi.Input[str],
+                 method: pulumi.Input[str],
+                 name: pulumi.Input[str],
+                 priority: pulumi.Input[int]):
+        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) -> pulumi.Input[str]:
+        return pulumi.get(self, "action")
+
+    @action.setter
+    def action(self, value: pulumi.Input[str]):
+        pulumi.set(self, "action", value)
+
+    @property
+    @pulumi.getter(name="conditionLists")
+    def condition_lists(self) -> pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentLayer4RuleListConditionListArgs']]]:
+        return pulumi.get(self, "condition_lists")
+
+    @condition_lists.setter
+    def condition_lists(self, value: pulumi.Input[Sequence[pulumi.Input['BgpPolicyContentLayer4RuleListConditionListArgs']]]):
+        pulumi.set(self, "condition_lists", value)
+
+    @property
+    @pulumi.getter
+    def limited(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "limited")
+
+    @limited.setter
+    def limited(self, value: pulumi.Input[int]):
+        pulumi.set(self, "limited", value)
+
+    @property
+    @pulumi.getter
+    def match(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "match")
+
+    @match.setter
+    def match(self, value: pulumi.Input[str]):
+        pulumi.set(self, "match", value)
+
+    @property
+    @pulumi.getter
+    def method(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "method")
+
+    @method.setter
+    def method(self, value: pulumi.Input[str]):
+        pulumi.set(self, "method", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def priority(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "priority")
+
+    @priority.setter
+    def priority(self, value: pulumi.Input[int]):
+        pulumi.set(self, "priority", value)
+
+
+@pulumi.input_type
+class BgpPolicyContentLayer4RuleListConditionListArgs:
+    def __init__(__self__, *,
+                 arg: pulumi.Input[str],
+                 depth: pulumi.Input[int],
+                 position: pulumi.Input[int]):
+        pulumi.set(__self__, "arg", arg)
+        pulumi.set(__self__, "depth", depth)
+        pulumi.set(__self__, "position", position)
+
+    @property
+    @pulumi.getter
+    def arg(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "arg")
+
+    @arg.setter
+    def arg(self, value: pulumi.Input[str]):
+        pulumi.set(self, "arg", value)
+
+    @property
+    @pulumi.getter
+    def depth(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "depth")
+
+    @depth.setter
+    def depth(self, value: pulumi.Input[int]):
+        pulumi.set(self, "depth", value)
+
+    @property
+    @pulumi.getter
+    def position(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "position")
+
+    @position.setter
+    def position(self, value: pulumi.Input[int]):
+        pulumi.set(self, "position", value)
+
+
+@pulumi.input_type
+class BgpPolicyContentPortRuleListArgs:
+    def __init__(__self__, *,
+                 dst_port_end: pulumi.Input[int],
+                 dst_port_start: pulumi.Input[int],
+                 match_action: pulumi.Input[str],
+                 protocol: pulumi.Input[str],
+                 seq_no: pulumi.Input[int],
+                 src_port_end: pulumi.Input[int],
+                 src_port_start: pulumi.Input[int],
+                 port_rule_id: Optional[pulumi.Input[str]] = None):
+        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) -> pulumi.Input[int]:
+        return pulumi.get(self, "dst_port_end")
+
+    @dst_port_end.setter
+    def dst_port_end(self, value: pulumi.Input[int]):
+        pulumi.set(self, "dst_port_end", value)
+
+    @property
+    @pulumi.getter(name="dstPortStart")
+    def dst_port_start(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "dst_port_start")
+
+    @dst_port_start.setter
+    def dst_port_start(self, value: pulumi.Input[int]):
+        pulumi.set(self, "dst_port_start", value)
+
+    @property
+    @pulumi.getter(name="matchAction")
+    def match_action(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "match_action")
+
+    @match_action.setter
+    def match_action(self, value: pulumi.Input[str]):
+        pulumi.set(self, "match_action", value)
+
+    @property
+    @pulumi.getter
+    def protocol(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "protocol")
+
+    @protocol.setter
+    def protocol(self, value: pulumi.Input[str]):
+        pulumi.set(self, "protocol", value)
+
+    @property
+    @pulumi.getter(name="seqNo")
+    def seq_no(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "seq_no")
+
+    @seq_no.setter
+    def seq_no(self, value: pulumi.Input[int]):
+        pulumi.set(self, "seq_no", value)
+
+    @property
+    @pulumi.getter(name="srcPortEnd")
+    def src_port_end(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "src_port_end")
+
+    @src_port_end.setter
+    def src_port_end(self, value: pulumi.Input[int]):
+        pulumi.set(self, "src_port_end", value)
+
+    @property
+    @pulumi.getter(name="srcPortStart")
+    def src_port_start(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "src_port_start")
+
+    @src_port_start.setter
+    def src_port_start(self, value: pulumi.Input[int]):
+        pulumi.set(self, "src_port_start", value)
+
+    @property
+    @pulumi.getter(name="portRuleId")
+    def port_rule_id(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "port_rule_id")
+
+    @port_rule_id.setter
+    def port_rule_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "port_rule_id", value)
+
+
+@pulumi.input_type
+class BgpPolicyContentSourceBlockListArgs:
+    def __init__(__self__, *,
+                 block_expire_seconds: pulumi.Input[int],
+                 every_seconds: pulumi.Input[int],
+                 exceed_limit_times: pulumi.Input[int],
+                 type: pulumi.Input[int]):
+        """
+        :param pulumi.Input[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) -> pulumi.Input[int]:
+        return pulumi.get(self, "block_expire_seconds")
+
+    @block_expire_seconds.setter
+    def block_expire_seconds(self, value: pulumi.Input[int]):
+        pulumi.set(self, "block_expire_seconds", value)
+
+    @property
+    @pulumi.getter(name="everySeconds")
+    def every_seconds(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "every_seconds")
+
+    @every_seconds.setter
+    def every_seconds(self, value: pulumi.Input[int]):
+        pulumi.set(self, "every_seconds", value)
+
+    @property
+    @pulumi.getter(name="exceedLimitTimes")
+    def exceed_limit_times(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "exceed_limit_times")
+
+    @exceed_limit_times.setter
+    def exceed_limit_times(self, value: pulumi.Input[int]):
+        pulumi.set(self, "exceed_limit_times", value)
+
+    @property
+    @pulumi.getter
+    def type(self) -> pulumi.Input[int]:
+        """
+        Type
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: pulumi.Input[int]):
+        pulumi.set(self, "type", value)
+
+
+@pulumi.input_type
+class BgpPolicyContentSourceLimitArgs:
+    def __init__(__self__, *,
+                 bps: Optional[pulumi.Input[int]] = None,
+                 pps: Optional[pulumi.Input[int]] = None,
+                 syn_bps: Optional[pulumi.Input[int]] = None,
+                 syn_pps: Optional[pulumi.Input[int]] = None):
+        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[pulumi.Input[int]]:
+        return pulumi.get(self, "bps")
+
+    @bps.setter
+    def bps(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "bps", value)
+
+    @property
+    @pulumi.getter
+    def pps(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "pps")
+
+    @pps.setter
+    def pps(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "pps", value)
+
+    @property
+    @pulumi.getter(name="synBps")
+    def syn_bps(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "syn_bps")
+
+    @syn_bps.setter
+    def syn_bps(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "syn_bps", value)
+
+    @property
+    @pulumi.getter(name="synPps")
+    def syn_pps(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "syn_pps")
+
+    @syn_pps.setter
+    def syn_pps(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "syn_pps", value)
+
+
 @pulumi.input_type
 class DomainResourceProxyTypeArgs:
     def __init__(__self__, *,