pulumi-alicloud 3.86.0a1758340042__py3-none-any.whl → 3.89.0a1763702747__py3-none-any.whl

pulumi_alicloud/esa/outputs.py

@@ -18,6 +18,11 @@ from . import outputs
 __all__ = [
     'HttpRequestHeaderModificationRuleRequestHeaderModification',
     'HttpResponseHeaderModificationRuleResponseHeaderModification',
+    'LoadBalancerAdaptiveRouting',
+    'LoadBalancerMonitor',
+    'LoadBalancerRandomSteering',
+    'LoadBalancerRule',
+    'LoadBalancerRuleFixedResponse',
     'OriginPoolOrigin',
     'OriginPoolOriginAuthConf',
     'RecordAuthConf',
@@ -29,6 +34,35 @@ __all__ = [
     'SiteDeliveryTaskS3Delivery',
     'SiteDeliveryTaskSlsDelivery',
     'TransportLayerApplicationRule',
+    'WafRuleConfig',
+    'WafRuleConfigActions',
+    'WafRuleConfigActionsBypass',
+    'WafRuleConfigActionsResponse',
+    'WafRuleConfigAppPackage',
+    'WafRuleConfigAppPackagePackageSign',
+    'WafRuleConfigAppSdk',
+    'WafRuleConfigAppSdkCustomSign',
+    'WafRuleConfigManagedRuleset',
+    'WafRuleConfigManagedRulesetManagedRule',
+    'WafRuleConfigRateLimit',
+    'WafRuleConfigRateLimitCharacteristics',
+    'WafRuleConfigRateLimitCharacteristicsCriteria',
+    'WafRuleConfigRateLimitCharacteristicsCriteriaCriteria',
+    'WafRuleConfigRateLimitCharacteristicsCriteriaCriteriaCriteria',
+    'WafRuleConfigRateLimitThreshold',
+    'WafRuleConfigRateLimitThresholdResponseStatus',
+    'WafRuleConfigSecurityLevel',
+    'WafRuleConfigTimer',
+    'WafRuleConfigTimerPeriod',
+    'WafRuleConfigTimerWeeklyPeriod',
+    'WafRuleConfigTimerWeeklyPeriodDailyPeriod',
+    'WafRuleShared',
+    'WafRuleSharedActions',
+    'WafRuleSharedActionsResponse',
+    'WafRuleSharedMatch',
+    'WafRuleSharedMatchCriteria',
+    'WafRuleSharedMatchCriteriaCriteria',
+    'WafRuleSharedMatchCriteriaCriteriaCriteria',
     'WaitingRoomHostNameAndPath',
     'GetSitesSiteResult',
 ]
@@ -79,14 +113,18 @@ class HttpResponseHeaderModificationRuleResponseHeaderModification(dict):
     def __init__(__self__, *,
                  name: _builtins.str,
                  operation: _builtins.str,
+                 type: Optional[_builtins.str] = None,
                  value: Optional[_builtins.str] = None):
         """
         :param _builtins.str name: The response header name.
         :param _builtins.str operation: Operation method. Possible values:
+        :param _builtins.str type: The value type. Value range:
         :param _builtins.str value: The response header value.
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "operation", operation)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
         if value is not None:
             pulumi.set(__self__, "value", value)
 
@@ -106,6 +144,14 @@ class HttpResponseHeaderModificationRuleResponseHeaderModification(dict):
         """
         return pulumi.get(self, "operation")
 
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> Optional[_builtins.str]:
+        """
+        The value type. Value range:
+        """
+        return pulumi.get(self, "type")
+
     @_builtins.property
     @pulumi.getter
     def value(self) -> Optional[_builtins.str]:
@@ -115,6 +161,470 @@ class HttpResponseHeaderModificationRuleResponseHeaderModification(dict):
         return pulumi.get(self, "value")
 
 
+@pulumi.output_type
+class LoadBalancerAdaptiveRouting(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "failoverAcrossPools":
+            suggest = "failover_across_pools"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LoadBalancerAdaptiveRouting. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LoadBalancerAdaptiveRouting.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LoadBalancerAdaptiveRouting.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 failover_across_pools: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.bool failover_across_pools: Whether to failover across pools.
+        """
+        if failover_across_pools is not None:
+            pulumi.set(__self__, "failover_across_pools", failover_across_pools)
+
+    @_builtins.property
+    @pulumi.getter(name="failoverAcrossPools")
+    def failover_across_pools(self) -> Optional[_builtins.bool]:
+        """
+        Whether to failover across pools.
+        """
+        return pulumi.get(self, "failover_across_pools")
+
+
+@pulumi.output_type
+class LoadBalancerMonitor(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "consecutiveDown":
+            suggest = "consecutive_down"
+        elif key == "consecutiveUp":
+            suggest = "consecutive_up"
+        elif key == "expectedCodes":
+            suggest = "expected_codes"
+        elif key == "followRedirects":
+            suggest = "follow_redirects"
+        elif key == "monitoringRegion":
+            suggest = "monitoring_region"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LoadBalancerMonitor. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LoadBalancerMonitor.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LoadBalancerMonitor.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 consecutive_down: Optional[_builtins.int] = None,
+                 consecutive_up: Optional[_builtins.int] = None,
+                 expected_codes: Optional[_builtins.str] = None,
+                 follow_redirects: Optional[_builtins.bool] = None,
+                 header: Optional[_builtins.str] = None,
+                 interval: Optional[_builtins.int] = None,
+                 method: Optional[_builtins.str] = None,
+                 monitoring_region: Optional[_builtins.str] = None,
+                 path: Optional[_builtins.str] = None,
+                 port: Optional[_builtins.int] = None,
+                 timeout: Optional[_builtins.int] = None,
+                 type: Optional[_builtins.str] = None):
+        """
+        :param _builtins.int consecutive_down: The number of consecutive failed health checks before the backend is considered down, for example, 5.
+        :param _builtins.int consecutive_up: The number of consecutive successful probes required to consider the target as up, e.g., 3.
+        :param _builtins.str expected_codes: Expected status code, such as 200,202, successful HTTP response.
+        :param _builtins.bool follow_redirects: Whether to follow the redirect.
+        :param _builtins.str header: The HTTP headers to be included in the health check request.
+        :param _builtins.int interval: The monitoring interval, such as 60 seconds, checks the frequency.
+        :param _builtins.str method: Monitor request methods, such as GET, methods in the HTTP protocol.
+        :param _builtins.str monitoring_region: Probe Point Region, default to Global
+               - `Global`: Global.
+               - `ChineseMainland`: Chinese mainland.
+               - `OutsideChineseMainland`: Global (excluding the Chinese mainland).
+        :param _builtins.str path: The monitor checks the path, such as/healthcheck, the HTTP request path.
+        :param _builtins.int port: The target port.
+        :param _builtins.int timeout: The timeout for the health check, in seconds. The value range is 1-10.
+        :param _builtins.str type: The type of monitor protocol, such as HTTP, used for health checks. When the value is off, it indicates that no check is performed.
+        """
+        if consecutive_down is not None:
+            pulumi.set(__self__, "consecutive_down", consecutive_down)
+        if consecutive_up is not None:
+            pulumi.set(__self__, "consecutive_up", consecutive_up)
+        if expected_codes is not None:
+            pulumi.set(__self__, "expected_codes", expected_codes)
+        if follow_redirects is not None:
+            pulumi.set(__self__, "follow_redirects", follow_redirects)
+        if header is not None:
+            pulumi.set(__self__, "header", header)
+        if interval is not None:
+            pulumi.set(__self__, "interval", interval)
+        if method is not None:
+            pulumi.set(__self__, "method", method)
+        if monitoring_region is not None:
+            pulumi.set(__self__, "monitoring_region", monitoring_region)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if timeout is not None:
+            pulumi.set(__self__, "timeout", timeout)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @_builtins.property
+    @pulumi.getter(name="consecutiveDown")
+    def consecutive_down(self) -> Optional[_builtins.int]:
+        """
+        The number of consecutive failed health checks before the backend is considered down, for example, 5.
+        """
+        return pulumi.get(self, "consecutive_down")
+
+    @_builtins.property
+    @pulumi.getter(name="consecutiveUp")
+    def consecutive_up(self) -> Optional[_builtins.int]:
+        """
+        The number of consecutive successful probes required to consider the target as up, e.g., 3.
+        """
+        return pulumi.get(self, "consecutive_up")
+
+    @_builtins.property
+    @pulumi.getter(name="expectedCodes")
+    def expected_codes(self) -> Optional[_builtins.str]:
+        """
+        Expected status code, such as 200,202, successful HTTP response.
+        """
+        return pulumi.get(self, "expected_codes")
+
+    @_builtins.property
+    @pulumi.getter(name="followRedirects")
+    def follow_redirects(self) -> Optional[_builtins.bool]:
+        """
+        Whether to follow the redirect.
+        """
+        return pulumi.get(self, "follow_redirects")
+
+    @_builtins.property
+    @pulumi.getter
+    def header(self) -> Optional[_builtins.str]:
+        """
+        The HTTP headers to be included in the health check request.
+        """
+        return pulumi.get(self, "header")
+
+    @_builtins.property
+    @pulumi.getter
+    def interval(self) -> Optional[_builtins.int]:
+        """
+        The monitoring interval, such as 60 seconds, checks the frequency.
+        """
+        return pulumi.get(self, "interval")
+
+    @_builtins.property
+    @pulumi.getter
+    def method(self) -> Optional[_builtins.str]:
+        """
+        Monitor request methods, such as GET, methods in the HTTP protocol.
+        """
+        return pulumi.get(self, "method")
+
+    @_builtins.property
+    @pulumi.getter(name="monitoringRegion")
+    def monitoring_region(self) -> Optional[_builtins.str]:
+        """
+        Probe Point Region, default to Global
+        - `Global`: Global.
+        - `ChineseMainland`: Chinese mainland.
+        - `OutsideChineseMainland`: Global (excluding the Chinese mainland).
+        """
+        return pulumi.get(self, "monitoring_region")
+
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> Optional[_builtins.str]:
+        """
+        The monitor checks the path, such as/healthcheck, the HTTP request path.
+        """
+        return pulumi.get(self, "path")
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
+        """
+        The target port.
+        """
+        return pulumi.get(self, "port")
+
+    @_builtins.property
+    @pulumi.getter
+    def timeout(self) -> Optional[_builtins.int]:
+        """
+        The timeout for the health check, in seconds. The value range is 1-10.
+        """
+        return pulumi.get(self, "timeout")
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> Optional[_builtins.str]:
+        """
+        The type of monitor protocol, such as HTTP, used for health checks. When the value is off, it indicates that no check is performed.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class LoadBalancerRandomSteering(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "defaultWeight":
+            suggest = "default_weight"
+        elif key == "poolWeights":
+            suggest = "pool_weights"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LoadBalancerRandomSteering. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LoadBalancerRandomSteering.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LoadBalancerRandomSteering.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 default_weight: Optional[_builtins.int] = None,
+                 pool_weights: Optional[Mapping[str, _builtins.str]] = None):
+        """
+        :param _builtins.int default_weight: The default round-robin weight, used for all pools that do not have individually specified weights. The value range is 0-100.
+        :param Mapping[str, _builtins.str] pool_weights: Weight configuration for each backend server pool, where the key is the pool ID and the value is the weight coefficient. The weight coefficient represents the proportion of relative traffic distribution.
+        """
+        if default_weight is not None:
+            pulumi.set(__self__, "default_weight", default_weight)
+        if pool_weights is not None:
+            pulumi.set(__self__, "pool_weights", pool_weights)
+
+    @_builtins.property
+    @pulumi.getter(name="defaultWeight")
+    def default_weight(self) -> Optional[_builtins.int]:
+        """
+        The default round-robin weight, used for all pools that do not have individually specified weights. The value range is 0-100.
+        """
+        return pulumi.get(self, "default_weight")
+
+    @_builtins.property
+    @pulumi.getter(name="poolWeights")
+    def pool_weights(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        Weight configuration for each backend server pool, where the key is the pool ID and the value is the weight coefficient. The weight coefficient represents the proportion of relative traffic distribution.
+        """
+        return pulumi.get(self, "pool_weights")
+
+
+@pulumi.output_type
+class LoadBalancerRule(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "fixedResponse":
+            suggest = "fixed_response"
+        elif key == "ruleEnable":
+            suggest = "rule_enable"
+        elif key == "ruleName":
+            suggest = "rule_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LoadBalancerRule. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LoadBalancerRule.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LoadBalancerRule.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 fixed_response: Optional['outputs.LoadBalancerRuleFixedResponse'] = None,
+                 overrides: Optional[_builtins.str] = None,
+                 rule: Optional[_builtins.str] = None,
+                 rule_enable: Optional[_builtins.str] = None,
+                 rule_name: Optional[_builtins.str] = None,
+                 sequence: Optional[_builtins.int] = None,
+                 terminates: Optional[_builtins.bool] = None):
+        """
+        :param 'LoadBalancerRuleFixedResponseArgs' fixed_response: Executes a specified response after matching the rule. See `fixed_response` below.
+        :param _builtins.str overrides: Modifies the load balancer configuration for the corresponding request after matching the rule. The fields in this configuration will override the corresponding fields in the load balancer configuration.
+        :param _builtins.str rule: Rule content, using conditional expressions to match user requests. When adding global configuration, this parameter does not need to be set. There are two usage scenarios:
+               - Match all incoming requests: value set to true
+               - Match specified request: Set the value to a custom expression, for example: (http.host eq \\"video.example.com\\")
+        :param _builtins.str rule_enable: Rule switch. When adding global configuration, this parameter does not need to be set. Value range:
+               - on: open.
+               - off: close.
+        :param _builtins.str rule_name: Rule name. When adding global configuration, this parameter does not need to be set.
+        :param _builtins.int sequence: Order of rule execution. The smaller the value, the higher the priority for execution.
+        :param _builtins.bool terminates: Whether to terminate the execution of subsequent rules.
+        """
+        if fixed_response is not None:
+            pulumi.set(__self__, "fixed_response", fixed_response)
+        if overrides is not None:
+            pulumi.set(__self__, "overrides", overrides)
+        if rule is not None:
+            pulumi.set(__self__, "rule", rule)
+        if rule_enable is not None:
+            pulumi.set(__self__, "rule_enable", rule_enable)
+        if rule_name is not None:
+            pulumi.set(__self__, "rule_name", rule_name)
+        if sequence is not None:
+            pulumi.set(__self__, "sequence", sequence)
+        if terminates is not None:
+            pulumi.set(__self__, "terminates", terminates)
+
+    @_builtins.property
+    @pulumi.getter(name="fixedResponse")
+    def fixed_response(self) -> Optional['outputs.LoadBalancerRuleFixedResponse']:
+        """
+        Executes a specified response after matching the rule. See `fixed_response` below.
+        """
+        return pulumi.get(self, "fixed_response")
+
+    @_builtins.property
+    @pulumi.getter
+    def overrides(self) -> Optional[_builtins.str]:
+        """
+        Modifies the load balancer configuration for the corresponding request after matching the rule. The fields in this configuration will override the corresponding fields in the load balancer configuration.
+        """
+        return pulumi.get(self, "overrides")
+
+    @_builtins.property
+    @pulumi.getter
+    def rule(self) -> Optional[_builtins.str]:
+        """
+        Rule content, using conditional expressions to match user requests. When adding global configuration, this parameter does not need to be set. There are two usage scenarios:
+        - Match all incoming requests: value set to true
+        - Match specified request: Set the value to a custom expression, for example: (http.host eq \\"video.example.com\\")
+        """
+        return pulumi.get(self, "rule")
+
+    @_builtins.property
+    @pulumi.getter(name="ruleEnable")
+    def rule_enable(self) -> Optional[_builtins.str]:
+        """
+        Rule switch. When adding global configuration, this parameter does not need to be set. Value range:
+        - on: open.
+        - off: close.
+        """
+        return pulumi.get(self, "rule_enable")
+
+    @_builtins.property
+    @pulumi.getter(name="ruleName")
+    def rule_name(self) -> Optional[_builtins.str]:
+        """
+        Rule name. When adding global configuration, this parameter does not need to be set.
+        """
+        return pulumi.get(self, "rule_name")
+
+    @_builtins.property
+    @pulumi.getter
+    def sequence(self) -> Optional[_builtins.int]:
+        """
+        Order of rule execution. The smaller the value, the higher the priority for execution.
+        """
+        return pulumi.get(self, "sequence")
+
+    @_builtins.property
+    @pulumi.getter
+    def terminates(self) -> Optional[_builtins.bool]:
+        """
+        Whether to terminate the execution of subsequent rules.
+        """
+        return pulumi.get(self, "terminates")
+
+
+@pulumi.output_type
+class LoadBalancerRuleFixedResponse(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "contentType":
+            suggest = "content_type"
+        elif key == "messageBody":
+            suggest = "message_body"
+        elif key == "statusCode":
+            suggest = "status_code"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LoadBalancerRuleFixedResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LoadBalancerRuleFixedResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LoadBalancerRuleFixedResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 content_type: Optional[_builtins.str] = None,
+                 location: Optional[_builtins.str] = None,
+                 message_body: Optional[_builtins.str] = None,
+                 status_code: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str content_type: The Content-Type field in the HTTP Header.
+        :param _builtins.str location: The location field in the http return.
+        :param _builtins.str message_body: The body value of the response.
+        :param _builtins.int status_code: Status Code.
+        """
+        if content_type is not None:
+            pulumi.set(__self__, "content_type", content_type)
+        if location is not None:
+            pulumi.set(__self__, "location", location)
+        if message_body is not None:
+            pulumi.set(__self__, "message_body", message_body)
+        if status_code is not None:
+            pulumi.set(__self__, "status_code", status_code)
+
+    @_builtins.property
+    @pulumi.getter(name="contentType")
+    def content_type(self) -> Optional[_builtins.str]:
+        """
+        The Content-Type field in the HTTP Header.
+        """
+        return pulumi.get(self, "content_type")
+
+    @_builtins.property
+    @pulumi.getter
+    def location(self) -> Optional[_builtins.str]:
+        """
+        The location field in the http return.
+        """
+        return pulumi.get(self, "location")
+
+    @_builtins.property
+    @pulumi.getter(name="messageBody")
+    def message_body(self) -> Optional[_builtins.str]:
+        """
+        The body value of the response.
+        """
+        return pulumi.get(self, "message_body")
+
+    @_builtins.property
+    @pulumi.getter(name="statusCode")
+    def status_code(self) -> Optional[_builtins.int]:
+        """
+        Status Code.
+        """
+        return pulumi.get(self, "status_code")
+
+
 @pulumi.output_type
 class OriginPoolOrigin(dict):
     @staticmethod
@@ -1285,6 +1795,1576 @@ class TransportLayerApplicationRule(dict):
         return pulumi.get(self, "rule_id")
 
 
+@pulumi.output_type
+class WafRuleConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "appPackage":
+            suggest = "app_package"
+        elif key == "appSdk":
+            suggest = "app_sdk"
+        elif key == "managedGroupId":
+            suggest = "managed_group_id"
+        elif key == "managedList":
+            suggest = "managed_list"
+        elif key == "managedRulesets":
+            suggest = "managed_rulesets"
+        elif key == "rateLimit":
+            suggest = "rate_limit"
+        elif key == "securityLevel":
+            suggest = "security_level"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 action: Optional[_builtins.str] = None,
+                 actions: Optional['outputs.WafRuleConfigActions'] = None,
+                 app_package: Optional['outputs.WafRuleConfigAppPackage'] = None,
+                 app_sdk: Optional['outputs.WafRuleConfigAppSdk'] = None,
+                 expression: Optional[_builtins.str] = None,
+                 id: Optional[_builtins.int] = None,
+                 managed_group_id: Optional[_builtins.int] = None,
+                 managed_list: Optional[_builtins.str] = None,
+                 managed_rulesets: Optional[Sequence['outputs.WafRuleConfigManagedRuleset']] = None,
+                 name: Optional[_builtins.str] = None,
+                 notes: Optional[_builtins.str] = None,
+                 rate_limit: Optional['outputs.WafRuleConfigRateLimit'] = None,
+                 security_level: Optional['outputs.WafRuleConfigSecurityLevel'] = None,
+                 sigchls: Optional[Sequence[_builtins.str]] = None,
+                 status: Optional[_builtins.str] = None,
+                 timer: Optional['outputs.WafRuleConfigTimer'] = None,
+                 type: Optional[_builtins.str] = None,
+                 value: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str action: The action performed on requests that match the managed rule.
+        :param 'WafRuleConfigActionsArgs' actions: Extended action configurations, including custom responses and bypass settings. See `actions` below.
+        :param 'WafRuleConfigAppPackageArgs' app_package: Security mechanism to prevent apps from being repackaged. See `app_package` below.
+        :param 'WafRuleConfigAppSdkArgs' app_sdk: Mobile app SDK-related configurations. See `app_sdk` below.
+        :param _builtins.str expression: The match expression used to evaluate incoming requests.
+        :param _builtins.int id: The ID of the custom error page, which can be obtained by calling the ListPages operation.
+        :param _builtins.int managed_group_id: The ID of the managed rule group (deprecated).
+        :param _builtins.str managed_list: The name of the managed list applied to this rule.
+        :param Sequence['WafRuleConfigManagedRulesetArgs'] managed_rulesets: The managed rulesets referenced by this rule and their configurations. See `managed_rulesets` below.
+        :param _builtins.str name: The package name of an authorized application.
+        :param _builtins.str notes: Additional notes about this rule.
+        :param 'WafRuleConfigRateLimitArgs' rate_limit: Configuration of the rate limiting rule. See `rate_limit` below.
+        :param 'WafRuleConfigSecurityLevelArgs' security_level: The overall security protection level of WAF. See `security_level` below.
+        :param Sequence[_builtins.str] sigchls: Configuration items for token verification mechanisms.
+        :param _builtins.str status: The status of the managed rule: whether it is enabled or disabled.
+        :param 'WafRuleConfigTimerArgs' timer: Configuration for the time schedule when the rule takes effect. See `timer` below.
+        :param _builtins.str type: The type category of the WAF rule.
+        :param _builtins.str value: The value of the custom signature field used for validation.
+        """
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+        if actions is not None:
+            pulumi.set(__self__, "actions", actions)
+        if app_package is not None:
+            pulumi.set(__self__, "app_package", app_package)
+        if app_sdk is not None:
+            pulumi.set(__self__, "app_sdk", app_sdk)
+        if expression is not None:
+            pulumi.set(__self__, "expression", expression)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if managed_group_id is not None:
+            pulumi.set(__self__, "managed_group_id", managed_group_id)
+        if managed_list is not None:
+            pulumi.set(__self__, "managed_list", managed_list)
+        if managed_rulesets is not None:
+            pulumi.set(__self__, "managed_rulesets", managed_rulesets)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if notes is not None:
+            pulumi.set(__self__, "notes", notes)
+        if rate_limit is not None:
+            pulumi.set(__self__, "rate_limit", rate_limit)
+        if security_level is not None:
+            pulumi.set(__self__, "security_level", security_level)
+        if sigchls is not None:
+            pulumi.set(__self__, "sigchls", sigchls)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if timer is not None:
+            pulumi.set(__self__, "timer", timer)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def action(self) -> Optional[_builtins.str]:
+        """
+        The action performed on requests that match the managed rule.
+        """
+        return pulumi.get(self, "action")
+
+    @_builtins.property
+    @pulumi.getter
+    def actions(self) -> Optional['outputs.WafRuleConfigActions']:
+        """
+        Extended action configurations, including custom responses and bypass settings. See `actions` below.
+        """
+        return pulumi.get(self, "actions")
+
+    @_builtins.property
+    @pulumi.getter(name="appPackage")
+    def app_package(self) -> Optional['outputs.WafRuleConfigAppPackage']:
+        """
+        Security mechanism to prevent apps from being repackaged. See `app_package` below.
+        """
+        return pulumi.get(self, "app_package")
+
+    @_builtins.property
+    @pulumi.getter(name="appSdk")
+    def app_sdk(self) -> Optional['outputs.WafRuleConfigAppSdk']:
+        """
+        Mobile app SDK-related configurations. See `app_sdk` below.
+        """
+        return pulumi.get(self, "app_sdk")
+
+    @_builtins.property
+    @pulumi.getter
+    def expression(self) -> Optional[_builtins.str]:
+        """
+        The match expression used to evaluate incoming requests.
+        """
+        return pulumi.get(self, "expression")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> Optional[_builtins.int]:
+        """
+        The ID of the custom error page, which can be obtained by calling the ListPages operation.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter(name="managedGroupId")
+    def managed_group_id(self) -> Optional[_builtins.int]:
+        """
+        The ID of the managed rule group (deprecated).
+        """
+        return pulumi.get(self, "managed_group_id")
+
+    @_builtins.property
+    @pulumi.getter(name="managedList")
+    def managed_list(self) -> Optional[_builtins.str]:
+        """
+        The name of the managed list applied to this rule.
+        """
+        return pulumi.get(self, "managed_list")
+
+    @_builtins.property
+    @pulumi.getter(name="managedRulesets")
+    def managed_rulesets(self) -> Optional[Sequence['outputs.WafRuleConfigManagedRuleset']]:
+        """
+        The managed rulesets referenced by this rule and their configurations. See `managed_rulesets` below.
+        """
+        return pulumi.get(self, "managed_rulesets")
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[_builtins.str]:
+        """
+        The package name of an authorized application.
+        """
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter
+    def notes(self) -> Optional[_builtins.str]:
+        """
+        Additional notes about this rule.
+        """
+        return pulumi.get(self, "notes")
+
+    @_builtins.property
+    @pulumi.getter(name="rateLimit")
+    def rate_limit(self) -> Optional['outputs.WafRuleConfigRateLimit']:
+        """
+        Configuration of the rate limiting rule. See `rate_limit` below.
+        """
+        return pulumi.get(self, "rate_limit")
+
+    @_builtins.property
+    @pulumi.getter(name="securityLevel")
+    def security_level(self) -> Optional['outputs.WafRuleConfigSecurityLevel']:
+        """
+        The overall security protection level of WAF. See `security_level` below.
+        """
+        return pulumi.get(self, "security_level")
+
+    @_builtins.property
+    @pulumi.getter
+    def sigchls(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        Configuration items for token verification mechanisms.
+        """
+        return pulumi.get(self, "sigchls")
+
+    @_builtins.property
+    @pulumi.getter
+    def status(self) -> Optional[_builtins.str]:
+        """
+        The status of the managed rule: whether it is enabled or disabled.
+        """
+        return pulumi.get(self, "status")
+
+    @_builtins.property
+    @pulumi.getter
+    def timer(self) -> Optional['outputs.WafRuleConfigTimer']:
+        """
+        Configuration for the time schedule when the rule takes effect. See `timer` below.
+        """
+        return pulumi.get(self, "timer")
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> Optional[_builtins.str]:
+        """
+        The type category of the WAF rule.
+        """
+        return pulumi.get(self, "type")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[_builtins.str]:
+        """
+        The value of the custom signature field used for validation.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class WafRuleConfigActions(dict):
+    def __init__(__self__, *,
+                 bypass: Optional['outputs.WafRuleConfigActionsBypass'] = None,
+                 response: Optional['outputs.WafRuleConfigActionsResponse'] = None):
+        """
+        :param 'WafRuleConfigActionsBypassArgs' bypass: The skip configuration specified by the whitelist rule. See `bypass` below.
+        """
+        if bypass is not None:
+            pulumi.set(__self__, "bypass", bypass)
+        if response is not None:
+            pulumi.set(__self__, "response", response)
+
+    @_builtins.property
+    @pulumi.getter
+    def bypass(self) -> Optional['outputs.WafRuleConfigActionsBypass']:
+        """
+        The skip configuration specified by the whitelist rule. See `bypass` below.
+        """
+        return pulumi.get(self, "bypass")
+
+    @_builtins.property
+    @pulumi.getter
+    def response(self) -> Optional['outputs.WafRuleConfigActionsResponse']:
+        return pulumi.get(self, "response")
+
+
+@pulumi.output_type
+class WafRuleConfigActionsBypass(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "customRules":
+            suggest = "custom_rules"
+        elif key == "regularRules":
+            suggest = "regular_rules"
+        elif key == "regularTypes":
+            suggest = "regular_types"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfigActionsBypass. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfigActionsBypass.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfigActionsBypass.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 custom_rules: Optional[Sequence[_builtins.int]] = None,
+                 regular_rules: Optional[Sequence[_builtins.int]] = None,
+                 regular_types: Optional[Sequence[_builtins.str]] = None,
+                 skip: Optional[_builtins.str] = None,
+                 tags: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param Sequence[_builtins.int] custom_rules: The IDs of custom rules to skip.
+        :param Sequence[_builtins.int] regular_rules: The IDs of specific managed rules to skip.
+        :param Sequence[_builtins.str] regular_types: The types of managed rules to skip.
+        :param _builtins.str skip: The scope that is skipped when requests match conditions defined in the whitelist rule.
+        :param Sequence[_builtins.str] tags: The rule categories that are skipped when requests match conditions defined in the whitelist rule.
+        """
+        if custom_rules is not None:
+            pulumi.set(__self__, "custom_rules", custom_rules)
+        if regular_rules is not None:
+            pulumi.set(__self__, "regular_rules", regular_rules)
+        if regular_types is not None:
+            pulumi.set(__self__, "regular_types", regular_types)
+        if skip is not None:
+            pulumi.set(__self__, "skip", skip)
+        if tags is not None:
+            pulumi.set(__self__, "tags", tags)
+
+    @_builtins.property
+    @pulumi.getter(name="customRules")
+    def custom_rules(self) -> Optional[Sequence[_builtins.int]]:
+        """
+        The IDs of custom rules to skip.
+        """
+        return pulumi.get(self, "custom_rules")
+
+    @_builtins.property
+    @pulumi.getter(name="regularRules")
+    def regular_rules(self) -> Optional[Sequence[_builtins.int]]:
+        """
+        The IDs of specific managed rules to skip.
+        """
+        return pulumi.get(self, "regular_rules")
+
+    @_builtins.property
+    @pulumi.getter(name="regularTypes")
+    def regular_types(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        The types of managed rules to skip.
+        """
+        return pulumi.get(self, "regular_types")
+
+    @_builtins.property
+    @pulumi.getter
+    def skip(self) -> Optional[_builtins.str]:
+        """
+        The scope that is skipped when requests match conditions defined in the whitelist rule.
+        """
+        return pulumi.get(self, "skip")
+
+    @_builtins.property
+    @pulumi.getter
+    def tags(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        The rule categories that are skipped when requests match conditions defined in the whitelist rule.
+        """
+        return pulumi.get(self, "tags")
+
+
+@pulumi.output_type
+class WafRuleConfigActionsResponse(dict):
+    def __init__(__self__, *,
+                 code: Optional[_builtins.int] = None,
+                 id: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int id: The internal unique ID of the WAF rule.
+        """
+        if code is not None:
+            pulumi.set(__self__, "code", code)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def code(self) -> Optional[_builtins.int]:
+        return pulumi.get(self, "code")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> Optional[_builtins.int]:
+        """
+        The internal unique ID of the WAF rule.
+        """
+        return pulumi.get(self, "id")
+
+
+@pulumi.output_type
+class WafRuleConfigAppPackage(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "packageSigns":
+            suggest = "package_signs"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfigAppPackage. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfigAppPackage.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfigAppPackage.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 package_signs: Optional[Sequence['outputs.WafRuleConfigAppPackagePackageSign']] = None):
+        """
+        :param Sequence['WafRuleConfigAppPackagePackageSignArgs'] package_signs: Security mechanism to prevent apps from being repackaged. See `package_signs` below.
+        """
+        if package_signs is not None:
+            pulumi.set(__self__, "package_signs", package_signs)
+
+    @_builtins.property
+    @pulumi.getter(name="packageSigns")
+    def package_signs(self) -> Optional[Sequence['outputs.WafRuleConfigAppPackagePackageSign']]:
+        """
+        Security mechanism to prevent apps from being repackaged. See `package_signs` below.
+        """
+        return pulumi.get(self, "package_signs")
+
+
+@pulumi.output_type
+class WafRuleConfigAppPackagePackageSign(dict):
+    def __init__(__self__, *,
+                 name: Optional[_builtins.str] = None,
+                 sign: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str sign: The digital signature of a legitimate app package.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if sign is not None:
+            pulumi.set(__self__, "sign", sign)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter
+    def sign(self) -> Optional[_builtins.str]:
+        """
+        The digital signature of a legitimate app package.
+        """
+        return pulumi.get(self, "sign")
+
+
+@pulumi.output_type
+class WafRuleConfigAppSdk(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "customSign":
+            suggest = "custom_sign"
+        elif key == "customSignStatus":
+            suggest = "custom_sign_status"
+        elif key == "featureAbnormals":
+            suggest = "feature_abnormals"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfigAppSdk. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfigAppSdk.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfigAppSdk.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 custom_sign: Optional['outputs.WafRuleConfigAppSdkCustomSign'] = None,
+                 custom_sign_status: Optional[_builtins.str] = None,
+                 feature_abnormals: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param 'WafRuleConfigAppSdkCustomSignArgs' custom_sign: Custom fields used for mobile app signature validation. See `custom_sign` below.
+        :param _builtins.str custom_sign_status: Indicates whether the custom signature field validation is enabled.
+        :param Sequence[_builtins.str] feature_abnormals: Detected abnormal behaviors of the application.
+        """
+        if custom_sign is not None:
+            pulumi.set(__self__, "custom_sign", custom_sign)
+        if custom_sign_status is not None:
+            pulumi.set(__self__, "custom_sign_status", custom_sign_status)
+        if feature_abnormals is not None:
+            pulumi.set(__self__, "feature_abnormals", feature_abnormals)
+
+    @_builtins.property
+    @pulumi.getter(name="customSign")
+    def custom_sign(self) -> Optional['outputs.WafRuleConfigAppSdkCustomSign']:
+        """
+        Custom fields used for mobile app signature validation. See `custom_sign` below.
+        """
+        return pulumi.get(self, "custom_sign")
+
+    @_builtins.property
+    @pulumi.getter(name="customSignStatus")
+    def custom_sign_status(self) -> Optional[_builtins.str]:
+        """
+        Indicates whether the custom signature field validation is enabled.
+        """
+        return pulumi.get(self, "custom_sign_status")
+
+    @_builtins.property
+    @pulumi.getter(name="featureAbnormals")
+    def feature_abnormals(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        Detected abnormal behaviors of the application.
+        """
+        return pulumi.get(self, "feature_abnormals")
+
+
+@pulumi.output_type
+class WafRuleConfigAppSdkCustomSign(dict):
+    def __init__(__self__, *,
+                 key: Optional[_builtins.str] = None,
+                 value: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str key: The name of the custom signature field used for validation.
+        :param _builtins.str value: The value of the custom signature field used for validation.
+        """
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def key(self) -> Optional[_builtins.str]:
+        """
+        The name of the custom signature field used for validation.
+        """
+        return pulumi.get(self, "key")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[_builtins.str]:
+        """
+        The value of the custom signature field used for validation.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class WafRuleConfigManagedRuleset(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "attackType":
+            suggest = "attack_type"
+        elif key == "managedRules":
+            suggest = "managed_rules"
+        elif key == "numberEnabled":
+            suggest = "number_enabled"
+        elif key == "numberTotal":
+            suggest = "number_total"
+        elif key == "protectionLevel":
+            suggest = "protection_level"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfigManagedRuleset. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfigManagedRuleset.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfigManagedRuleset.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 action: Optional[_builtins.str] = None,
+                 attack_type: Optional[_builtins.int] = None,
+                 managed_rules: Optional[Sequence['outputs.WafRuleConfigManagedRulesetManagedRule']] = None,
+                 number_enabled: Optional[_builtins.int] = None,
+                 number_total: Optional[_builtins.int] = None,
+                 protection_level: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int attack_type: The primary attack type targeted by this ruleset.
+        :param Sequence['WafRuleConfigManagedRulesetManagedRuleArgs'] managed_rules: The individual managed rules included in this ruleset. See `managed_rules` below.
+        :param _builtins.int number_enabled: Number of rules currently enabled.
+        :param _builtins.int number_total: Total number of rules in this ruleset.
+        :param _builtins.int protection_level: The protection strength level assigned to this ruleset.
+        """
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+        if attack_type is not None:
+            pulumi.set(__self__, "attack_type", attack_type)
+        if managed_rules is not None:
+            pulumi.set(__self__, "managed_rules", managed_rules)
+        if number_enabled is not None:
+            pulumi.set(__self__, "number_enabled", number_enabled)
+        if number_total is not None:
+            pulumi.set(__self__, "number_total", number_total)
+        if protection_level is not None:
+            pulumi.set(__self__, "protection_level", protection_level)
+
+    @_builtins.property
+    @pulumi.getter
+    def action(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "action")
+
+    @_builtins.property
+    @pulumi.getter(name="attackType")
+    def attack_type(self) -> Optional[_builtins.int]:
+        """
+        The primary attack type targeted by this ruleset.
+        """
+        return pulumi.get(self, "attack_type")
+
+    @_builtins.property
+    @pulumi.getter(name="managedRules")
+    def managed_rules(self) -> Optional[Sequence['outputs.WafRuleConfigManagedRulesetManagedRule']]:
+        """
+        The individual managed rules included in this ruleset. See `managed_rules` below.
+        """
+        return pulumi.get(self, "managed_rules")
+
+    @_builtins.property
+    @pulumi.getter(name="numberEnabled")
+    def number_enabled(self) -> Optional[_builtins.int]:
+        """
+        Number of rules currently enabled.
+        """
+        return pulumi.get(self, "number_enabled")
+
+    @_builtins.property
+    @pulumi.getter(name="numberTotal")
+    def number_total(self) -> Optional[_builtins.int]:
+        """
+        Total number of rules in this ruleset.
+        """
+        return pulumi.get(self, "number_total")
+
+    @_builtins.property
+    @pulumi.getter(name="protectionLevel")
+    def protection_level(self) -> Optional[_builtins.int]:
+        """
+        The protection strength level assigned to this ruleset.
+        """
+        return pulumi.get(self, "protection_level")
+
+
+@pulumi.output_type
+class WafRuleConfigManagedRulesetManagedRule(dict):
+    def __init__(__self__, *,
+                 action: Optional[_builtins.str] = None,
+                 id: Optional[_builtins.int] = None,
+                 status: Optional[_builtins.str] = None):
+        """
+        :param _builtins.int id: The internal unique ID of the WAF rule.
+        :param _builtins.str status: The status of the managed rule: whether it is enabled or disabled.
+        """
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @_builtins.property
+    @pulumi.getter
+    def action(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "action")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> Optional[_builtins.int]:
+        """
+        The internal unique ID of the WAF rule.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter
+    def status(self) -> Optional[_builtins.str]:
+        """
+        The status of the managed rule: whether it is enabled or disabled.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class WafRuleConfigRateLimit(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "onHit":
+            suggest = "on_hit"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfigRateLimit. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfigRateLimit.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfigRateLimit.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 characteristics: Optional['outputs.WafRuleConfigRateLimitCharacteristics'] = None,
+                 interval: Optional[_builtins.int] = None,
+                 on_hit: Optional[_builtins.bool] = None,
+                 threshold: Optional['outputs.WafRuleConfigRateLimitThreshold'] = None,
+                 ttl: Optional[_builtins.int] = None):
+        """
+        :param 'WafRuleConfigRateLimitCharacteristicsArgs' characteristics: The statistical dimensions to which the rate limiting rule applies. See `characteristics` below.
+        :param _builtins.int interval: The statistical interval.
+        :param _builtins.bool on_hit: Indicates whether the rule applies to requests that hit the cache.
+        :param 'WafRuleConfigRateLimitThresholdArgs' threshold: Threshold settings for the rate limiting rule. See `threshold` below.
+        :param _builtins.int ttl: The timeout period for creating the stack used in rate limiting.
+        """
+        if characteristics is not None:
+            pulumi.set(__self__, "characteristics", characteristics)
+        if interval is not None:
+            pulumi.set(__self__, "interval", interval)
+        if on_hit is not None:
+            pulumi.set(__self__, "on_hit", on_hit)
+        if threshold is not None:
+            pulumi.set(__self__, "threshold", threshold)
+        if ttl is not None:
+            pulumi.set(__self__, "ttl", ttl)
+
+    @_builtins.property
+    @pulumi.getter
+    def characteristics(self) -> Optional['outputs.WafRuleConfigRateLimitCharacteristics']:
+        """
+        The statistical dimensions to which the rate limiting rule applies. See `characteristics` below.
+        """
+        return pulumi.get(self, "characteristics")
+
+    @_builtins.property
+    @pulumi.getter
+    def interval(self) -> Optional[_builtins.int]:
+        """
+        The statistical interval.
+        """
+        return pulumi.get(self, "interval")
+
+    @_builtins.property
+    @pulumi.getter(name="onHit")
+    def on_hit(self) -> Optional[_builtins.bool]:
+        """
+        Indicates whether the rule applies to requests that hit the cache.
+        """
+        return pulumi.get(self, "on_hit")
+
+    @_builtins.property
+    @pulumi.getter
+    def threshold(self) -> Optional['outputs.WafRuleConfigRateLimitThreshold']:
+        """
+        Threshold settings for the rate limiting rule. See `threshold` below.
+        """
+        return pulumi.get(self, "threshold")
+
+    @_builtins.property
+    @pulumi.getter
+    def ttl(self) -> Optional[_builtins.int]:
+        """
+        The timeout period for creating the stack used in rate limiting.
+        """
+        return pulumi.get(self, "ttl")
+
+
+@pulumi.output_type
+class WafRuleConfigRateLimitCharacteristics(dict):
+    def __init__(__self__, *,
+                 criterias: Optional[Sequence['outputs.WafRuleConfigRateLimitCharacteristicsCriteria']] = None,
+                 logic: Optional[_builtins.str] = None):
+        if criterias is not None:
+            pulumi.set(__self__, "criterias", criterias)
+        if logic is not None:
+            pulumi.set(__self__, "logic", logic)
+
+    @_builtins.property
+    @pulumi.getter
+    def criterias(self) -> Optional[Sequence['outputs.WafRuleConfigRateLimitCharacteristicsCriteria']]:
+        return pulumi.get(self, "criterias")
+
+    @_builtins.property
+    @pulumi.getter
+    def logic(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "logic")
+
+
+@pulumi.output_type
+class WafRuleConfigRateLimitCharacteristicsCriteria(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "matchType":
+            suggest = "match_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfigRateLimitCharacteristicsCriteria. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfigRateLimitCharacteristicsCriteria.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfigRateLimitCharacteristicsCriteria.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 criterias: Optional[Sequence['outputs.WafRuleConfigRateLimitCharacteristicsCriteriaCriteria']] = None,
+                 logic: Optional[_builtins.str] = None,
+                 match_type: Optional[_builtins.str] = None):
+        if criterias is not None:
+            pulumi.set(__self__, "criterias", criterias)
+        if logic is not None:
+            pulumi.set(__self__, "logic", logic)
+        if match_type is not None:
+            pulumi.set(__self__, "match_type", match_type)
+
+    @_builtins.property
+    @pulumi.getter
+    def criterias(self) -> Optional[Sequence['outputs.WafRuleConfigRateLimitCharacteristicsCriteriaCriteria']]:
+        return pulumi.get(self, "criterias")
+
+    @_builtins.property
+    @pulumi.getter
+    def logic(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "logic")
+
+    @_builtins.property
+    @pulumi.getter(name="matchType")
+    def match_type(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "match_type")
+
+
+@pulumi.output_type
+class WafRuleConfigRateLimitCharacteristicsCriteriaCriteria(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "matchType":
+            suggest = "match_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfigRateLimitCharacteristicsCriteriaCriteria. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfigRateLimitCharacteristicsCriteriaCriteria.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfigRateLimitCharacteristicsCriteriaCriteria.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 criterias: Optional[Sequence['outputs.WafRuleConfigRateLimitCharacteristicsCriteriaCriteriaCriteria']] = None,
+                 logic: Optional[_builtins.str] = None,
+                 match_type: Optional[_builtins.str] = None):
+        if criterias is not None:
+            pulumi.set(__self__, "criterias", criterias)
+        if logic is not None:
+            pulumi.set(__self__, "logic", logic)
+        if match_type is not None:
+            pulumi.set(__self__, "match_type", match_type)
+
+    @_builtins.property
+    @pulumi.getter
+    def criterias(self) -> Optional[Sequence['outputs.WafRuleConfigRateLimitCharacteristicsCriteriaCriteriaCriteria']]:
+        return pulumi.get(self, "criterias")
+
+    @_builtins.property
+    @pulumi.getter
+    def logic(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "logic")
+
+    @_builtins.property
+    @pulumi.getter(name="matchType")
+    def match_type(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "match_type")
+
+
+@pulumi.output_type
+class WafRuleConfigRateLimitCharacteristicsCriteriaCriteriaCriteria(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "matchType":
+            suggest = "match_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfigRateLimitCharacteristicsCriteriaCriteriaCriteria. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfigRateLimitCharacteristicsCriteriaCriteriaCriteria.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfigRateLimitCharacteristicsCriteriaCriteriaCriteria.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 match_type: Optional[_builtins.str] = None):
+        if match_type is not None:
+            pulumi.set(__self__, "match_type", match_type)
+
+    @_builtins.property
+    @pulumi.getter(name="matchType")
+    def match_type(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "match_type")
+
+
+@pulumi.output_type
+class WafRuleConfigRateLimitThreshold(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "distinctManagedRules":
+            suggest = "distinct_managed_rules"
+        elif key == "managedRulesBlocked":
+            suggest = "managed_rules_blocked"
+        elif key == "responseStatus":
+            suggest = "response_status"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfigRateLimitThreshold. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfigRateLimitThreshold.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfigRateLimitThreshold.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 distinct_managed_rules: Optional[_builtins.int] = None,
+                 managed_rules_blocked: Optional[_builtins.int] = None,
+                 request: Optional[_builtins.int] = None,
+                 response_status: Optional['outputs.WafRuleConfigRateLimitThresholdResponseStatus'] = None,
+                 traffic: Optional[_builtins.str] = None):
+        """
+        :param _builtins.int distinct_managed_rules: The maximum number of distinct managed rules that can be triggered.
+        :param _builtins.int managed_rules_blocked: The maximum number of times that managed rules can be triggered.
+        :param _builtins.int request: The maximum number of allowed requests within a time interval.
+        :param 'WafRuleConfigRateLimitThresholdResponseStatusArgs' response_status: Limits on the frequency of returning specific HTTP status codes. See `response_status` below.
+        :param _builtins.str traffic: The maximum allowed traffic within a time interval (deprecated).
+        """
+        if distinct_managed_rules is not None:
+            pulumi.set(__self__, "distinct_managed_rules", distinct_managed_rules)
+        if managed_rules_blocked is not None:
+            pulumi.set(__self__, "managed_rules_blocked", managed_rules_blocked)
+        if request is not None:
+            pulumi.set(__self__, "request", request)
+        if response_status is not None:
+            pulumi.set(__self__, "response_status", response_status)
+        if traffic is not None:
+            pulumi.set(__self__, "traffic", traffic)
+
+    @_builtins.property
+    @pulumi.getter(name="distinctManagedRules")
+    def distinct_managed_rules(self) -> Optional[_builtins.int]:
+        """
+        The maximum number of distinct managed rules that can be triggered.
+        """
+        return pulumi.get(self, "distinct_managed_rules")
+
+    @_builtins.property
+    @pulumi.getter(name="managedRulesBlocked")
+    def managed_rules_blocked(self) -> Optional[_builtins.int]:
+        """
+        The maximum number of times that managed rules can be triggered.
+        """
+        return pulumi.get(self, "managed_rules_blocked")
+
+    @_builtins.property
+    @pulumi.getter
+    def request(self) -> Optional[_builtins.int]:
+        """
+        The maximum number of allowed requests within a time interval.
+        """
+        return pulumi.get(self, "request")
+
+    @_builtins.property
+    @pulumi.getter(name="responseStatus")
+    def response_status(self) -> Optional['outputs.WafRuleConfigRateLimitThresholdResponseStatus']:
+        """
+        Limits on the frequency of returning specific HTTP status codes. See `response_status` below.
+        """
+        return pulumi.get(self, "response_status")
+
+    @_builtins.property
+    @pulumi.getter
+    def traffic(self) -> Optional[_builtins.str]:
+        """
+        The maximum allowed traffic within a time interval (deprecated).
+        """
+        return pulumi.get(self, "traffic")
+
+
+@pulumi.output_type
+class WafRuleConfigRateLimitThresholdResponseStatus(dict):
+    def __init__(__self__, *,
+                 code: Optional[_builtins.int] = None,
+                 count: Optional[_builtins.int] = None,
+                 ratio: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int count: The maximum number of times the specified status code can be returned.
+        :param _builtins.int ratio: The upper limit of the percentage of occurrences of the specified status code among all responses.
+        """
+        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)
+
+    @_builtins.property
+    @pulumi.getter
+    def code(self) -> Optional[_builtins.int]:
+        return pulumi.get(self, "code")
+
+    @_builtins.property
+    @pulumi.getter
+    def count(self) -> Optional[_builtins.int]:
+        """
+        The maximum number of times the specified status code can be returned.
+        """
+        return pulumi.get(self, "count")
+
+    @_builtins.property
+    @pulumi.getter
+    def ratio(self) -> Optional[_builtins.int]:
+        """
+        The upper limit of the percentage of occurrences of the specified status code among all responses.
+        """
+        return pulumi.get(self, "ratio")
+
+
+@pulumi.output_type
+class WafRuleConfigSecurityLevel(dict):
+    def __init__(__self__, *,
+                 value: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str value: The value of the custom signature field used for validation.
+        """
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[_builtins.str]:
+        """
+        The value of the custom signature field used for validation.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class WafRuleConfigTimer(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "weeklyPeriods":
+            suggest = "weekly_periods"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfigTimer. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfigTimer.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfigTimer.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 periods: Optional[Sequence['outputs.WafRuleConfigTimerPeriod']] = None,
+                 scopes: Optional[_builtins.str] = None,
+                 weekly_periods: Optional[Sequence['outputs.WafRuleConfigTimerWeeklyPeriod']] = None,
+                 zone: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str scopes: Timing type:
+        :param Sequence['WafRuleConfigTimerWeeklyPeriodArgs'] weekly_periods: Weekly recurring time schedules. See `weekly_periods` below.
+        :param _builtins.int zone: The time zone. If it is not specified, the default value is UTC +00:00.  Example: 8 means East Zone 8,-8 means West Zone 8  Range:-12 -+14
+        """
+        if periods is not None:
+            pulumi.set(__self__, "periods", periods)
+        if scopes is not None:
+            pulumi.set(__self__, "scopes", scopes)
+        if weekly_periods is not None:
+            pulumi.set(__self__, "weekly_periods", weekly_periods)
+        if zone is not None:
+            pulumi.set(__self__, "zone", zone)
+
+    @_builtins.property
+    @pulumi.getter
+    def periods(self) -> Optional[Sequence['outputs.WafRuleConfigTimerPeriod']]:
+        return pulumi.get(self, "periods")
+
+    @_builtins.property
+    @pulumi.getter
+    def scopes(self) -> Optional[_builtins.str]:
+        """
+        Timing type:
+        """
+        return pulumi.get(self, "scopes")
+
+    @_builtins.property
+    @pulumi.getter(name="weeklyPeriods")
+    def weekly_periods(self) -> Optional[Sequence['outputs.WafRuleConfigTimerWeeklyPeriod']]:
+        """
+        Weekly recurring time schedules. See `weekly_periods` below.
+        """
+        return pulumi.get(self, "weekly_periods")
+
+    @_builtins.property
+    @pulumi.getter
+    def zone(self) -> Optional[_builtins.int]:
+        """
+        The time zone. If it is not specified, the default value is UTC +00:00.  Example: 8 means East Zone 8,-8 means West Zone 8  Range:-12 -+14
+        """
+        return pulumi.get(self, "zone")
+
+
+@pulumi.output_type
+class WafRuleConfigTimerPeriod(dict):
+    def __init__(__self__, *,
+                 end: Optional[_builtins.str] = None,
+                 start: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str end: End time in HH:mm:ss format
+        :param _builtins.str start: Start time in HH:mm:ss format
+        """
+        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[_builtins.str]:
+        """
+        End time in HH:mm:ss format
+        """
+        return pulumi.get(self, "end")
+
+    @_builtins.property
+    @pulumi.getter
+    def start(self) -> Optional[_builtins.str]:
+        """
+        Start time in HH:mm:ss format
+        """
+        return pulumi.get(self, "start")
+
+
+@pulumi.output_type
+class WafRuleConfigTimerWeeklyPeriod(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dailyPeriods":
+            suggest = "daily_periods"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleConfigTimerWeeklyPeriod. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleConfigTimerWeeklyPeriod.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleConfigTimerWeeklyPeriod.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 daily_periods: Optional[Sequence['outputs.WafRuleConfigTimerWeeklyPeriodDailyPeriod']] = None,
+                 days: Optional[_builtins.str] = None):
+        """
+        :param Sequence['WafRuleConfigTimerWeeklyPeriodDailyPeriodArgs'] daily_periods: Daily effective time periods within a weekly schedule. See `daily_periods` below.
+        :param _builtins.str days: Cycle, multiple use comma separated, 1-7 respectively represent Monday-Sunday.  Example: Monday, Wednesday value is "1,3"
+        """
+        if daily_periods is not None:
+            pulumi.set(__self__, "daily_periods", daily_periods)
+        if days is not None:
+            pulumi.set(__self__, "days", days)
+
+    @_builtins.property
+    @pulumi.getter(name="dailyPeriods")
+    def daily_periods(self) -> Optional[Sequence['outputs.WafRuleConfigTimerWeeklyPeriodDailyPeriod']]:
+        """
+        Daily effective time periods within a weekly schedule. See `daily_periods` below.
+        """
+        return pulumi.get(self, "daily_periods")
+
+    @_builtins.property
+    @pulumi.getter
+    def days(self) -> Optional[_builtins.str]:
+        """
+        Cycle, multiple use comma separated, 1-7 respectively represent Monday-Sunday.  Example: Monday, Wednesday value is "1,3"
+        """
+        return pulumi.get(self, "days")
+
+
+@pulumi.output_type
+class WafRuleConfigTimerWeeklyPeriodDailyPeriod(dict):
+    def __init__(__self__, *,
+                 end: Optional[_builtins.str] = None,
+                 start: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str end: End time in HH:mm:ss format
+        :param _builtins.str start: Start time in HH:mm:ss format
+        """
+        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[_builtins.str]:
+        """
+        End time in HH:mm:ss format
+        """
+        return pulumi.get(self, "end")
+
+    @_builtins.property
+    @pulumi.getter
+    def start(self) -> Optional[_builtins.str]:
+        """
+        Start time in HH:mm:ss format
+        """
+        return pulumi.get(self, "start")
+
+
+@pulumi.output_type
+class WafRuleShared(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "crossSiteId":
+            suggest = "cross_site_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleShared. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleShared.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleShared.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 action: Optional[_builtins.str] = None,
+                 actions: Optional['outputs.WafRuleSharedActions'] = None,
+                 cross_site_id: Optional[_builtins.int] = None,
+                 expression: Optional[_builtins.str] = None,
+                 match: Optional['outputs.WafRuleSharedMatch'] = None,
+                 mode: Optional[_builtins.str] = None,
+                 name: Optional[_builtins.str] = None,
+                 target: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str action: The default action executed under shared configuration.
+        :param 'WafRuleSharedActionsArgs' actions: Extended action configurations under shared settings. See `actions` below.
+        :param _builtins.int cross_site_id: Specify the cross-domain site ID.
+        :param _builtins.str expression: The match expression used in shared configuration.
+        :param 'WafRuleSharedMatchArgs' match: Configuration of the request matching logic engine. See `match` below.
+        :param _builtins.str mode: The integration mode of the Web SDK:
+        :param _builtins.str name: The display name of the ruleset.
+        :param _builtins.str target: The target type protected by this rule: web or app.
+        """
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+        if actions is not None:
+            pulumi.set(__self__, "actions", actions)
+        if cross_site_id is not None:
+            pulumi.set(__self__, "cross_site_id", cross_site_id)
+        if expression is not None:
+            pulumi.set(__self__, "expression", expression)
+        if match is not None:
+            pulumi.set(__self__, "match", match)
+        if mode is not None:
+            pulumi.set(__self__, "mode", mode)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if target is not None:
+            pulumi.set(__self__, "target", target)
+
+    @_builtins.property
+    @pulumi.getter
+    def action(self) -> Optional[_builtins.str]:
+        """
+        The default action executed under shared configuration.
+        """
+        return pulumi.get(self, "action")
+
+    @_builtins.property
+    @pulumi.getter
+    def actions(self) -> Optional['outputs.WafRuleSharedActions']:
+        """
+        Extended action configurations under shared settings. See `actions` below.
+        """
+        return pulumi.get(self, "actions")
+
+    @_builtins.property
+    @pulumi.getter(name="crossSiteId")
+    def cross_site_id(self) -> Optional[_builtins.int]:
+        """
+        Specify the cross-domain site ID.
+        """
+        return pulumi.get(self, "cross_site_id")
+
+    @_builtins.property
+    @pulumi.getter
+    def expression(self) -> Optional[_builtins.str]:
+        """
+        The match expression used in shared configuration.
+        """
+        return pulumi.get(self, "expression")
+
+    @_builtins.property
+    @pulumi.getter
+    def match(self) -> Optional['outputs.WafRuleSharedMatch']:
+        """
+        Configuration of the request matching logic engine. See `match` below.
+        """
+        return pulumi.get(self, "match")
+
+    @_builtins.property
+    @pulumi.getter
+    def mode(self) -> Optional[_builtins.str]:
+        """
+        The integration mode of the Web SDK:
+        """
+        return pulumi.get(self, "mode")
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[_builtins.str]:
+        """
+        The display name of the ruleset.
+        """
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter
+    def target(self) -> Optional[_builtins.str]:
+        """
+        The target type protected by this rule: web or app.
+        """
+        return pulumi.get(self, "target")
+
+
+@pulumi.output_type
+class WafRuleSharedActions(dict):
+    def __init__(__self__, *,
+                 response: Optional['outputs.WafRuleSharedActionsResponse'] = None):
+        if response is not None:
+            pulumi.set(__self__, "response", response)
+
+    @_builtins.property
+    @pulumi.getter
+    def response(self) -> Optional['outputs.WafRuleSharedActionsResponse']:
+        return pulumi.get(self, "response")
+
+
+@pulumi.output_type
+class WafRuleSharedActionsResponse(dict):
+    def __init__(__self__, *,
+                 code: Optional[_builtins.int] = None,
+                 id: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int id: The internal unique ID of the WAF rule.
+        """
+        if code is not None:
+            pulumi.set(__self__, "code", code)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def code(self) -> Optional[_builtins.int]:
+        return pulumi.get(self, "code")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> Optional[_builtins.int]:
+        """
+        The internal unique ID of the WAF rule.
+        """
+        return pulumi.get(self, "id")
+
+
+@pulumi.output_type
+class WafRuleSharedMatch(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "matchType":
+            suggest = "match_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleSharedMatch. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleSharedMatch.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleSharedMatch.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 criterias: Optional[Sequence['outputs.WafRuleSharedMatchCriteria']] = None,
+                 logic: Optional[_builtins.str] = None,
+                 match_type: Optional[_builtins.str] = None):
+        if criterias is not None:
+            pulumi.set(__self__, "criterias", criterias)
+        if logic is not None:
+            pulumi.set(__self__, "logic", logic)
+        if match_type is not None:
+            pulumi.set(__self__, "match_type", match_type)
+
+    @_builtins.property
+    @pulumi.getter
+    def criterias(self) -> Optional[Sequence['outputs.WafRuleSharedMatchCriteria']]:
+        return pulumi.get(self, "criterias")
+
+    @_builtins.property
+    @pulumi.getter
+    def logic(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "logic")
+
+    @_builtins.property
+    @pulumi.getter(name="matchType")
+    def match_type(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "match_type")
+
+
+@pulumi.output_type
+class WafRuleSharedMatchCriteria(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "matchType":
+            suggest = "match_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleSharedMatchCriteria. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleSharedMatchCriteria.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleSharedMatchCriteria.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 criterias: Optional[Sequence['outputs.WafRuleSharedMatchCriteriaCriteria']] = None,
+                 logic: Optional[_builtins.str] = None,
+                 match_type: Optional[_builtins.str] = None):
+        if criterias is not None:
+            pulumi.set(__self__, "criterias", criterias)
+        if logic is not None:
+            pulumi.set(__self__, "logic", logic)
+        if match_type is not None:
+            pulumi.set(__self__, "match_type", match_type)
+
+    @_builtins.property
+    @pulumi.getter
+    def criterias(self) -> Optional[Sequence['outputs.WafRuleSharedMatchCriteriaCriteria']]:
+        return pulumi.get(self, "criterias")
+
+    @_builtins.property
+    @pulumi.getter
+    def logic(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "logic")
+
+    @_builtins.property
+    @pulumi.getter(name="matchType")
+    def match_type(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "match_type")
+
+
+@pulumi.output_type
+class WafRuleSharedMatchCriteriaCriteria(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "matchType":
+            suggest = "match_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleSharedMatchCriteriaCriteria. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleSharedMatchCriteriaCriteria.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleSharedMatchCriteriaCriteria.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 criterias: Optional[Sequence['outputs.WafRuleSharedMatchCriteriaCriteriaCriteria']] = None,
+                 logic: Optional[_builtins.str] = None,
+                 match_type: Optional[_builtins.str] = None):
+        if criterias is not None:
+            pulumi.set(__self__, "criterias", criterias)
+        if logic is not None:
+            pulumi.set(__self__, "logic", logic)
+        if match_type is not None:
+            pulumi.set(__self__, "match_type", match_type)
+
+    @_builtins.property
+    @pulumi.getter
+    def criterias(self) -> Optional[Sequence['outputs.WafRuleSharedMatchCriteriaCriteriaCriteria']]:
+        return pulumi.get(self, "criterias")
+
+    @_builtins.property
+    @pulumi.getter
+    def logic(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "logic")
+
+    @_builtins.property
+    @pulumi.getter(name="matchType")
+    def match_type(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "match_type")
+
+
+@pulumi.output_type
+class WafRuleSharedMatchCriteriaCriteriaCriteria(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "matchType":
+            suggest = "match_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WafRuleSharedMatchCriteriaCriteriaCriteria. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WafRuleSharedMatchCriteriaCriteriaCriteria.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WafRuleSharedMatchCriteriaCriteriaCriteria.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 match_type: Optional[_builtins.str] = None):
+        if match_type is not None:
+            pulumi.set(__self__, "match_type", match_type)
+
+    @_builtins.property
+    @pulumi.getter(name="matchType")
+    def match_type(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "match_type")
+
+
 @pulumi.output_type
 class WaitingRoomHostNameAndPath(dict):
     def __init__(__self__, *,