pulumi-alicloud 3.88.0a1761888283__py3-none-any.whl → 3.88.0a1761969289__py3-none-any.whl

pulumi_alicloud/wafv3/_inputs.py

@@ -21,10 +21,20 @@ __all__ = [
     'DefenseRuleConfigAccountIdentifierArgsDict',
     'DefenseRuleConfigConditionArgs',
     'DefenseRuleConfigConditionArgsDict',
+    'DefenseRuleConfigGrayConfigArgs',
+    'DefenseRuleConfigGrayConfigArgsDict',
     'DefenseRuleConfigRateLimitArgs',
     'DefenseRuleConfigRateLimitArgsDict',
     'DefenseRuleConfigRateLimitStatusArgs',
     'DefenseRuleConfigRateLimitStatusArgsDict',
+    'DefenseRuleConfigTimeConfigArgs',
+    'DefenseRuleConfigTimeConfigArgsDict',
+    'DefenseRuleConfigTimeConfigTimePeriodArgs',
+    'DefenseRuleConfigTimeConfigTimePeriodArgsDict',
+    'DefenseRuleConfigTimeConfigWeekTimePeriodArgs',
+    'DefenseRuleConfigTimeConfigWeekTimePeriodArgsDict',
+    'DefenseRuleConfigTimeConfigWeekTimePeriodDayPeriodArgs',
+    'DefenseRuleConfigTimeConfigWeekTimePeriodDayPeriodArgsDict',
     'DomainListenArgs',
     'DomainListenArgsDict',
     'DomainRedirectArgs',
@@ -114,6 +124,16 @@ if not MYPY:
         """
         The traffic characteristics of ACL, which are described in JSON format. You can enter up to five matching conditions. For specific configuration information, see detailed configuration of conditions. See `conditions` below.
         """
+        gray_config: NotRequired[pulumi.Input['DefenseRuleConfigGrayConfigArgsDict']]
+        """
+        The canary release configuration for the rule. The value is a JSON. This parameter is required only when you set `GrayStatus` to 1. See `gray_config` below.
+        """
+        gray_status: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Specifies whether to enable canary release for the rule. Valid values:
+        - 0 (default): disables canary release.
+        - 1: enables canary release.
+        """
         mode: NotRequired[pulumi.Input[_builtins.int]]
         """
         The HTTP flood protection mode. Valid values:
@@ -156,6 +176,10 @@ if not MYPY:
         - qps: indicates throttling based on queries per second (QPS).
         - ratio (default): indicates throttling based on percentage.
         """
+        time_config: NotRequired[pulumi.Input['DefenseRuleConfigTimeConfigArgsDict']]
+        """
+        The scheduled rule configuration. The value is a JSON.  See `time_config` below.
+        """
         ua: NotRequired[pulumi.Input[_builtins.str]]
         """
         The User-Agent string that is allowed for access to the address.
@@ -179,6 +203,8 @@ class DefenseRuleConfigArgs:
                  cc_status: Optional[pulumi.Input[_builtins.int]] = None,
                  cn_regions: Optional[pulumi.Input[_builtins.str]] = None,
                  conditions: Optional[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigConditionArgs']]]] = None,
+                 gray_config: Optional[pulumi.Input['DefenseRuleConfigGrayConfigArgs']] = None,
+                 gray_status: Optional[pulumi.Input[_builtins.int]] = None,
                  mode: Optional[pulumi.Input[_builtins.int]] = None,
                  protocol: Optional[pulumi.Input[_builtins.str]] = None,
                  rate_limit: Optional[pulumi.Input['DefenseRuleConfigRateLimitArgs']] = None,
@@ -186,6 +212,7 @@ class DefenseRuleConfigArgs:
                  rule_action: Optional[pulumi.Input[_builtins.str]] = None,
                  throttle_threhold: Optional[pulumi.Input[_builtins.int]] = None,
                  throttle_type: Optional[pulumi.Input[_builtins.str]] = None,
+                 time_config: Optional[pulumi.Input['DefenseRuleConfigTimeConfigArgs']] = None,
                  ua: Optional[pulumi.Input[_builtins.str]] = None,
                  url: Optional[pulumi.Input[_builtins.str]] = None):
         """
@@ -239,6 +266,10 @@ class DefenseRuleConfigArgs:
                - 1: Indicates that the speed limit is on.
         :param pulumi.Input[_builtins.str] cn_regions: The regions in China from which you want to block requests. If you specify "CN", requests from the Chinese mainland (excluding Hong Kong, Macao, and Taiwan) are blocked. Separate multiple regions with commas (,). For more information about region codes, see Description of region codes in China.
         :param pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigConditionArgs']]] conditions: The traffic characteristics of ACL, which are described in JSON format. You can enter up to five matching conditions. For specific configuration information, see detailed configuration of conditions. See `conditions` below.
+        :param pulumi.Input['DefenseRuleConfigGrayConfigArgs'] gray_config: The canary release configuration for the rule. The value is a JSON. This parameter is required only when you set `GrayStatus` to 1. See `gray_config` below.
+        :param pulumi.Input[_builtins.int] gray_status: Specifies whether to enable canary release for the rule. Valid values:
+               - 0 (default): disables canary release.
+               - 1: enables canary release.
         :param pulumi.Input[_builtins.int] mode: The HTTP flood protection mode. Valid values:
                - 0 (default): indicates normal protection.
                - 1: indicates emergency protection.
@@ -260,6 +291,7 @@ class DefenseRuleConfigArgs:
         :param pulumi.Input[_builtins.str] throttle_type: The throttling method. Valid values:
                - qps: indicates throttling based on queries per second (QPS).
                - ratio (default): indicates throttling based on percentage.
+        :param pulumi.Input['DefenseRuleConfigTimeConfigArgs'] time_config: The scheduled rule configuration. The value is a JSON.  See `time_config` below.
         :param pulumi.Input[_builtins.str] ua: The User-Agent string that is allowed for access to the address.
         :param pulumi.Input[_builtins.str] url: The address of the cached page.
         """
@@ -281,6 +313,10 @@ class DefenseRuleConfigArgs:
             pulumi.set(__self__, "cn_regions", cn_regions)
         if conditions is not None:
             pulumi.set(__self__, "conditions", conditions)
+        if gray_config is not None:
+            pulumi.set(__self__, "gray_config", gray_config)
+        if gray_status is not None:
+            pulumi.set(__self__, "gray_status", gray_status)
         if mode is not None:
             pulumi.set(__self__, "mode", mode)
         if protocol is not None:
@@ -295,6 +331,8 @@ class DefenseRuleConfigArgs:
             pulumi.set(__self__, "throttle_threhold", throttle_threhold)
         if throttle_type is not None:
             pulumi.set(__self__, "throttle_type", throttle_type)
+        if time_config is not None:
+            pulumi.set(__self__, "time_config", time_config)
         if ua is not None:
             pulumi.set(__self__, "ua", ua)
         if url is not None:
@@ -449,6 +487,32 @@ class DefenseRuleConfigArgs:
     def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigConditionArgs']]]]):
         pulumi.set(self, "conditions", value)
 
+    @_builtins.property
+    @pulumi.getter(name="grayConfig")
+    def gray_config(self) -> Optional[pulumi.Input['DefenseRuleConfigGrayConfigArgs']]:
+        """
+        The canary release configuration for the rule. The value is a JSON. This parameter is required only when you set `GrayStatus` to 1. See `gray_config` below.
+        """
+        return pulumi.get(self, "gray_config")
+
+    @gray_config.setter
+    def gray_config(self, value: Optional[pulumi.Input['DefenseRuleConfigGrayConfigArgs']]):
+        pulumi.set(self, "gray_config", value)
+
+    @_builtins.property
+    @pulumi.getter(name="grayStatus")
+    def gray_status(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Specifies whether to enable canary release for the rule. Valid values:
+        - 0 (default): disables canary release.
+        - 1: enables canary release.
+        """
+        return pulumi.get(self, "gray_status")
+
+    @gray_status.setter
+    def gray_status(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "gray_status", value)
+
     @_builtins.property
     @pulumi.getter
     def mode(self) -> Optional[pulumi.Input[_builtins.int]]:
@@ -547,6 +611,18 @@ class DefenseRuleConfigArgs:
     def throttle_type(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "throttle_type", value)
 
+    @_builtins.property
+    @pulumi.getter(name="timeConfig")
+    def time_config(self) -> Optional[pulumi.Input['DefenseRuleConfigTimeConfigArgs']]:
+        """
+        The scheduled rule configuration. The value is a JSON.  See `time_config` below.
+        """
+        return pulumi.get(self, "time_config")
+
+    @time_config.setter
+    def time_config(self, value: Optional[pulumi.Input['DefenseRuleConfigTimeConfigArgs']]):
+        pulumi.set(self, "time_config", value)
+
     @_builtins.property
     @pulumi.getter
     def ua(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -881,6 +957,78 @@ class DefenseRuleConfigConditionArgs:
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class DefenseRuleConfigGrayConfigArgsDict(TypedDict):
+        gray_rate: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The percentage of traffic for which the canary release takes effect. The value must be in the range of 1 to 100.
+        """
+        gray_sub_key: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The sub-feature of the statistical object. This parameter is required when you set the `GrayTarget` parameter to `cookie`, `header`, or `queryarg`.
+        """
+        gray_target: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The type of the canary release object. Valid values:
+        """
+elif False:
+    DefenseRuleConfigGrayConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DefenseRuleConfigGrayConfigArgs:
+    def __init__(__self__, *,
+                 gray_rate: Optional[pulumi.Input[_builtins.int]] = None,
+                 gray_sub_key: Optional[pulumi.Input[_builtins.str]] = None,
+                 gray_target: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.int] gray_rate: The percentage of traffic for which the canary release takes effect. The value must be in the range of 1 to 100.
+        :param pulumi.Input[_builtins.str] gray_sub_key: The sub-feature of the statistical object. This parameter is required when you set the `GrayTarget` parameter to `cookie`, `header`, or `queryarg`.
+        :param pulumi.Input[_builtins.str] gray_target: The type of the canary release object. Valid values:
+        """
+        if gray_rate is not None:
+            pulumi.set(__self__, "gray_rate", gray_rate)
+        if gray_sub_key is not None:
+            pulumi.set(__self__, "gray_sub_key", gray_sub_key)
+        if gray_target is not None:
+            pulumi.set(__self__, "gray_target", gray_target)
+
+    @_builtins.property
+    @pulumi.getter(name="grayRate")
+    def gray_rate(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The percentage of traffic for which the canary release takes effect. The value must be in the range of 1 to 100.
+        """
+        return pulumi.get(self, "gray_rate")
+
+    @gray_rate.setter
+    def gray_rate(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "gray_rate", value)
+
+    @_builtins.property
+    @pulumi.getter(name="graySubKey")
+    def gray_sub_key(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The sub-feature of the statistical object. This parameter is required when you set the `GrayTarget` parameter to `cookie`, `header`, or `queryarg`.
+        """
+        return pulumi.get(self, "gray_sub_key")
+
+    @gray_sub_key.setter
+    def gray_sub_key(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "gray_sub_key", value)
+
+    @_builtins.property
+    @pulumi.getter(name="grayTarget")
+    def gray_target(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The type of the canary release object. Valid values:
+        """
+        return pulumi.get(self, "gray_target")
+
+    @gray_target.setter
+    def gray_target(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "gray_target", value)
+
+
 if not MYPY:
     class DefenseRuleConfigRateLimitArgsDict(TypedDict):
         interval: NotRequired[pulumi.Input[_builtins.int]]
@@ -1106,6 +1254,254 @@ class DefenseRuleConfigRateLimitStatusArgs:
         pulumi.set(self, "ratio", value)
 
 
+if not MYPY:
+    class DefenseRuleConfigTimeConfigArgsDict(TypedDict):
+        time_periods: NotRequired[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigTimePeriodArgsDict']]]]
+        """
+        The time period during which the rule is effective. This parameter is required when you set the `TimeScope` parameter to `period`. A maximum of five time periods can be set. See `time_periods` below.
+        """
+        time_scope: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The effective period of the rule. Valid values:
+        """
+        time_zone: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The time zone in which the rule is effective. The default value is `8`. The value must be in the range of - 12 to 12. `0` indicates UTC. `8` indicates UTC+8. **-8** indicates UTC-8.
+        """
+        week_time_periods: NotRequired[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigWeekTimePeriodArgsDict']]]]
+        """
+        The periodic time period during which the rule is effective. This parameter is required when you set the `TimeScope` parameter to `cycle`. A maximum of five time periods can be set. See `week_time_periods` below.
+        """
+elif False:
+    DefenseRuleConfigTimeConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DefenseRuleConfigTimeConfigArgs:
+    def __init__(__self__, *,
+                 time_periods: Optional[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigTimePeriodArgs']]]] = None,
+                 time_scope: Optional[pulumi.Input[_builtins.str]] = None,
+                 time_zone: Optional[pulumi.Input[_builtins.int]] = None,
+                 week_time_periods: Optional[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigWeekTimePeriodArgs']]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigTimePeriodArgs']]] time_periods: The time period during which the rule is effective. This parameter is required when you set the `TimeScope` parameter to `period`. A maximum of five time periods can be set. See `time_periods` below.
+        :param pulumi.Input[_builtins.str] time_scope: The effective period of the rule. Valid values:
+        :param pulumi.Input[_builtins.int] time_zone: The time zone in which the rule is effective. The default value is `8`. The value must be in the range of - 12 to 12. `0` indicates UTC. `8` indicates UTC+8. **-8** indicates UTC-8.
+        :param pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigWeekTimePeriodArgs']]] week_time_periods: The periodic time period during which the rule is effective. This parameter is required when you set the `TimeScope` parameter to `cycle`. A maximum of five time periods can be set. See `week_time_periods` below.
+        """
+        if time_periods is not None:
+            pulumi.set(__self__, "time_periods", time_periods)
+        if time_scope is not None:
+            pulumi.set(__self__, "time_scope", time_scope)
+        if time_zone is not None:
+            pulumi.set(__self__, "time_zone", time_zone)
+        if week_time_periods is not None:
+            pulumi.set(__self__, "week_time_periods", week_time_periods)
+
+    @_builtins.property
+    @pulumi.getter(name="timePeriods")
+    def time_periods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigTimePeriodArgs']]]]:
+        """
+        The time period during which the rule is effective. This parameter is required when you set the `TimeScope` parameter to `period`. A maximum of five time periods can be set. See `time_periods` below.
+        """
+        return pulumi.get(self, "time_periods")
+
+    @time_periods.setter
+    def time_periods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigTimePeriodArgs']]]]):
+        pulumi.set(self, "time_periods", value)
+
+    @_builtins.property
+    @pulumi.getter(name="timeScope")
+    def time_scope(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The effective period of the rule. Valid values:
+        """
+        return pulumi.get(self, "time_scope")
+
+    @time_scope.setter
+    def time_scope(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "time_scope", value)
+
+    @_builtins.property
+    @pulumi.getter(name="timeZone")
+    def time_zone(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The time zone in which the rule is effective. The default value is `8`. The value must be in the range of - 12 to 12. `0` indicates UTC. `8` indicates UTC+8. **-8** indicates UTC-8.
+        """
+        return pulumi.get(self, "time_zone")
+
+    @time_zone.setter
+    def time_zone(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "time_zone", value)
+
+    @_builtins.property
+    @pulumi.getter(name="weekTimePeriods")
+    def week_time_periods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigWeekTimePeriodArgs']]]]:
+        """
+        The periodic time period during which the rule is effective. This parameter is required when you set the `TimeScope` parameter to `cycle`. A maximum of five time periods can be set. See `week_time_periods` below.
+        """
+        return pulumi.get(self, "week_time_periods")
+
+    @week_time_periods.setter
+    def week_time_periods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigWeekTimePeriodArgs']]]]):
+        pulumi.set(self, "week_time_periods", value)
+
+
+if not MYPY:
+    class DefenseRuleConfigTimeConfigTimePeriodArgsDict(TypedDict):
+        end: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The end time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of 0-86400000).
+        """
+        start: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The start time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of [0-86400000).
+        """
+elif False:
+    DefenseRuleConfigTimeConfigTimePeriodArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DefenseRuleConfigTimeConfigTimePeriodArgs:
+    def __init__(__self__, *,
+                 end: Optional[pulumi.Input[_builtins.int]] = None,
+                 start: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] end: The end time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of 0-86400000).
+        :param pulumi.Input[_builtins.int] start: The start time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of [0-86400000).
+        """
+        if end is not None:
+            pulumi.set(__self__, "end", end)
+        if start is not None:
+            pulumi.set(__self__, "start", start)
+
+    @_builtins.property
+    @pulumi.getter
+    def end(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The end time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of 0-86400000).
+        """
+        return pulumi.get(self, "end")
+
+    @end.setter
+    def end(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "end", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def start(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The start time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of [0-86400000).
+        """
+        return pulumi.get(self, "start")
+
+    @start.setter
+    def start(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "start", value)
+
+
+if not MYPY:
+    class DefenseRuleConfigTimeConfigWeekTimePeriodArgsDict(TypedDict):
+        day: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The time period of each day when the rule is effective. It includes the start time start and end time end. You can specify multiple time periods.
+        """
+        day_periods: NotRequired[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigWeekTimePeriodDayPeriodArgsDict']]]]
+        """
+        The time period of each day when the rule is effective.  See `day_periods` below.
+        """
+elif False:
+    DefenseRuleConfigTimeConfigWeekTimePeriodArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DefenseRuleConfigTimeConfigWeekTimePeriodArgs:
+    def __init__(__self__, *,
+                 day: Optional[pulumi.Input[_builtins.str]] = None,
+                 day_periods: Optional[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigWeekTimePeriodDayPeriodArgs']]]] = None):
+        """
+        :param pulumi.Input[_builtins.str] day: The time period of each day when the rule is effective. It includes the start time start and end time end. You can specify multiple time periods.
+        :param pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigWeekTimePeriodDayPeriodArgs']]] day_periods: The time period of each day when the rule is effective.  See `day_periods` below.
+        """
+        if day is not None:
+            pulumi.set(__self__, "day", day)
+        if day_periods is not None:
+            pulumi.set(__self__, "day_periods", day_periods)
+
+    @_builtins.property
+    @pulumi.getter
+    def day(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The time period of each day when the rule is effective. It includes the start time start and end time end. You can specify multiple time periods.
+        """
+        return pulumi.get(self, "day")
+
+    @day.setter
+    def day(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "day", value)
+
+    @_builtins.property
+    @pulumi.getter(name="dayPeriods")
+    def day_periods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigWeekTimePeriodDayPeriodArgs']]]]:
+        """
+        The time period of each day when the rule is effective.  See `day_periods` below.
+        """
+        return pulumi.get(self, "day_periods")
+
+    @day_periods.setter
+    def day_periods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DefenseRuleConfigTimeConfigWeekTimePeriodDayPeriodArgs']]]]):
+        pulumi.set(self, "day_periods", value)
+
+
+if not MYPY:
+    class DefenseRuleConfigTimeConfigWeekTimePeriodDayPeriodArgsDict(TypedDict):
+        end: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The end time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of 0-86400000).
+        """
+        start: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The start time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of [0-86400000).
+        """
+elif False:
+    DefenseRuleConfigTimeConfigWeekTimePeriodDayPeriodArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DefenseRuleConfigTimeConfigWeekTimePeriodDayPeriodArgs:
+    def __init__(__self__, *,
+                 end: Optional[pulumi.Input[_builtins.int]] = None,
+                 start: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] end: The end time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of 0-86400000).
+        :param pulumi.Input[_builtins.int] start: The start time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of [0-86400000).
+        """
+        if end is not None:
+            pulumi.set(__self__, "end", end)
+        if start is not None:
+            pulumi.set(__self__, "start", start)
+
+    @_builtins.property
+    @pulumi.getter
+    def end(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The end time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of 0-86400000).
+        """
+        return pulumi.get(self, "end")
+
+    @end.setter
+    def end(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "end", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def start(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The start time of each day when the rule is effective. This is a millisecond-level timestamp relative to 00:00 of the day. The value must be in the range of [0-86400000).
+        """
+        return pulumi.get(self, "start")
+
+    @start.setter
+    def start(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "start", value)
+
+
 if not MYPY:
     class DomainListenArgsDict(TypedDict):
         cert_id: NotRequired[pulumi.Input[_builtins.str]]