tencentcloud-sdk-python 3.0.1443__py2.py3-none-any.whl → 3.0.1444__py2.py3-none-any.whl

tencentcloud/waf/v20180125/models.py

@@ -11100,6 +11100,85 @@ class DeleteIpAccessControlV2Response(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class DeleteOwaspRuleStatusRequest(AbstractModel):
+    """DeleteOwaspRuleStatus请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Domain: 域名
+        :type Domain: str
+        :param _RuleIDs: 规则ID列表
+        :type RuleIDs: list of str
+        """
+        self._Domain = None
+        self._RuleIDs = None
+
+    @property
+    def Domain(self):
+        """域名
+        :rtype: str
+        """
+        return self._Domain
+
+    @Domain.setter
+    def Domain(self, Domain):
+        self._Domain = Domain
+
+    @property
+    def RuleIDs(self):
+        """规则ID列表
+        :rtype: list of str
+        """
+        return self._RuleIDs
+
+    @RuleIDs.setter
+    def RuleIDs(self, RuleIDs):
+        self._RuleIDs = RuleIDs
+
+
+    def _deserialize(self, params):
+        self._Domain = params.get("Domain")
+        self._RuleIDs = params.get("RuleIDs")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class DeleteOwaspRuleStatusResponse(AbstractModel):
+    """DeleteOwaspRuleStatus返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._RequestId = None
+
+    @property
+    def RequestId(self):
+        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._RequestId = params.get("RequestId")
+
+
 class DeleteOwaspWhiteRuleRequest(AbstractModel):
     """DeleteOwaspWhiteRule请求参数结构体
 
@@ -19250,36 +19329,30 @@ class DescribeObjectsResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
-class DescribeOwaspWhiteRulesRequest(AbstractModel):
-    """DescribeOwaspWhiteRules请求参数结构体
+class DescribeOwaspRuleTypesRequest(AbstractModel):
+    """DescribeOwaspRuleTypes请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _Domain: 需要查询的域名
+        :param _Domain: 查询域名
         :type Domain: str
-        :param _Offset: 分页分页，默认为0
+        :param _Offset: 分页页数，默认为0
         :type Offset: int
         :param _Limit: 每页容量，默认为10
         :type Limit: int
-        :param _By: 排序的字段，支持CreateTime：新建时间、UpdateTime：修改时间
-        :type By: str
-        :param _Order: 排序方式，支持asc、desc
-        :type Order: str
-        :param _Filters: 筛选条件，支持RuleId：加白规则ID、 Name：规则名称、RuleType：加白的规则类型、Status：规则开关状态、ValidStatus：规则生效状态、TimerType：生效方式、ID：具体的加白id，根据RuleType来判断是规则id还是类型id
+        :param _Filters: 筛选条件，支持 RuleId：规则ID、CveID：CVE编号、Desc：描述
         :type Filters: list of FiltersItemNew
         """
         self._Domain = None
         self._Offset = None
         self._Limit = None
-        self._By = None
-        self._Order = None
         self._Filters = None
 
     @property
     def Domain(self):
-        """需要查询的域名
+        """查询域名
         :rtype: str
         """
         return self._Domain
@@ -19290,7 +19363,7 @@ class DescribeOwaspWhiteRulesRequest(AbstractModel):
 
     @property
     def Offset(self):
-        """分页分页，默认为0
+        """分页页数，默认为0
         :rtype: int
         """
         return self._Offset
@@ -19310,31 +19383,9 @@ class DescribeOwaspWhiteRulesRequest(AbstractModel):
     def Limit(self, Limit):
         self._Limit = Limit
 
-    @property
-    def By(self):
-        """排序的字段，支持CreateTime：新建时间、UpdateTime：修改时间
-        :rtype: str
-        """
-        return self._By
-
-    @By.setter
-    def By(self, By):
-        self._By = By
-
-    @property
-    def Order(self):
-        """排序方式，支持asc、desc
-        :rtype: str
-        """
-        return self._Order
-
-    @Order.setter
-    def Order(self, Order):
-        self._Order = Order
-
     @property
     def Filters(self):
-        """筛选条件，支持RuleId：加白规则ID、 Name：规则名称、RuleType：加白的规则类型、Status：规则开关状态、ValidStatus：规则生效状态、TimerType：生效方式、ID：具体的加白id，根据RuleType来判断是规则id还是类型id
+        """筛选条件，支持 RuleId：规则ID、CveID：CVE编号、Desc：描述
         :rtype: list of FiltersItemNew
         """
         return self._Filters
@@ -19348,8 +19399,6 @@ class DescribeOwaspWhiteRulesRequest(AbstractModel):
         self._Domain = params.get("Domain")
         self._Offset = params.get("Offset")
         self._Limit = params.get("Limit")
-        self._By = params.get("By")
-        self._Order = params.get("Order")
         if params.get("Filters") is not None:
             self._Filters = []
             for item in params.get("Filters"):
@@ -19366,17 +19415,17 @@ class DescribeOwaspWhiteRulesRequest(AbstractModel):
         
 
 
-class DescribeOwaspWhiteRulesResponse(AbstractModel):
-    """DescribeOwaspWhiteRules返回参数结构体
+class DescribeOwaspRuleTypesResponse(AbstractModel):
+    """DescribeOwaspRuleTypes返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _Total: 规则总数
+        :param _Total: 规则类型数量
         :type Total: int
-        :param _List: 规则白名单列表
-        :type List: list of OwaspWhiteRule
+        :param _List: 规则类型列表及信息
+        :type List: list of OwaspRuleType
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
@@ -19386,7 +19435,7 @@ class DescribeOwaspWhiteRulesResponse(AbstractModel):
 
     @property
     def Total(self):
-        """规则总数
+        """规则类型数量
         :rtype: int
         """
         return self._Total
@@ -19397,8 +19446,8 @@ class DescribeOwaspWhiteRulesResponse(AbstractModel):
 
     @property
     def List(self):
-        """规则白名单列表
-        :rtype: list of OwaspWhiteRule
+        """规则类型列表及信息
+        :rtype: list of OwaspRuleType
         """
         return self._List
 
@@ -19423,140 +19472,121 @@ class DescribeOwaspWhiteRulesResponse(AbstractModel):
         if params.get("List") is not None:
             self._List = []
             for item in params.get("List"):
-                obj = OwaspWhiteRule()
+                obj = OwaspRuleType()
                 obj._deserialize(item)
                 self._List.append(obj)
         self._RequestId = params.get("RequestId")
 
 
-class DescribePeakPointsRequest(AbstractModel):
-    """DescribePeakPoints请求参数结构体
+class DescribeOwaspRulesRequest(AbstractModel):
+    """DescribeOwaspRules请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _FromTime: 查询起始时间
-        :type FromTime: str
-        :param _ToTime: 查询终止时间
-        :type ToTime: str
-        :param _Domain: 查询的域名，如果查询所有域名数据，该参数不填写
+        :param _Domain: 需要查询的域名
         :type Domain: str
-        :param _Edition: 只有两个值有效，sparta-waf，clb-waf，不传则不过滤
-        :type Edition: str
-        :param _InstanceID: WAF实例ID，不传则不过滤
-        :type InstanceID: str
-        :param _MetricName: 十二个值可选：
-access-峰值qps趋势图
-botAccess- bot峰值qps趋势图
-down-下行峰值带宽趋势图
-up-上行峰值带宽趋势图
-attack-Web攻击总数趋势图
-cc-CC攻击总数趋势图
-bw-黑IP攻击总数趋势图
-tamper-防篡改攻击总数趋势图
-leak-防泄露攻击总数趋势图
-acl-访问控制攻击总数趋势图
-http_status-状态码各次数趋势图
-wx_access-微信小程序峰值qps趋势图
-        :type MetricName: str
+        :param _Offset: 分页页数，默认为0
+        :type Offset: int
+        :param _Limit: 每页容量，默认为10
+        :type Limit: int
+        :param _By: 排序字段，支持 RuleId, UpdateTime
+        :type By: str
+        :param _Order: 排序方式，支持asc、desc
+        :type Order: str
+        :param _Filters: 筛选条件，支持 RuleId：规则ID、TypeId：规则类型、Desc：规则描述 、CveID：CVE编号、Status：规则状态、VulLevel：威胁等级
+        :type Filters: list of FiltersItemNew
         """
-        self._FromTime = None
-        self._ToTime = None
         self._Domain = None
-        self._Edition = None
-        self._InstanceID = None
-        self._MetricName = None
+        self._Offset = None
+        self._Limit = None
+        self._By = None
+        self._Order = None
+        self._Filters = None
 
     @property
-    def FromTime(self):
-        """查询起始时间
+    def Domain(self):
+        """需要查询的域名
         :rtype: str
         """
-        return self._FromTime
+        return self._Domain
 
-    @FromTime.setter
-    def FromTime(self, FromTime):
-        self._FromTime = FromTime
+    @Domain.setter
+    def Domain(self, Domain):
+        self._Domain = Domain
 
     @property
-    def ToTime(self):
-        """查询终止时间
-        :rtype: str
+    def Offset(self):
+        """分页页数，默认为0
+        :rtype: int
         """
-        return self._ToTime
+        return self._Offset
 
-    @ToTime.setter
-    def ToTime(self, ToTime):
-        self._ToTime = ToTime
+    @Offset.setter
+    def Offset(self, Offset):
+        self._Offset = Offset
 
     @property
-    def Domain(self):
-        """查询的域名，如果查询所有域名数据，该参数不填写
-        :rtype: str
+    def Limit(self):
+        """每页容量，默认为10
+        :rtype: int
         """
-        return self._Domain
+        return self._Limit
 
-    @Domain.setter
-    def Domain(self, Domain):
-        self._Domain = Domain
+    @Limit.setter
+    def Limit(self, Limit):
+        self._Limit = Limit
 
     @property
-    def Edition(self):
-        """只有两个值有效，sparta-waf，clb-waf，不传则不过滤
+    def By(self):
+        """排序字段，支持 RuleId, UpdateTime
         :rtype: str
         """
-        return self._Edition
+        return self._By
 
-    @Edition.setter
-    def Edition(self, Edition):
-        self._Edition = Edition
+    @By.setter
+    def By(self, By):
+        self._By = By
 
     @property
-    def InstanceID(self):
-        """WAF实例ID，不传则不过滤
+    def Order(self):
+        """排序方式，支持asc、desc
         :rtype: str
         """
-        return self._InstanceID
+        return self._Order
 
-    @InstanceID.setter
-    def InstanceID(self, InstanceID):
-        self._InstanceID = InstanceID
+    @Order.setter
+    def Order(self, Order):
+        self._Order = Order
 
     @property
-    def MetricName(self):
-        """十二个值可选：
-access-峰值qps趋势图
-botAccess- bot峰值qps趋势图
-down-下行峰值带宽趋势图
-up-上行峰值带宽趋势图
-attack-Web攻击总数趋势图
-cc-CC攻击总数趋势图
-bw-黑IP攻击总数趋势图
-tamper-防篡改攻击总数趋势图
-leak-防泄露攻击总数趋势图
-acl-访问控制攻击总数趋势图
-http_status-状态码各次数趋势图
-wx_access-微信小程序峰值qps趋势图
-        :rtype: str
+    def Filters(self):
+        """筛选条件，支持 RuleId：规则ID、TypeId：规则类型、Desc：规则描述 、CveID：CVE编号、Status：规则状态、VulLevel：威胁等级
+        :rtype: list of FiltersItemNew
         """
-        return self._MetricName
+        return self._Filters
 
-    @MetricName.setter
-    def MetricName(self, MetricName):
-        self._MetricName = MetricName
+    @Filters.setter
+    def Filters(self, Filters):
+        self._Filters = Filters
 
 
     def _deserialize(self, params):
-        self._FromTime = params.get("FromTime")
-        self._ToTime = params.get("ToTime")
         self._Domain = params.get("Domain")
-        self._Edition = params.get("Edition")
-        self._InstanceID = params.get("InstanceID")
-        self._MetricName = params.get("MetricName")
-        memeber_set = set(params.keys())
-        for name, value in vars(self).items():
-            property_name = name[1:]
+        self._Offset = params.get("Offset")
+        self._Limit = params.get("Limit")
+        self._By = params.get("By")
+        self._Order = params.get("Order")
+        if params.get("Filters") is not None:
+            self._Filters = []
+            for item in params.get("Filters"):
+                obj = FiltersItemNew()
+                obj._deserialize(item)
+                self._Filters.append(obj)
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
             if property_name in memeber_set:
                 memeber_set.remove(property_name)
         if len(memeber_set) > 0:
@@ -19564,31 +19594,45 @@ wx_access-微信小程序峰值qps趋势图
         
 
 
-class DescribePeakPointsResponse(AbstractModel):
-    """DescribePeakPoints返回参数结构体
+class DescribeOwaspRulesResponse(AbstractModel):
+    """DescribeOwaspRules返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _Points: 数据点
-        :type Points: list of PeakPointsItem
+        :param _Total: 规则总数
+        :type Total: int
+        :param _List: 规则列表
+        :type List: list of OwaspRule
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._Points = None
+        self._Total = None
+        self._List = None
         self._RequestId = None
 
     @property
-    def Points(self):
-        """数据点
-        :rtype: list of PeakPointsItem
+    def Total(self):
+        """规则总数
+        :rtype: int
         """
-        return self._Points
+        return self._Total
 
-    @Points.setter
-    def Points(self, Points):
-        self._Points = Points
+    @Total.setter
+    def Total(self, Total):
+        self._Total = Total
+
+    @property
+    def List(self):
+        """规则列表
+        :rtype: list of OwaspRule
+        """
+        return self._List
+
+    @List.setter
+    def List(self, List):
+        self._List = List
 
     @property
     def RequestId(self):
@@ -19603,126 +19647,122 @@ class DescribePeakPointsResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        if params.get("Points") is not None:
-            self._Points = []
-            for item in params.get("Points"):
-                obj = PeakPointsItem()
+        self._Total = params.get("Total")
+        if params.get("List") is not None:
+            self._List = []
+            for item in params.get("List"):
+                obj = OwaspRule()
                 obj._deserialize(item)
-                self._Points.append(obj)
+                self._List.append(obj)
         self._RequestId = params.get("RequestId")
 
 
-class DescribePeakValueRequest(AbstractModel):
-    """DescribePeakValue请求参数结构体
+class DescribeOwaspWhiteRulesRequest(AbstractModel):
+    """DescribeOwaspWhiteRules请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _FromTime: 查询起始时间
-        :type FromTime: str
-        :param _ToTime: 查询结束时间
-        :type ToTime: str
-        :param _Domain: 需要查询的域名，当前用户所有域名可以不传
+        :param _Domain: 需要查询的域名
         :type Domain: str
-        :param _Edition: 只有两个值有效，sparta-waf，clb-waf，不传则不过滤
-        :type Edition: str
-        :param _InstanceID: WAF实例ID，不传则不过滤
-        :type InstanceID: str
-        :param _MetricName: 五个值可选：
-access-峰值qps
-down-下行峰值带宽
-up-上行峰值带宽
-attack-Web攻击总数
-cc-CC攻击总数趋势图
-        :type MetricName: str
+        :param _Offset: 分页分页，默认为0
+        :type Offset: int
+        :param _Limit: 每页容量，默认为10
+        :type Limit: int
+        :param _By: 排序的字段，支持CreateTime：新建时间、UpdateTime：修改时间
+        :type By: str
+        :param _Order: 排序方式，支持asc、desc
+        :type Order: str
+        :param _Filters: 筛选条件，支持RuleId：加白规则ID、 Name：规则名称、RuleType：加白的规则类型、Status：规则开关状态、ValidStatus：规则生效状态、TimerType：生效方式、ID：具体的加白id，根据RuleType来判断是规则id还是类型id
+        :type Filters: list of FiltersItemNew
         """
-        self._FromTime = None
-        self._ToTime = None
         self._Domain = None
-        self._Edition = None
-        self._InstanceID = None
-        self._MetricName = None
+        self._Offset = None
+        self._Limit = None
+        self._By = None
+        self._Order = None
+        self._Filters = None
 
     @property
-    def FromTime(self):
-        """查询起始时间
+    def Domain(self):
+        """需要查询的域名
         :rtype: str
         """
-        return self._FromTime
+        return self._Domain
 
-    @FromTime.setter
-    def FromTime(self, FromTime):
-        self._FromTime = FromTime
+    @Domain.setter
+    def Domain(self, Domain):
+        self._Domain = Domain
 
     @property
-    def ToTime(self):
-        """查询结束时间
-        :rtype: str
+    def Offset(self):
+        """分页分页，默认为0
+        :rtype: int
         """
-        return self._ToTime
+        return self._Offset
 
-    @ToTime.setter
-    def ToTime(self, ToTime):
-        self._ToTime = ToTime
+    @Offset.setter
+    def Offset(self, Offset):
+        self._Offset = Offset
 
     @property
-    def Domain(self):
-        """需要查询的域名，当前用户所有域名可以不传
-        :rtype: str
+    def Limit(self):
+        """每页容量，默认为10
+        :rtype: int
         """
-        return self._Domain
+        return self._Limit
 
-    @Domain.setter
-    def Domain(self, Domain):
-        self._Domain = Domain
+    @Limit.setter
+    def Limit(self, Limit):
+        self._Limit = Limit
 
     @property
-    def Edition(self):
-        """只有两个值有效，sparta-waf，clb-waf，不传则不过滤
+    def By(self):
+        """排序的字段，支持CreateTime：新建时间、UpdateTime：修改时间
         :rtype: str
         """
-        return self._Edition
+        return self._By
 
-    @Edition.setter
-    def Edition(self, Edition):
-        self._Edition = Edition
+    @By.setter
+    def By(self, By):
+        self._By = By
 
     @property
-    def InstanceID(self):
-        """WAF实例ID，不传则不过滤
+    def Order(self):
+        """排序方式，支持asc、desc
         :rtype: str
         """
-        return self._InstanceID
+        return self._Order
 
-    @InstanceID.setter
-    def InstanceID(self, InstanceID):
-        self._InstanceID = InstanceID
+    @Order.setter
+    def Order(self, Order):
+        self._Order = Order
 
     @property
-    def MetricName(self):
-        """五个值可选：
-access-峰值qps
-down-下行峰值带宽
-up-上行峰值带宽
-attack-Web攻击总数
-cc-CC攻击总数趋势图
-        :rtype: str
+    def Filters(self):
+        """筛选条件，支持RuleId：加白规则ID、 Name：规则名称、RuleType：加白的规则类型、Status：规则开关状态、ValidStatus：规则生效状态、TimerType：生效方式、ID：具体的加白id，根据RuleType来判断是规则id还是类型id
+        :rtype: list of FiltersItemNew
         """
-        return self._MetricName
+        return self._Filters
 
-    @MetricName.setter
-    def MetricName(self, MetricName):
-        self._MetricName = MetricName
+    @Filters.setter
+    def Filters(self, Filters):
+        self._Filters = Filters
 
 
     def _deserialize(self, params):
-        self._FromTime = params.get("FromTime")
-        self._ToTime = params.get("ToTime")
         self._Domain = params.get("Domain")
-        self._Edition = params.get("Edition")
-        self._InstanceID = params.get("InstanceID")
-        self._MetricName = params.get("MetricName")
+        self._Offset = params.get("Offset")
+        self._Limit = params.get("Limit")
+        self._By = params.get("By")
+        self._Order = params.get("Order")
+        if params.get("Filters") is not None:
+            self._Filters = []
+            for item in params.get("Filters"):
+                obj = FiltersItemNew()
+                obj._deserialize(item)
+                self._Filters.append(obj)
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -19733,94 +19773,52 @@ cc-CC攻击总数趋势图
         
 
 
-class DescribePeakValueResponse(AbstractModel):
-    """DescribePeakValue返回参数结构体
+class DescribeOwaspWhiteRulesResponse(AbstractModel):
+    """DescribeOwaspWhiteRules返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _Access: QPS峰值
-        :type Access: int
-        :param _Up: 上行带宽峰值，单位B
-        :type Up: int
-        :param _Down: 下行带宽峰值，单位B
-        :type Down: int
-        :param _Attack: Web攻击总数
-        :type Attack: int
-        :param _Cc: CC攻击总数
-        :type Cc: int
+        :param _Total: 规则总数
+        :type Total: int
+        :param _List: 规则白名单列表
+        :type List: list of OwaspWhiteRule
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._Access = None
-        self._Up = None
-        self._Down = None
-        self._Attack = None
-        self._Cc = None
+        self._Total = None
+        self._List = None
         self._RequestId = None
 
     @property
-    def Access(self):
-        """QPS峰值
+    def Total(self):
+        """规则总数
         :rtype: int
         """
-        return self._Access
+        return self._Total
 
-    @Access.setter
-    def Access(self, Access):
-        self._Access = Access
+    @Total.setter
+    def Total(self, Total):
+        self._Total = Total
 
     @property
-    def Up(self):
-        """上行带宽峰值，单位B
-        :rtype: int
+    def List(self):
+        """规则白名单列表
+        :rtype: list of OwaspWhiteRule
         """
-        return self._Up
+        return self._List
 
-    @Up.setter
-    def Up(self, Up):
-        self._Up = Up
+    @List.setter
+    def List(self, List):
+        self._List = List
 
     @property
-    def Down(self):
-        """下行带宽峰值，单位B
-        :rtype: int
+    def RequestId(self):
+        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
         """
-        return self._Down
-
-    @Down.setter
-    def Down(self, Down):
-        self._Down = Down
-
-    @property
-    def Attack(self):
-        """Web攻击总数
-        :rtype: int
-        """
-        return self._Attack
-
-    @Attack.setter
-    def Attack(self, Attack):
-        self._Attack = Attack
-
-    @property
-    def Cc(self):
-        """CC攻击总数
-        :rtype: int
-        """
-        return self._Cc
-
-    @Cc.setter
-    def Cc(self, Cc):
-        self._Cc = Cc
-
-    @property
-    def RequestId(self):
-        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :rtype: str
-        """
-        return self._RequestId
+        return self._RequestId
 
     @RequestId.setter
     def RequestId(self, RequestId):
@@ -19828,32 +19826,80 @@ class DescribePeakValueResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._Access = params.get("Access")
-        self._Up = params.get("Up")
-        self._Down = params.get("Down")
-        self._Attack = params.get("Attack")
-        self._Cc = params.get("Cc")
+        self._Total = params.get("Total")
+        if params.get("List") is not None:
+            self._List = []
+            for item in params.get("List"):
+                obj = OwaspWhiteRule()
+                obj._deserialize(item)
+                self._List.append(obj)
         self._RequestId = params.get("RequestId")
 
 
-class DescribePolicyStatusRequest(AbstractModel):
-    """DescribePolicyStatus请求参数结构体
+class DescribePeakPointsRequest(AbstractModel):
+    """DescribePeakPoints请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _Domain: 域名
+        :param _FromTime: 查询起始时间
+        :type FromTime: str
+        :param _ToTime: 查询终止时间
+        :type ToTime: str
+        :param _Domain: 查询的域名，如果查询所有域名数据，该参数不填写
         :type Domain: str
-        :param _Edition: clb-waf或者saas-waf
+        :param _Edition: 只有两个值有效，sparta-waf，clb-waf，不传则不过滤
         :type Edition: str
+        :param _InstanceID: WAF实例ID，不传则不过滤
+        :type InstanceID: str
+        :param _MetricName: 十二个值可选：
+access-峰值qps趋势图
+botAccess- bot峰值qps趋势图
+down-下行峰值带宽趋势图
+up-上行峰值带宽趋势图
+attack-Web攻击总数趋势图
+cc-CC攻击总数趋势图
+bw-黑IP攻击总数趋势图
+tamper-防篡改攻击总数趋势图
+leak-防泄露攻击总数趋势图
+acl-访问控制攻击总数趋势图
+http_status-状态码各次数趋势图
+wx_access-微信小程序峰值qps趋势图
+        :type MetricName: str
         """
+        self._FromTime = None
+        self._ToTime = None
         self._Domain = None
         self._Edition = None
+        self._InstanceID = None
+        self._MetricName = None
+
+    @property
+    def FromTime(self):
+        """查询起始时间
+        :rtype: str
+        """
+        return self._FromTime
+
+    @FromTime.setter
+    def FromTime(self, FromTime):
+        self._FromTime = FromTime
+
+    @property
+    def ToTime(self):
+        """查询终止时间
+        :rtype: str
+        """
+        return self._ToTime
+
+    @ToTime.setter
+    def ToTime(self, ToTime):
+        self._ToTime = ToTime
 
     @property
     def Domain(self):
-        """域名
+        """查询的域名，如果查询所有域名数据，该参数不填写
         :rtype: str
         """
         return self._Domain
@@ -19864,7 +19910,7 @@ class DescribePolicyStatusRequest(AbstractModel):
 
     @property
     def Edition(self):
-        """clb-waf或者saas-waf
+        """只有两个值有效，sparta-waf，clb-waf，不传则不过滤
         :rtype: str
         """
         return self._Edition
@@ -19873,10 +19919,48 @@ class DescribePolicyStatusRequest(AbstractModel):
     def Edition(self, Edition):
         self._Edition = Edition
 
+    @property
+    def InstanceID(self):
+        """WAF实例ID，不传则不过滤
+        :rtype: str
+        """
+        return self._InstanceID
+
+    @InstanceID.setter
+    def InstanceID(self, InstanceID):
+        self._InstanceID = InstanceID
+
+    @property
+    def MetricName(self):
+        """十二个值可选：
+access-峰值qps趋势图
+botAccess- bot峰值qps趋势图
+down-下行峰值带宽趋势图
+up-上行峰值带宽趋势图
+attack-Web攻击总数趋势图
+cc-CC攻击总数趋势图
+bw-黑IP攻击总数趋势图
+tamper-防篡改攻击总数趋势图
+leak-防泄露攻击总数趋势图
+acl-访问控制攻击总数趋势图
+http_status-状态码各次数趋势图
+wx_access-微信小程序峰值qps趋势图
+        :rtype: str
+        """
+        return self._MetricName
+
+    @MetricName.setter
+    def MetricName(self, MetricName):
+        self._MetricName = MetricName
+
 
     def _deserialize(self, params):
+        self._FromTime = params.get("FromTime")
+        self._ToTime = params.get("ToTime")
         self._Domain = params.get("Domain")
         self._Edition = params.get("Edition")
+        self._InstanceID = params.get("InstanceID")
+        self._MetricName = params.get("MetricName")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -19887,45 +19971,31 @@ class DescribePolicyStatusRequest(AbstractModel):
         
 
 
-class DescribePolicyStatusResponse(AbstractModel):
-    """DescribePolicyStatus返回参数结构体
+class DescribePeakPointsResponse(AbstractModel):
+    """DescribePeakPoints返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _InstanceId: 实例ID
-        :type InstanceId: str
-        :param _Status: 防护状态
-        :type Status: int
+        :param _Points: 数据点
+        :type Points: list of PeakPointsItem
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._InstanceId = None
-        self._Status = None
+        self._Points = None
         self._RequestId = None
 
     @property
-    def InstanceId(self):
-        """实例ID
-        :rtype: str
-        """
-        return self._InstanceId
-
-    @InstanceId.setter
-    def InstanceId(self, InstanceId):
-        self._InstanceId = InstanceId
-
-    @property
-    def Status(self):
-        """防护状态
-        :rtype: int
+    def Points(self):
+        """数据点
+        :rtype: list of PeakPointsItem
         """
-        return self._Status
+        return self._Points
 
-    @Status.setter
-    def Status(self, Status):
-        self._Status = Status
+    @Points.setter
+    def Points(self, Points):
+        self._Points = Points
 
     @property
     def RequestId(self):
@@ -19940,40 +20010,83 @@ class DescribePolicyStatusResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._InstanceId = params.get("InstanceId")
-        self._Status = params.get("Status")
+        if params.get("Points") is not None:
+            self._Points = []
+            for item in params.get("Points"):
+                obj = PeakPointsItem()
+                obj._deserialize(item)
+                self._Points.append(obj)
         self._RequestId = params.get("RequestId")
 
 
-class DescribePortsRequest(AbstractModel):
-    """DescribePorts请求参数结构体
+class DescribePeakValueRequest(AbstractModel):
+    """DescribePeakValue请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _InstanceID: 实例ID
-        :type InstanceID: str
-        :param _Edition: 实例类型
+        :param _FromTime: 查询起始时间
+        :type FromTime: str
+        :param _ToTime: 查询结束时间
+        :type ToTime: str
+        :param _Domain: 需要查询的域名，当前用户所有域名可以不传
+        :type Domain: str
+        :param _Edition: 只有两个值有效，sparta-waf，clb-waf，不传则不过滤
         :type Edition: str
+        :param _InstanceID: WAF实例ID，不传则不过滤
+        :type InstanceID: str
+        :param _MetricName: 五个值可选：
+access-峰值qps
+down-下行峰值带宽
+up-上行峰值带宽
+attack-Web攻击总数
+cc-CC攻击总数趋势图
+        :type MetricName: str
         """
-        self._InstanceID = None
+        self._FromTime = None
+        self._ToTime = None
+        self._Domain = None
         self._Edition = None
+        self._InstanceID = None
+        self._MetricName = None
 
     @property
-    def InstanceID(self):
-        """实例ID
+    def FromTime(self):
+        """查询起始时间
         :rtype: str
         """
-        return self._InstanceID
+        return self._FromTime
 
-    @InstanceID.setter
-    def InstanceID(self, InstanceID):
-        self._InstanceID = InstanceID
+    @FromTime.setter
+    def FromTime(self, FromTime):
+        self._FromTime = FromTime
+
+    @property
+    def ToTime(self):
+        """查询结束时间
+        :rtype: str
+        """
+        return self._ToTime
+
+    @ToTime.setter
+    def ToTime(self, ToTime):
+        self._ToTime = ToTime
+
+    @property
+    def Domain(self):
+        """需要查询的域名，当前用户所有域名可以不传
+        :rtype: str
+        """
+        return self._Domain
+
+    @Domain.setter
+    def Domain(self, Domain):
+        self._Domain = Domain
 
     @property
     def Edition(self):
-        """实例类型
+        """只有两个值有效，sparta-waf，clb-waf，不传则不过滤
         :rtype: str
         """
         return self._Edition
@@ -19982,10 +20095,41 @@ class DescribePortsRequest(AbstractModel):
     def Edition(self, Edition):
         self._Edition = Edition
 
+    @property
+    def InstanceID(self):
+        """WAF实例ID，不传则不过滤
+        :rtype: str
+        """
+        return self._InstanceID
+
+    @InstanceID.setter
+    def InstanceID(self, InstanceID):
+        self._InstanceID = InstanceID
+
+    @property
+    def MetricName(self):
+        """五个值可选：
+access-峰值qps
+down-下行峰值带宽
+up-上行峰值带宽
+attack-Web攻击总数
+cc-CC攻击总数趋势图
+        :rtype: str
+        """
+        return self._MetricName
+
+    @MetricName.setter
+    def MetricName(self, MetricName):
+        self._MetricName = MetricName
+
 
     def _deserialize(self, params):
-        self._InstanceID = params.get("InstanceID")
+        self._FromTime = params.get("FromTime")
+        self._ToTime = params.get("ToTime")
+        self._Domain = params.get("Domain")
         self._Edition = params.get("Edition")
+        self._InstanceID = params.get("InstanceID")
+        self._MetricName = params.get("MetricName")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -19996,45 +20140,87 @@ class DescribePortsRequest(AbstractModel):
         
 
 
-class DescribePortsResponse(AbstractModel):
-    """DescribePorts返回参数结构体
+class DescribePeakValueResponse(AbstractModel):
+    """DescribePeakValue返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _HttpPorts: http端口列表
-        :type HttpPorts: list of str
-        :param _HttpsPorts: https端口列表
-        :type HttpsPorts: list of str
+        :param _Access: QPS峰值
+        :type Access: int
+        :param _Up: 上行带宽峰值，单位B
+        :type Up: int
+        :param _Down: 下行带宽峰值，单位B
+        :type Down: int
+        :param _Attack: Web攻击总数
+        :type Attack: int
+        :param _Cc: CC攻击总数
+        :type Cc: int
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._HttpPorts = None
-        self._HttpsPorts = None
+        self._Access = None
+        self._Up = None
+        self._Down = None
+        self._Attack = None
+        self._Cc = None
         self._RequestId = None
 
     @property
-    def HttpPorts(self):
-        """http端口列表
-        :rtype: list of str
+    def Access(self):
+        """QPS峰值
+        :rtype: int
         """
-        return self._HttpPorts
+        return self._Access
 
-    @HttpPorts.setter
-    def HttpPorts(self, HttpPorts):
-        self._HttpPorts = HttpPorts
+    @Access.setter
+    def Access(self, Access):
+        self._Access = Access
 
     @property
-    def HttpsPorts(self):
-        """https端口列表
-        :rtype: list of str
+    def Up(self):
+        """上行带宽峰值，单位B
+        :rtype: int
         """
-        return self._HttpsPorts
+        return self._Up
 
-    @HttpsPorts.setter
-    def HttpsPorts(self, HttpsPorts):
-        self._HttpsPorts = HttpsPorts
+    @Up.setter
+    def Up(self, Up):
+        self._Up = Up
+
+    @property
+    def Down(self):
+        """下行带宽峰值，单位B
+        :rtype: int
+        """
+        return self._Down
+
+    @Down.setter
+    def Down(self, Down):
+        self._Down = Down
+
+    @property
+    def Attack(self):
+        """Web攻击总数
+        :rtype: int
+        """
+        return self._Attack
+
+    @Attack.setter
+    def Attack(self, Attack):
+        self._Attack = Attack
+
+    @property
+    def Cc(self):
+        """CC攻击总数
+        :rtype: int
+        """
+        return self._Cc
+
+    @Cc.setter
+    def Cc(self, Cc):
+        self._Cc = Cc
 
     @property
     def RequestId(self):
@@ -20049,37 +20235,55 @@ class DescribePortsResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._HttpPorts = params.get("HttpPorts")
-        self._HttpsPorts = params.get("HttpsPorts")
+        self._Access = params.get("Access")
+        self._Up = params.get("Up")
+        self._Down = params.get("Down")
+        self._Attack = params.get("Attack")
+        self._Cc = params.get("Cc")
         self._RequestId = params.get("RequestId")
 
 
-class DescribePostCKafkaFlowsRequest(AbstractModel):
-    """DescribePostCKafkaFlows请求参数结构体
+class DescribePolicyStatusRequest(AbstractModel):
+    """DescribePolicyStatus请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _LogType: 1-访问日志，2-攻击日志，默认为访问日志。
-        :type LogType: int
+        :param _Domain: 域名
+        :type Domain: str
+        :param _Edition: clb-waf或者saas-waf
+        :type Edition: str
         """
-        self._LogType = None
+        self._Domain = None
+        self._Edition = None
 
     @property
-    def LogType(self):
-        """1-访问日志，2-攻击日志，默认为访问日志。
-        :rtype: int
+    def Domain(self):
+        """域名
+        :rtype: str
         """
-        return self._LogType
+        return self._Domain
 
-    @LogType.setter
-    def LogType(self, LogType):
-        self._LogType = LogType
+    @Domain.setter
+    def Domain(self, Domain):
+        self._Domain = Domain
+
+    @property
+    def Edition(self):
+        """clb-waf或者saas-waf
+        :rtype: str
+        """
+        return self._Edition
+
+    @Edition.setter
+    def Edition(self, Edition):
+        self._Edition = Edition
 
 
     def _deserialize(self, params):
-        self._LogType = params.get("LogType")
+        self._Domain = params.get("Domain")
+        self._Edition = params.get("Edition")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -20090,31 +20294,45 @@ class DescribePostCKafkaFlowsRequest(AbstractModel):
         
 
 
-class DescribePostCKafkaFlowsResponse(AbstractModel):
-    """DescribePostCKafkaFlows返回参数结构体
+class DescribePolicyStatusResponse(AbstractModel):
+    """DescribePolicyStatus返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _PostCKafkaFlows: 客户的投递流列表
-        :type PostCKafkaFlows: list of PostCKafkaFlowInfo
+        :param _InstanceId: 实例ID
+        :type InstanceId: str
+        :param _Status: 防护状态
+        :type Status: int
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._PostCKafkaFlows = None
+        self._InstanceId = None
+        self._Status = None
         self._RequestId = None
 
     @property
-    def PostCKafkaFlows(self):
-        """客户的投递流列表
-        :rtype: list of PostCKafkaFlowInfo
+    def InstanceId(self):
+        """实例ID
+        :rtype: str
         """
-        return self._PostCKafkaFlows
+        return self._InstanceId
 
-    @PostCKafkaFlows.setter
-    def PostCKafkaFlows(self, PostCKafkaFlows):
-        self._PostCKafkaFlows = PostCKafkaFlows
+    @InstanceId.setter
+    def InstanceId(self, InstanceId):
+        self._InstanceId = InstanceId
+
+    @property
+    def Status(self):
+        """防护状态
+        :rtype: int
+        """
+        return self._Status
+
+    @Status.setter
+    def Status(self, Status):
+        self._Status = Status
 
     @property
     def RequestId(self):
@@ -20129,41 +20347,52 @@ class DescribePostCKafkaFlowsResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        if params.get("PostCKafkaFlows") is not None:
-            self._PostCKafkaFlows = []
-            for item in params.get("PostCKafkaFlows"):
-                obj = PostCKafkaFlowInfo()
-                obj._deserialize(item)
-                self._PostCKafkaFlows.append(obj)
+        self._InstanceId = params.get("InstanceId")
+        self._Status = params.get("Status")
         self._RequestId = params.get("RequestId")
 
 
-class DescribePostCLSFlowsRequest(AbstractModel):
-    """DescribePostCLSFlows请求参数结构体
+class DescribePortsRequest(AbstractModel):
+    """DescribePorts请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _LogType: 1-访问日志，2-攻击日志，默认为访问日志。
-        :type LogType: int
+        :param _InstanceID: 实例ID
+        :type InstanceID: str
+        :param _Edition: 实例类型
+        :type Edition: str
         """
-        self._LogType = None
+        self._InstanceID = None
+        self._Edition = None
 
     @property
-    def LogType(self):
-        """1-访问日志，2-攻击日志，默认为访问日志。
-        :rtype: int
+    def InstanceID(self):
+        """实例ID
+        :rtype: str
         """
-        return self._LogType
+        return self._InstanceID
 
-    @LogType.setter
-    def LogType(self, LogType):
-        self._LogType = LogType
+    @InstanceID.setter
+    def InstanceID(self, InstanceID):
+        self._InstanceID = InstanceID
+
+    @property
+    def Edition(self):
+        """实例类型
+        :rtype: str
+        """
+        return self._Edition
+
+    @Edition.setter
+    def Edition(self, Edition):
+        self._Edition = Edition
 
 
     def _deserialize(self, params):
-        self._LogType = params.get("LogType")
+        self._InstanceID = params.get("InstanceID")
+        self._Edition = params.get("Edition")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -20174,17 +20403,195 @@ class DescribePostCLSFlowsRequest(AbstractModel):
         
 
 
-class DescribePostCLSFlowsResponse(AbstractModel):
-    """DescribePostCLSFlows返回参数结构体
+class DescribePortsResponse(AbstractModel):
+    """DescribePorts返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _PostCLSFlows: 客户的投递流列表
-        :type PostCLSFlows: list of PostCLSFlowInfo
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
+        :param _HttpPorts: http端口列表
+        :type HttpPorts: list of str
+        :param _HttpsPorts: https端口列表
+        :type HttpsPorts: list of str
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._HttpPorts = None
+        self._HttpsPorts = None
+        self._RequestId = None
+
+    @property
+    def HttpPorts(self):
+        """http端口列表
+        :rtype: list of str
+        """
+        return self._HttpPorts
+
+    @HttpPorts.setter
+    def HttpPorts(self, HttpPorts):
+        self._HttpPorts = HttpPorts
+
+    @property
+    def HttpsPorts(self):
+        """https端口列表
+        :rtype: list of str
+        """
+        return self._HttpsPorts
+
+    @HttpsPorts.setter
+    def HttpsPorts(self, HttpsPorts):
+        self._HttpsPorts = HttpsPorts
+
+    @property
+    def RequestId(self):
+        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._HttpPorts = params.get("HttpPorts")
+        self._HttpsPorts = params.get("HttpsPorts")
+        self._RequestId = params.get("RequestId")
+
+
+class DescribePostCKafkaFlowsRequest(AbstractModel):
+    """DescribePostCKafkaFlows请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _LogType: 1-访问日志，2-攻击日志，默认为访问日志。
+        :type LogType: int
+        """
+        self._LogType = None
+
+    @property
+    def LogType(self):
+        """1-访问日志，2-攻击日志，默认为访问日志。
+        :rtype: int
+        """
+        return self._LogType
+
+    @LogType.setter
+    def LogType(self, LogType):
+        self._LogType = LogType
+
+
+    def _deserialize(self, params):
+        self._LogType = params.get("LogType")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class DescribePostCKafkaFlowsResponse(AbstractModel):
+    """DescribePostCKafkaFlows返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _PostCKafkaFlows: 客户的投递流列表
+        :type PostCKafkaFlows: list of PostCKafkaFlowInfo
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._PostCKafkaFlows = None
+        self._RequestId = None
+
+    @property
+    def PostCKafkaFlows(self):
+        """客户的投递流列表
+        :rtype: list of PostCKafkaFlowInfo
+        """
+        return self._PostCKafkaFlows
+
+    @PostCKafkaFlows.setter
+    def PostCKafkaFlows(self, PostCKafkaFlows):
+        self._PostCKafkaFlows = PostCKafkaFlows
+
+    @property
+    def RequestId(self):
+        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        if params.get("PostCKafkaFlows") is not None:
+            self._PostCKafkaFlows = []
+            for item in params.get("PostCKafkaFlows"):
+                obj = PostCKafkaFlowInfo()
+                obj._deserialize(item)
+                self._PostCKafkaFlows.append(obj)
+        self._RequestId = params.get("RequestId")
+
+
+class DescribePostCLSFlowsRequest(AbstractModel):
+    """DescribePostCLSFlows请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _LogType: 1-访问日志，2-攻击日志，默认为访问日志。
+        :type LogType: int
+        """
+        self._LogType = None
+
+    @property
+    def LogType(self):
+        """1-访问日志，2-攻击日志，默认为访问日志。
+        :rtype: int
+        """
+        return self._LogType
+
+    @LogType.setter
+    def LogType(self, LogType):
+        self._LogType = LogType
+
+
+    def _deserialize(self, params):
+        self._LogType = params.get("LogType")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class DescribePostCLSFlowsResponse(AbstractModel):
+    """DescribePostCLSFlows返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _PostCLSFlows: 客户的投递流列表
+        :type PostCLSFlows: list of PostCLSFlowInfo
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
         """
         self._PostCLSFlows = None
         self._RequestId = None
@@ -35458,66 +35865,32 @@ class ModifyObjectResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
-class ModifyOwaspWhiteRuleRequest(AbstractModel):
-    """ModifyOwaspWhiteRule请求参数结构体
+class ModifyOwaspRuleStatusRequest(AbstractModel):
+    """ModifyOwaspRuleStatus请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _RuleId: 规则ID
-        :type RuleId: int
-        :param _Name: 规则名称
-        :type Name: str
         :param _Domain: 域名
         :type Domain: str
-        :param _Strategies: 规则匹配策略列表
-        :type Strategies: list of Strategy
-        :param _Ids: 加白的规则ID列表
-        :type Ids: list of int non-negative
-        :param _Type: 加白的类型，0:按照特定规则ID加白, 1:按照规则类型加白
-        :type Type: int
-        :param _JobType: 规则执行的方式，TimedJob为定时执行，CronJob为周期执行
-        :type JobType: str
-        :param _JobDateTime: 定时任务配置
-        :type JobDateTime: :class:`tencentcloud.waf.v20180125.models.JobDateTime`
-        :param _ExpireTime: 如果没有设置JobDateTime字段则用此字段，0表示永久生效，其它表示定时生效的截止时间（单位为秒）
-        :type ExpireTime: int
-        :param _Status: 规则状态，0：关闭、1：开启，默认为开启
-        :type Status: int
+        :param _RuleStatus: 规则开关，0：关闭、1：开启、2：只观察
+        :type RuleStatus: int
+        :param _SelectAll: 是否全选
+        :type SelectAll: bool
+        :param _RuleIDs: 规则ID列表
+        :type RuleIDs: list of str
+        :param _TypeId: 如果反转需要传入类型
+        :type TypeId: int
+        :param _Reason: 修改原因 0：无(兼容记录为空) 1：业务自身特性误报避免 2：规则误报上报 3：核心业务规则灰度 4：其它
+        :type Reason: int
         """
-        self._RuleId = None
-        self._Name = None
         self._Domain = None
-        self._Strategies = None
-        self._Ids = None
-        self._Type = None
-        self._JobType = None
-        self._JobDateTime = None
-        self._ExpireTime = None
-        self._Status = None
-
-    @property
-    def RuleId(self):
-        """规则ID
-        :rtype: int
-        """
-        return self._RuleId
-
-    @RuleId.setter
-    def RuleId(self, RuleId):
-        self._RuleId = RuleId
-
-    @property
-    def Name(self):
-        """规则名称
-        :rtype: str
-        """
-        return self._Name
-
-    @Name.setter
-    def Name(self, Name):
-        self._Name = Name
+        self._RuleStatus = None
+        self._SelectAll = None
+        self._RuleIDs = None
+        self._TypeId = None
+        self._Reason = None
 
     @property
     def Domain(self):
@@ -35531,101 +35904,68 @@ class ModifyOwaspWhiteRuleRequest(AbstractModel):
         self._Domain = Domain
 
     @property
-    def Strategies(self):
-        """规则匹配策略列表
-        :rtype: list of Strategy
+    def RuleStatus(self):
+        """规则开关，0：关闭、1：开启、2：只观察
+        :rtype: int
         """
-        return self._Strategies
+        return self._RuleStatus
 
-    @Strategies.setter
-    def Strategies(self, Strategies):
-        self._Strategies = Strategies
+    @RuleStatus.setter
+    def RuleStatus(self, RuleStatus):
+        self._RuleStatus = RuleStatus
 
     @property
-    def Ids(self):
-        """加白的规则ID列表
-        :rtype: list of int non-negative
+    def SelectAll(self):
+        """是否全选
+        :rtype: bool
         """
-        return self._Ids
+        return self._SelectAll
 
-    @Ids.setter
-    def Ids(self, Ids):
-        self._Ids = Ids
+    @SelectAll.setter
+    def SelectAll(self, SelectAll):
+        self._SelectAll = SelectAll
 
     @property
-    def Type(self):
-        """加白的类型，0:按照特定规则ID加白, 1:按照规则类型加白
-        :rtype: int
-        """
-        return self._Type
-
-    @Type.setter
-    def Type(self, Type):
-        self._Type = Type
-
-    @property
-    def JobType(self):
-        """规则执行的方式，TimedJob为定时执行，CronJob为周期执行
-        :rtype: str
-        """
-        return self._JobType
-
-    @JobType.setter
-    def JobType(self, JobType):
-        self._JobType = JobType
-
-    @property
-    def JobDateTime(self):
-        """定时任务配置
-        :rtype: :class:`tencentcloud.waf.v20180125.models.JobDateTime`
+    def RuleIDs(self):
+        """规则ID列表
+        :rtype: list of str
         """
-        return self._JobDateTime
+        return self._RuleIDs
 
-    @JobDateTime.setter
-    def JobDateTime(self, JobDateTime):
-        self._JobDateTime = JobDateTime
+    @RuleIDs.setter
+    def RuleIDs(self, RuleIDs):
+        self._RuleIDs = RuleIDs
 
     @property
-    def ExpireTime(self):
-        """如果没有设置JobDateTime字段则用此字段，0表示永久生效，其它表示定时生效的截止时间（单位为秒）
+    def TypeId(self):
+        """如果反转需要传入类型
         :rtype: int
         """
-        return self._ExpireTime
+        return self._TypeId
 
-    @ExpireTime.setter
-    def ExpireTime(self, ExpireTime):
-        self._ExpireTime = ExpireTime
+    @TypeId.setter
+    def TypeId(self, TypeId):
+        self._TypeId = TypeId
 
     @property
-    def Status(self):
-        """规则状态，0：关闭、1：开启，默认为开启
+    def Reason(self):
+        """修改原因 0：无(兼容记录为空) 1：业务自身特性误报避免 2：规则误报上报 3：核心业务规则灰度 4：其它
         :rtype: int
         """
-        return self._Status
+        return self._Reason
 
-    @Status.setter
-    def Status(self, Status):
-        self._Status = Status
+    @Reason.setter
+    def Reason(self, Reason):
+        self._Reason = Reason
 
 
     def _deserialize(self, params):
-        self._RuleId = params.get("RuleId")
-        self._Name = params.get("Name")
         self._Domain = params.get("Domain")
-        if params.get("Strategies") is not None:
-            self._Strategies = []
-            for item in params.get("Strategies"):
-                obj = Strategy()
-                obj._deserialize(item)
-                self._Strategies.append(obj)
-        self._Ids = params.get("Ids")
-        self._Type = params.get("Type")
-        self._JobType = params.get("JobType")
-        if params.get("JobDateTime") is not None:
-            self._JobDateTime = JobDateTime()
-            self._JobDateTime._deserialize(params.get("JobDateTime"))
-        self._ExpireTime = params.get("ExpireTime")
-        self._Status = params.get("Status")
+        self._RuleStatus = params.get("RuleStatus")
+        self._SelectAll = params.get("SelectAll")
+        self._RuleIDs = params.get("RuleIDs")
+        self._TypeId = params.get("TypeId")
+        self._Reason = params.get("Reason")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -35636,8 +35976,8 @@ class ModifyOwaspWhiteRuleRequest(AbstractModel):
         
 
 
-class ModifyOwaspWhiteRuleResponse(AbstractModel):
-    """ModifyOwaspWhiteRule返回参数结构体
+class ModifyOwaspRuleStatusResponse(AbstractModel):
+    """ModifyOwaspRuleStatus返回参数结构体
 
     """
 
@@ -35664,8 +36004,8 @@ class ModifyOwaspWhiteRuleResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
-class ModifyProtectionStatusRequest(AbstractModel):
-    """ModifyProtectionStatus请求参数结构体
+class ModifyOwaspRuleTypeActionRequest(AbstractModel):
+    """ModifyOwaspRuleTypeAction请求参数结构体
 
     """
 
@@ -35673,14 +36013,14 @@ class ModifyProtectionStatusRequest(AbstractModel):
         r"""
         :param _Domain: 域名
         :type Domain: str
-        :param _Status: 1：开启WAF开关，0：关闭WAF开关
-        :type Status: int
-        :param _Edition: WAF的版本，clb-waf代表负载均衡WAF、sparta-waf代表SaaS WAF，默认是sparta-waf。
-        :type Edition: str
+        :param _TypeIDs: 规则类型ID列表
+        :type TypeIDs: list of str
+        :param _RuleTypeAction: 规则类型的防护模式，0：观察、1：拦截
+        :type RuleTypeAction: int
         """
         self._Domain = None
-        self._Status = None
-        self._Edition = None
+        self._TypeIDs = None
+        self._RuleTypeAction = None
 
     @property
     def Domain(self):
@@ -35694,32 +36034,32 @@ class ModifyProtectionStatusRequest(AbstractModel):
         self._Domain = Domain
 
     @property
-    def Status(self):
-        """1：开启WAF开关，0：关闭WAF开关
-        :rtype: int
+    def TypeIDs(self):
+        """规则类型ID列表
+        :rtype: list of str
         """
-        return self._Status
+        return self._TypeIDs
 
-    @Status.setter
-    def Status(self, Status):
-        self._Status = Status
+    @TypeIDs.setter
+    def TypeIDs(self, TypeIDs):
+        self._TypeIDs = TypeIDs
 
     @property
-    def Edition(self):
-        """WAF的版本，clb-waf代表负载均衡WAF、sparta-waf代表SaaS WAF，默认是sparta-waf。
-        :rtype: str
+    def RuleTypeAction(self):
+        """规则类型的防护模式，0：观察、1：拦截
+        :rtype: int
         """
-        return self._Edition
+        return self._RuleTypeAction
 
-    @Edition.setter
-    def Edition(self, Edition):
-        self._Edition = Edition
+    @RuleTypeAction.setter
+    def RuleTypeAction(self, RuleTypeAction):
+        self._RuleTypeAction = RuleTypeAction
 
 
     def _deserialize(self, params):
         self._Domain = params.get("Domain")
-        self._Status = params.get("Status")
-        self._Edition = params.get("Edition")
+        self._TypeIDs = params.get("TypeIDs")
+        self._RuleTypeAction = params.get("RuleTypeAction")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -35730,8 +36070,8 @@ class ModifyProtectionStatusRequest(AbstractModel):
         
 
 
-class ModifyProtectionStatusResponse(AbstractModel):
-    """ModifyProtectionStatus返回参数结构体
+class ModifyOwaspRuleTypeActionResponse(AbstractModel):
+    """ModifyOwaspRuleTypeAction返回参数结构体
 
     """
 
@@ -35758,8 +36098,8 @@ class ModifyProtectionStatusResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
-class ModifySpartaProtectionModeRequest(AbstractModel):
-    """ModifySpartaProtectionMode请求参数结构体
+class ModifyOwaspRuleTypeLevelRequest(AbstractModel):
+    """ModifyOwaspRuleTypeLevel请求参数结构体
 
     """
 
@@ -35767,22 +36107,14 @@ class ModifySpartaProtectionModeRequest(AbstractModel):
         r"""
         :param _Domain: 域名
         :type Domain: str
-        :param _Mode: 防护状态：
-10：规则观察&&AI关闭模式，11：规则观察&&AI观察模式，12：规则观察&&AI拦截模式
-20：规则拦截&&AI关闭模式，21：规则拦截&&AI观察模式，22：规则拦截&&AI拦截模式
-        :type Mode: int
-        :param _Edition: WAF的版本，clb-waf代表负载均衡WAF、sparta-waf代表SaaS WAF，默认是sparta-waf。
-        :type Edition: str
-        :param _Type: 0是修改规则引擎状态，1是修改AI的状态
-        :type Type: int
-        :param _InstanceID: 实例id
-        :type InstanceID: str
+        :param _TypeIDs: 规则类型ID列表
+        :type TypeIDs: list of str
+        :param _RuleTypeLevel: 规则的防护等级，100：宽松、200：正常、300：严格、400：超严格
+        :type RuleTypeLevel: int
         """
         self._Domain = None
-        self._Mode = None
-        self._Edition = None
-        self._Type = None
-        self._InstanceID = None
+        self._TypeIDs = None
+        self._RuleTypeLevel = None
 
     @property
     def Domain(self):
@@ -35796,58 +36128,126 @@ class ModifySpartaProtectionModeRequest(AbstractModel):
         self._Domain = Domain
 
     @property
-    def Mode(self):
-        """防护状态：
-10：规则观察&&AI关闭模式，11：规则观察&&AI观察模式，12：规则观察&&AI拦截模式
-20：规则拦截&&AI关闭模式，21：规则拦截&&AI观察模式，22：规则拦截&&AI拦截模式
+    def TypeIDs(self):
+        """规则类型ID列表
+        :rtype: list of str
+        """
+        return self._TypeIDs
+
+    @TypeIDs.setter
+    def TypeIDs(self, TypeIDs):
+        self._TypeIDs = TypeIDs
+
+    @property
+    def RuleTypeLevel(self):
+        """规则的防护等级，100：宽松、200：正常、300：严格、400：超严格
         :rtype: int
         """
-        return self._Mode
+        return self._RuleTypeLevel
 
-    @Mode.setter
-    def Mode(self, Mode):
-        self._Mode = Mode
+    @RuleTypeLevel.setter
+    def RuleTypeLevel(self, RuleTypeLevel):
+        self._RuleTypeLevel = RuleTypeLevel
+
+
+    def _deserialize(self, params):
+        self._Domain = params.get("Domain")
+        self._TypeIDs = params.get("TypeIDs")
+        self._RuleTypeLevel = params.get("RuleTypeLevel")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class ModifyOwaspRuleTypeLevelResponse(AbstractModel):
+    """ModifyOwaspRuleTypeLevel返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._RequestId = None
 
     @property
-    def Edition(self):
-        """WAF的版本，clb-waf代表负载均衡WAF、sparta-waf代表SaaS WAF，默认是sparta-waf。
+    def RequestId(self):
+        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :rtype: str
         """
-        return self._Edition
+        return self._RequestId
 
-    @Edition.setter
-    def Edition(self, Edition):
-        self._Edition = Edition
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._RequestId = params.get("RequestId")
+
+
+class ModifyOwaspRuleTypeStatusRequest(AbstractModel):
+    """ModifyOwaspRuleTypeStatus请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Domain: 域名
+        :type Domain: str
+        :param _TypeIDs: 规则类型ID列表
+        :type TypeIDs: list of str
+        :param _RuleTypeStatus: 规则类型的开关状态，0：关闭、1：开启
+        :type RuleTypeStatus: int
+        """
+        self._Domain = None
+        self._TypeIDs = None
+        self._RuleTypeStatus = None
 
     @property
-    def Type(self):
-        """0是修改规则引擎状态，1是修改AI的状态
-        :rtype: int
+    def Domain(self):
+        """域名
+        :rtype: str
         """
-        return self._Type
+        return self._Domain
 
-    @Type.setter
-    def Type(self, Type):
-        self._Type = Type
+    @Domain.setter
+    def Domain(self, Domain):
+        self._Domain = Domain
 
     @property
-    def InstanceID(self):
-        """实例id
-        :rtype: str
+    def TypeIDs(self):
+        """规则类型ID列表
+        :rtype: list of str
         """
-        return self._InstanceID
+        return self._TypeIDs
 
-    @InstanceID.setter
-    def InstanceID(self, InstanceID):
-        self._InstanceID = InstanceID
+    @TypeIDs.setter
+    def TypeIDs(self, TypeIDs):
+        self._TypeIDs = TypeIDs
+
+    @property
+    def RuleTypeStatus(self):
+        """规则类型的开关状态，0：关闭、1：开启
+        :rtype: int
+        """
+        return self._RuleTypeStatus
+
+    @RuleTypeStatus.setter
+    def RuleTypeStatus(self, RuleTypeStatus):
+        self._RuleTypeStatus = RuleTypeStatus
 
 
     def _deserialize(self, params):
         self._Domain = params.get("Domain")
-        self._Mode = params.get("Mode")
-        self._Edition = params.get("Edition")
-        self._Type = params.get("Type")
-        self._InstanceID = params.get("InstanceID")
+        self._TypeIDs = params.get("TypeIDs")
+        self._RuleTypeStatus = params.get("RuleTypeStatus")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -35858,8 +36258,8 @@ class ModifySpartaProtectionModeRequest(AbstractModel):
         
 
 
-class ModifySpartaProtectionModeResponse(AbstractModel):
-    """ModifySpartaProtectionMode返回参数结构体
+class ModifyOwaspRuleTypeStatusResponse(AbstractModel):
+    """ModifyOwaspRuleTypeStatus返回参数结构体
 
     """
 
@@ -35886,21 +36286,449 @@ class ModifySpartaProtectionModeResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
-class ModifySpartaProtectionRequest(AbstractModel):
-    """ModifySpartaProtection请求参数结构体
+class ModifyOwaspWhiteRuleRequest(AbstractModel):
+    """ModifyOwaspWhiteRule请求参数结构体
 
     """
 
     def __init__(self):
         r"""
+        :param _RuleId: 规则ID
+        :type RuleId: int
+        :param _Name: 规则名称
+        :type Name: str
         :param _Domain: 域名
         :type Domain: str
-        :param _DomainId: 必填项。域名唯一ID
-        :type DomainId: str
-        :param _InstanceID: 必填项。域名所属实例id
-        :type InstanceID: str
-        :param _CertType: 证书类型。0：仅配置HTTP监听端口，没有证书1：证书来源为自有证书2：证书来源为托管证书
-        :type CertType: int
+        :param _Strategies: 规则匹配策略列表
+        :type Strategies: list of Strategy
+        :param _Ids: 加白的规则ID列表
+        :type Ids: list of int non-negative
+        :param _Type: 加白的类型，0:按照特定规则ID加白, 1:按照规则类型加白
+        :type Type: int
+        :param _JobType: 规则执行的方式，TimedJob为定时执行，CronJob为周期执行
+        :type JobType: str
+        :param _JobDateTime: 定时任务配置
+        :type JobDateTime: :class:`tencentcloud.waf.v20180125.models.JobDateTime`
+        :param _ExpireTime: 如果没有设置JobDateTime字段则用此字段，0表示永久生效，其它表示定时生效的截止时间（单位为秒）
+        :type ExpireTime: int
+        :param _Status: 规则状态，0：关闭、1：开启，默认为开启
+        :type Status: int
+        """
+        self._RuleId = None
+        self._Name = None
+        self._Domain = None
+        self._Strategies = None
+        self._Ids = None
+        self._Type = None
+        self._JobType = None
+        self._JobDateTime = None
+        self._ExpireTime = None
+        self._Status = None
+
+    @property
+    def RuleId(self):
+        """规则ID
+        :rtype: int
+        """
+        return self._RuleId
+
+    @RuleId.setter
+    def RuleId(self, RuleId):
+        self._RuleId = RuleId
+
+    @property
+    def Name(self):
+        """规则名称
+        :rtype: str
+        """
+        return self._Name
+
+    @Name.setter
+    def Name(self, Name):
+        self._Name = Name
+
+    @property
+    def Domain(self):
+        """域名
+        :rtype: str
+        """
+        return self._Domain
+
+    @Domain.setter
+    def Domain(self, Domain):
+        self._Domain = Domain
+
+    @property
+    def Strategies(self):
+        """规则匹配策略列表
+        :rtype: list of Strategy
+        """
+        return self._Strategies
+
+    @Strategies.setter
+    def Strategies(self, Strategies):
+        self._Strategies = Strategies
+
+    @property
+    def Ids(self):
+        """加白的规则ID列表
+        :rtype: list of int non-negative
+        """
+        return self._Ids
+
+    @Ids.setter
+    def Ids(self, Ids):
+        self._Ids = Ids
+
+    @property
+    def Type(self):
+        """加白的类型，0:按照特定规则ID加白, 1:按照规则类型加白
+        :rtype: int
+        """
+        return self._Type
+
+    @Type.setter
+    def Type(self, Type):
+        self._Type = Type
+
+    @property
+    def JobType(self):
+        """规则执行的方式，TimedJob为定时执行，CronJob为周期执行
+        :rtype: str
+        """
+        return self._JobType
+
+    @JobType.setter
+    def JobType(self, JobType):
+        self._JobType = JobType
+
+    @property
+    def JobDateTime(self):
+        """定时任务配置
+        :rtype: :class:`tencentcloud.waf.v20180125.models.JobDateTime`
+        """
+        return self._JobDateTime
+
+    @JobDateTime.setter
+    def JobDateTime(self, JobDateTime):
+        self._JobDateTime = JobDateTime
+
+    @property
+    def ExpireTime(self):
+        """如果没有设置JobDateTime字段则用此字段，0表示永久生效，其它表示定时生效的截止时间（单位为秒）
+        :rtype: int
+        """
+        return self._ExpireTime
+
+    @ExpireTime.setter
+    def ExpireTime(self, ExpireTime):
+        self._ExpireTime = ExpireTime
+
+    @property
+    def Status(self):
+        """规则状态，0：关闭、1：开启，默认为开启
+        :rtype: int
+        """
+        return self._Status
+
+    @Status.setter
+    def Status(self, Status):
+        self._Status = Status
+
+
+    def _deserialize(self, params):
+        self._RuleId = params.get("RuleId")
+        self._Name = params.get("Name")
+        self._Domain = params.get("Domain")
+        if params.get("Strategies") is not None:
+            self._Strategies = []
+            for item in params.get("Strategies"):
+                obj = Strategy()
+                obj._deserialize(item)
+                self._Strategies.append(obj)
+        self._Ids = params.get("Ids")
+        self._Type = params.get("Type")
+        self._JobType = params.get("JobType")
+        if params.get("JobDateTime") is not None:
+            self._JobDateTime = JobDateTime()
+            self._JobDateTime._deserialize(params.get("JobDateTime"))
+        self._ExpireTime = params.get("ExpireTime")
+        self._Status = params.get("Status")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class ModifyOwaspWhiteRuleResponse(AbstractModel):
+    """ModifyOwaspWhiteRule返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._RequestId = None
+
+    @property
+    def RequestId(self):
+        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._RequestId = params.get("RequestId")
+
+
+class ModifyProtectionStatusRequest(AbstractModel):
+    """ModifyProtectionStatus请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Domain: 域名
+        :type Domain: str
+        :param _Status: 1：开启WAF开关，0：关闭WAF开关
+        :type Status: int
+        :param _Edition: WAF的版本，clb-waf代表负载均衡WAF、sparta-waf代表SaaS WAF，默认是sparta-waf。
+        :type Edition: str
+        """
+        self._Domain = None
+        self._Status = None
+        self._Edition = None
+
+    @property
+    def Domain(self):
+        """域名
+        :rtype: str
+        """
+        return self._Domain
+
+    @Domain.setter
+    def Domain(self, Domain):
+        self._Domain = Domain
+
+    @property
+    def Status(self):
+        """1：开启WAF开关，0：关闭WAF开关
+        :rtype: int
+        """
+        return self._Status
+
+    @Status.setter
+    def Status(self, Status):
+        self._Status = Status
+
+    @property
+    def Edition(self):
+        """WAF的版本，clb-waf代表负载均衡WAF、sparta-waf代表SaaS WAF，默认是sparta-waf。
+        :rtype: str
+        """
+        return self._Edition
+
+    @Edition.setter
+    def Edition(self, Edition):
+        self._Edition = Edition
+
+
+    def _deserialize(self, params):
+        self._Domain = params.get("Domain")
+        self._Status = params.get("Status")
+        self._Edition = params.get("Edition")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class ModifyProtectionStatusResponse(AbstractModel):
+    """ModifyProtectionStatus返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._RequestId = None
+
+    @property
+    def RequestId(self):
+        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._RequestId = params.get("RequestId")
+
+
+class ModifySpartaProtectionModeRequest(AbstractModel):
+    """ModifySpartaProtectionMode请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Domain: 域名
+        :type Domain: str
+        :param _Mode: 防护状态：
+10：规则观察&&AI关闭模式，11：规则观察&&AI观察模式，12：规则观察&&AI拦截模式
+20：规则拦截&&AI关闭模式，21：规则拦截&&AI观察模式，22：规则拦截&&AI拦截模式
+        :type Mode: int
+        :param _Edition: WAF的版本，clb-waf代表负载均衡WAF、sparta-waf代表SaaS WAF，默认是sparta-waf。
+        :type Edition: str
+        :param _Type: 0是修改规则引擎状态，1是修改AI的状态
+        :type Type: int
+        :param _InstanceID: 实例id
+        :type InstanceID: str
+        """
+        self._Domain = None
+        self._Mode = None
+        self._Edition = None
+        self._Type = None
+        self._InstanceID = None
+
+    @property
+    def Domain(self):
+        """域名
+        :rtype: str
+        """
+        return self._Domain
+
+    @Domain.setter
+    def Domain(self, Domain):
+        self._Domain = Domain
+
+    @property
+    def Mode(self):
+        """防护状态：
+10：规则观察&&AI关闭模式，11：规则观察&&AI观察模式，12：规则观察&&AI拦截模式
+20：规则拦截&&AI关闭模式，21：规则拦截&&AI观察模式，22：规则拦截&&AI拦截模式
+        :rtype: int
+        """
+        return self._Mode
+
+    @Mode.setter
+    def Mode(self, Mode):
+        self._Mode = Mode
+
+    @property
+    def Edition(self):
+        """WAF的版本，clb-waf代表负载均衡WAF、sparta-waf代表SaaS WAF，默认是sparta-waf。
+        :rtype: str
+        """
+        return self._Edition
+
+    @Edition.setter
+    def Edition(self, Edition):
+        self._Edition = Edition
+
+    @property
+    def Type(self):
+        """0是修改规则引擎状态，1是修改AI的状态
+        :rtype: int
+        """
+        return self._Type
+
+    @Type.setter
+    def Type(self, Type):
+        self._Type = Type
+
+    @property
+    def InstanceID(self):
+        """实例id
+        :rtype: str
+        """
+        return self._InstanceID
+
+    @InstanceID.setter
+    def InstanceID(self, InstanceID):
+        self._InstanceID = InstanceID
+
+
+    def _deserialize(self, params):
+        self._Domain = params.get("Domain")
+        self._Mode = params.get("Mode")
+        self._Edition = params.get("Edition")
+        self._Type = params.get("Type")
+        self._InstanceID = params.get("InstanceID")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class ModifySpartaProtectionModeResponse(AbstractModel):
+    """ModifySpartaProtectionMode返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._RequestId = None
+
+    @property
+    def RequestId(self):
+        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._RequestId = params.get("RequestId")
+
+
+class ModifySpartaProtectionRequest(AbstractModel):
+    """ModifySpartaProtection请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Domain: 域名
+        :type Domain: str
+        :param _DomainId: 必填项。域名唯一ID
+        :type DomainId: str
+        :param _InstanceID: 必填项。域名所属实例id
+        :type InstanceID: str
+        :param _CertType: 证书类型。0：仅配置HTTP监听端口，没有证书1：证书来源为自有证书2：证书来源为托管证书
+        :type CertType: int
         :param _Cert: CertType为1时，需要填充此参数，表示自有证书的证书链
         :type Cert: str
         :param _PrivateKey: CertType为1时，需要填充此参数，表示自有证书的私钥
@@ -37280,79 +38108,394 @@ class ModifyWafThreatenIntelligenceRequest(AbstractModel):
         
 
 
-class ModifyWafThreatenIntelligenceResponse(AbstractModel):
-    """ModifyWafThreatenIntelligence返回参数结构体
+class ModifyWafThreatenIntelligenceResponse(AbstractModel):
+    """ModifyWafThreatenIntelligence返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _WafThreatenIntelligenceDetails: 当前WAF威胁情报封禁模块详情
+        :type WafThreatenIntelligenceDetails: :class:`tencentcloud.waf.v20180125.models.WafThreatenIntelligenceDetails`
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._WafThreatenIntelligenceDetails = None
+        self._RequestId = None
+
+    @property
+    def WafThreatenIntelligenceDetails(self):
+        """当前WAF威胁情报封禁模块详情
+        :rtype: :class:`tencentcloud.waf.v20180125.models.WafThreatenIntelligenceDetails`
+        """
+        return self._WafThreatenIntelligenceDetails
+
+    @WafThreatenIntelligenceDetails.setter
+    def WafThreatenIntelligenceDetails(self, WafThreatenIntelligenceDetails):
+        self._WafThreatenIntelligenceDetails = WafThreatenIntelligenceDetails
+
+    @property
+    def RequestId(self):
+        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        if params.get("WafThreatenIntelligenceDetails") is not None:
+            self._WafThreatenIntelligenceDetails = WafThreatenIntelligenceDetails()
+            self._WafThreatenIntelligenceDetails._deserialize(params.get("WafThreatenIntelligenceDetails"))
+        self._RequestId = params.get("RequestId")
+
+
+class ModifyWebshellStatusRequest(AbstractModel):
+    """ModifyWebshellStatus请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Webshell: 域名webshell状态
+        :type Webshell: :class:`tencentcloud.waf.v20180125.models.WebshellStatus`
+        """
+        self._Webshell = None
+
+    @property
+    def Webshell(self):
+        """域名webshell状态
+        :rtype: :class:`tencentcloud.waf.v20180125.models.WebshellStatus`
+        """
+        return self._Webshell
+
+    @Webshell.setter
+    def Webshell(self, Webshell):
+        self._Webshell = Webshell
+
+
+    def _deserialize(self, params):
+        if params.get("Webshell") is not None:
+            self._Webshell = WebshellStatus()
+            self._Webshell._deserialize(params.get("Webshell"))
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class ModifyWebshellStatusResponse(AbstractModel):
+    """ModifyWebshellStatus返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Success: 成功的状态码，需要JSON解码后再使用，返回的格式是{"域名":"状态"}，成功的状态码为Success，其它的为失败的状态码（yunapi定义的错误码）
+        :type Success: :class:`tencentcloud.waf.v20180125.models.ResponseCode`
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._Success = None
+        self._RequestId = None
+
+    @property
+    def Success(self):
+        """成功的状态码，需要JSON解码后再使用，返回的格式是{"域名":"状态"}，成功的状态码为Success，其它的为失败的状态码（yunapi定义的错误码）
+        :rtype: :class:`tencentcloud.waf.v20180125.models.ResponseCode`
+        """
+        return self._Success
+
+    @Success.setter
+    def Success(self, Success):
+        self._Success = Success
+
+    @property
+    def RequestId(self):
+        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        if params.get("Success") is not None:
+            self._Success = ResponseCode()
+            self._Success._deserialize(params.get("Success"))
+        self._RequestId = params.get("RequestId")
+
+
+class NetworkConfig(AbstractModel):
+    """实例的网络配置
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _AntiDDosEip: 高防EIP地址
+        :type AntiDDosEip: str
+        :param _AntiDDosEipStatus: 高防EIP绑定状态。
+0：解绑
+1：绑定
+        :type AntiDDosEipStatus: int
+        :param _VipStatus: WAF原生VIP绑定状态。
+0：解绑
+1：绑定
+        :type VipStatus: int
+        """
+        self._AntiDDosEip = None
+        self._AntiDDosEipStatus = None
+        self._VipStatus = None
+
+    @property
+    def AntiDDosEip(self):
+        """高防EIP地址
+        :rtype: str
+        """
+        return self._AntiDDosEip
+
+    @AntiDDosEip.setter
+    def AntiDDosEip(self, AntiDDosEip):
+        self._AntiDDosEip = AntiDDosEip
+
+    @property
+    def AntiDDosEipStatus(self):
+        """高防EIP绑定状态。
+0：解绑
+1：绑定
+        :rtype: int
+        """
+        return self._AntiDDosEipStatus
+
+    @AntiDDosEipStatus.setter
+    def AntiDDosEipStatus(self, AntiDDosEipStatus):
+        self._AntiDDosEipStatus = AntiDDosEipStatus
+
+    @property
+    def VipStatus(self):
+        """WAF原生VIP绑定状态。
+0：解绑
+1：绑定
+        :rtype: int
+        """
+        return self._VipStatus
+
+    @VipStatus.setter
+    def VipStatus(self, VipStatus):
+        self._VipStatus = VipStatus
+
+
+    def _deserialize(self, params):
+        self._AntiDDosEip = params.get("AntiDDosEip")
+        self._AntiDDosEipStatus = params.get("AntiDDosEipStatus")
+        self._VipStatus = params.get("VipStatus")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class OwaspRule(AbstractModel):
+    """Owasp规则
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _RuleId: 规则ID
+        :type RuleId: int
+        :param _Description: 规则描述
+        :type Description: str
+        :param _Status: 规则开关，0：关闭、1：开启、2：只观察
+        :type Status: int
+        :param _Level: 规则的防护等级，100：宽松、200：正常、300：严格、400：超严格
+        :type Level: int
+        :param _VulLevel: 威胁等级，0：未知，100：低危，200：中危，300：高危，400：危急
+        :type VulLevel: int
+        :param _CveID: CVE ID
+        :type CveID: str
+        :param _TypeId: 规则所属的类型ID
+        :type TypeId: int
+        :param _CreateTime: 创建时间
+        :type CreateTime: str
+        :param _ModifyTime: 更新时间
+        :type ModifyTime: str
+        :param _Locked: 是否被锁定
+        :type Locked: int
+        :param _Reason: 修改原因
+0：无(兼容记录为空)
+1：业务自身特性误报避免
+2：规则误报上报
+3：核心业务规则灰度
+4：其它
+        :type Reason: int
+        """
+        self._RuleId = None
+        self._Description = None
+        self._Status = None
+        self._Level = None
+        self._VulLevel = None
+        self._CveID = None
+        self._TypeId = None
+        self._CreateTime = None
+        self._ModifyTime = None
+        self._Locked = None
+        self._Reason = None
+
+    @property
+    def RuleId(self):
+        """规则ID
+        :rtype: int
+        """
+        return self._RuleId
+
+    @RuleId.setter
+    def RuleId(self, RuleId):
+        self._RuleId = RuleId
+
+    @property
+    def Description(self):
+        """规则描述
+        :rtype: str
+        """
+        return self._Description
+
+    @Description.setter
+    def Description(self, Description):
+        self._Description = Description
+
+    @property
+    def Status(self):
+        """规则开关，0：关闭、1：开启、2：只观察
+        :rtype: int
+        """
+        return self._Status
 
-    """
+    @Status.setter
+    def Status(self, Status):
+        self._Status = Status
 
-    def __init__(self):
-        r"""
-        :param _WafThreatenIntelligenceDetails: 当前WAF威胁情报封禁模块详情
-        :type WafThreatenIntelligenceDetails: :class:`tencentcloud.waf.v20180125.models.WafThreatenIntelligenceDetails`
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
+    @property
+    def Level(self):
+        """规则的防护等级，100：宽松、200：正常、300：严格、400：超严格
+        :rtype: int
         """
-        self._WafThreatenIntelligenceDetails = None
-        self._RequestId = None
+        return self._Level
+
+    @Level.setter
+    def Level(self, Level):
+        self._Level = Level
 
     @property
-    def WafThreatenIntelligenceDetails(self):
-        """当前WAF威胁情报封禁模块详情
-        :rtype: :class:`tencentcloud.waf.v20180125.models.WafThreatenIntelligenceDetails`
+    def VulLevel(self):
+        """威胁等级，0：未知，100：低危，200：中危，300：高危，400：危急
+        :rtype: int
         """
-        return self._WafThreatenIntelligenceDetails
+        return self._VulLevel
 
-    @WafThreatenIntelligenceDetails.setter
-    def WafThreatenIntelligenceDetails(self, WafThreatenIntelligenceDetails):
-        self._WafThreatenIntelligenceDetails = WafThreatenIntelligenceDetails
+    @VulLevel.setter
+    def VulLevel(self, VulLevel):
+        self._VulLevel = VulLevel
 
     @property
-    def RequestId(self):
-        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+    def CveID(self):
+        """CVE ID
         :rtype: str
         """
-        return self._RequestId
+        return self._CveID
 
-    @RequestId.setter
-    def RequestId(self, RequestId):
-        self._RequestId = RequestId
+    @CveID.setter
+    def CveID(self, CveID):
+        self._CveID = CveID
 
+    @property
+    def TypeId(self):
+        """规则所属的类型ID
+        :rtype: int
+        """
+        return self._TypeId
 
-    def _deserialize(self, params):
-        if params.get("WafThreatenIntelligenceDetails") is not None:
-            self._WafThreatenIntelligenceDetails = WafThreatenIntelligenceDetails()
-            self._WafThreatenIntelligenceDetails._deserialize(params.get("WafThreatenIntelligenceDetails"))
-        self._RequestId = params.get("RequestId")
+    @TypeId.setter
+    def TypeId(self, TypeId):
+        self._TypeId = TypeId
 
+    @property
+    def CreateTime(self):
+        """创建时间
+        :rtype: str
+        """
+        return self._CreateTime
 
-class ModifyWebshellStatusRequest(AbstractModel):
-    """ModifyWebshellStatus请求参数结构体
+    @CreateTime.setter
+    def CreateTime(self, CreateTime):
+        self._CreateTime = CreateTime
 
-    """
+    @property
+    def ModifyTime(self):
+        """更新时间
+        :rtype: str
+        """
+        return self._ModifyTime
 
-    def __init__(self):
-        r"""
-        :param _Webshell: 域名webshell状态
-        :type Webshell: :class:`tencentcloud.waf.v20180125.models.WebshellStatus`
+    @ModifyTime.setter
+    def ModifyTime(self, ModifyTime):
+        self._ModifyTime = ModifyTime
+
+    @property
+    def Locked(self):
+        """是否被锁定
+        :rtype: int
         """
-        self._Webshell = None
+        return self._Locked
+
+    @Locked.setter
+    def Locked(self, Locked):
+        self._Locked = Locked
 
     @property
-    def Webshell(self):
-        """域名webshell状态
-        :rtype: :class:`tencentcloud.waf.v20180125.models.WebshellStatus`
+    def Reason(self):
+        """修改原因
+0：无(兼容记录为空)
+1：业务自身特性误报避免
+2：规则误报上报
+3：核心业务规则灰度
+4：其它
+        :rtype: int
         """
-        return self._Webshell
+        return self._Reason
 
-    @Webshell.setter
-    def Webshell(self, Webshell):
-        self._Webshell = Webshell
+    @Reason.setter
+    def Reason(self, Reason):
+        self._Reason = Reason
 
 
     def _deserialize(self, params):
-        if params.get("Webshell") is not None:
-            self._Webshell = WebshellStatus()
-            self._Webshell._deserialize(params.get("Webshell"))
+        self._RuleId = params.get("RuleId")
+        self._Description = params.get("Description")
+        self._Status = params.get("Status")
+        self._Level = params.get("Level")
+        self._VulLevel = params.get("VulLevel")
+        self._CveID = params.get("CveID")
+        self._TypeId = params.get("TypeId")
+        self._CreateTime = params.get("CreateTime")
+        self._ModifyTime = params.get("ModifyTime")
+        self._Locked = params.get("Locked")
+        self._Reason = params.get("Reason")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -37363,115 +38506,154 @@ class ModifyWebshellStatusRequest(AbstractModel):
         
 
 
-class ModifyWebshellStatusResponse(AbstractModel):
-    """ModifyWebshellStatus返回参数结构体
+class OwaspRuleType(AbstractModel):
+    """Owasp规则类型
 
     """
 
     def __init__(self):
         r"""
-        :param _Success: 成功的状态码，需要JSON解码后再使用，返回的格式是{"域名":"状态"}，成功的状态码为Success，其它的为失败的状态码（yunapi定义的错误码）
-        :type Success: :class:`tencentcloud.waf.v20180125.models.ResponseCode`
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
+        :param _TypeId: 类型ID
+        :type TypeId: int
+        :param _TypeName: 类型名称
+        :type TypeName: str
+        :param _Description: 类型描述
+
+        :type Description: str
+        :param _Classification: 类型分类
+        :type Classification: str
+        :param _Action: 规则类型的防护模式，0：观察、1：拦截
+        :type Action: int
+        :param _Level: 规则类型的防护等级，100：宽松、200：正常、300：严格、400：超严格
+        :type Level: int
+        :param _Status: 规则类型的开关状态，0：关闭、1：开启
+        :type Status: int
+        :param _TotalRule: 规则类型下的所有规则总是
+        :type TotalRule: int
+        :param _ActiveRule: 规则类型下的启用的规则总数
+        :type ActiveRule: int
         """
-        self._Success = None
-        self._RequestId = None
+        self._TypeId = None
+        self._TypeName = None
+        self._Description = None
+        self._Classification = None
+        self._Action = None
+        self._Level = None
+        self._Status = None
+        self._TotalRule = None
+        self._ActiveRule = None
 
     @property
-    def Success(self):
-        """成功的状态码，需要JSON解码后再使用，返回的格式是{"域名":"状态"}，成功的状态码为Success，其它的为失败的状态码（yunapi定义的错误码）
-        :rtype: :class:`tencentcloud.waf.v20180125.models.ResponseCode`
+    def TypeId(self):
+        """类型ID
+        :rtype: int
         """
-        return self._Success
+        return self._TypeId
 
-    @Success.setter
-    def Success(self, Success):
-        self._Success = Success
+    @TypeId.setter
+    def TypeId(self, TypeId):
+        self._TypeId = TypeId
 
     @property
-    def RequestId(self):
-        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+    def TypeName(self):
+        """类型名称
         :rtype: str
         """
-        return self._RequestId
+        return self._TypeName
 
-    @RequestId.setter
-    def RequestId(self, RequestId):
-        self._RequestId = RequestId
+    @TypeName.setter
+    def TypeName(self, TypeName):
+        self._TypeName = TypeName
 
+    @property
+    def Description(self):
+        """类型描述
 
-    def _deserialize(self, params):
-        if params.get("Success") is not None:
-            self._Success = ResponseCode()
-            self._Success._deserialize(params.get("Success"))
-        self._RequestId = params.get("RequestId")
+        :rtype: str
+        """
+        return self._Description
 
+    @Description.setter
+    def Description(self, Description):
+        self._Description = Description
 
-class NetworkConfig(AbstractModel):
-    """实例的网络配置
+    @property
+    def Classification(self):
+        """类型分类
+        :rtype: str
+        """
+        return self._Classification
 
-    """
+    @Classification.setter
+    def Classification(self, Classification):
+        self._Classification = Classification
 
-    def __init__(self):
-        r"""
-        :param _AntiDDosEip: 高防EIP地址
-        :type AntiDDosEip: str
-        :param _AntiDDosEipStatus: 高防EIP绑定状态。
-0：解绑
-1：绑定
-        :type AntiDDosEipStatus: int
-        :param _VipStatus: WAF原生VIP绑定状态。
-0：解绑
-1：绑定
-        :type VipStatus: int
+    @property
+    def Action(self):
+        """规则类型的防护模式，0：观察、1：拦截
+        :rtype: int
         """
-        self._AntiDDosEip = None
-        self._AntiDDosEipStatus = None
-        self._VipStatus = None
+        return self._Action
+
+    @Action.setter
+    def Action(self, Action):
+        self._Action = Action
 
     @property
-    def AntiDDosEip(self):
-        """高防EIP地址
-        :rtype: str
+    def Level(self):
+        """规则类型的防护等级，100：宽松、200：正常、300：严格、400：超严格
+        :rtype: int
         """
-        return self._AntiDDosEip
+        return self._Level
 
-    @AntiDDosEip.setter
-    def AntiDDosEip(self, AntiDDosEip):
-        self._AntiDDosEip = AntiDDosEip
+    @Level.setter
+    def Level(self, Level):
+        self._Level = Level
 
     @property
-    def AntiDDosEipStatus(self):
-        """高防EIP绑定状态。
-0：解绑
-1：绑定
+    def Status(self):
+        """规则类型的开关状态，0：关闭、1：开启
         :rtype: int
         """
-        return self._AntiDDosEipStatus
+        return self._Status
 
-    @AntiDDosEipStatus.setter
-    def AntiDDosEipStatus(self, AntiDDosEipStatus):
-        self._AntiDDosEipStatus = AntiDDosEipStatus
+    @Status.setter
+    def Status(self, Status):
+        self._Status = Status
 
     @property
-    def VipStatus(self):
-        """WAF原生VIP绑定状态。
-0：解绑
-1：绑定
+    def TotalRule(self):
+        """规则类型下的所有规则总是
         :rtype: int
         """
-        return self._VipStatus
+        return self._TotalRule
 
-    @VipStatus.setter
-    def VipStatus(self, VipStatus):
-        self._VipStatus = VipStatus
+    @TotalRule.setter
+    def TotalRule(self, TotalRule):
+        self._TotalRule = TotalRule
+
+    @property
+    def ActiveRule(self):
+        """规则类型下的启用的规则总数
+        :rtype: int
+        """
+        return self._ActiveRule
+
+    @ActiveRule.setter
+    def ActiveRule(self, ActiveRule):
+        self._ActiveRule = ActiveRule
 
 
     def _deserialize(self, params):
-        self._AntiDDosEip = params.get("AntiDDosEip")
-        self._AntiDDosEipStatus = params.get("AntiDDosEipStatus")
-        self._VipStatus = params.get("VipStatus")
+        self._TypeId = params.get("TypeId")
+        self._TypeName = params.get("TypeName")
+        self._Description = params.get("Description")
+        self._Classification = params.get("Classification")
+        self._Action = params.get("Action")
+        self._Level = params.get("Level")
+        self._Status = params.get("Status")
+        self._TotalRule = params.get("TotalRule")
+        self._ActiveRule = params.get("ActiveRule")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]