tencentcloud-sdk-python 3.0.1273__py2.py3-none-any.whl → 3.0.1275__py2.py3-none-any.whl

tencentcloud/privatedns/v20201028/models.py

@@ -595,137 +595,34 @@ class AuditLogInfo(AbstractModel):
         
 
 
-class CreateEndPointAndEndPointServiceRequest(AbstractModel):
-    """CreateEndPointAndEndPointService请求参数结构体
+class CreatePrivateDNSAccountRequest(AbstractModel):
+    """CreatePrivateDNSAccount请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _VpcId: VPC实例ID
-        :type VpcId: str
-        :param _AutoAcceptFlag: 是否自动接受
-        :type AutoAcceptFlag: bool
-        :param _ServiceInstanceId: 后端服务ID
-        :type ServiceInstanceId: str
-        :param _EndPointName: 终端节点名称
-        :type EndPointName: str
-        :param _EndPointRegion: 终端节点地域，必须要和终端节点服务所属地域一致
-        :type EndPointRegion: str
-        :param _EndPointServiceName: 终端节点服务名称
-        :type EndPointServiceName: str
-        :param _ServiceType: 挂载的PAAS服务类型，CLB,CDB,CRS
-        :type ServiceType: str
-        :param _IpNum: 终端节点ip数量
-        :type IpNum: int
-        """
-        self._VpcId = None
-        self._AutoAcceptFlag = None
-        self._ServiceInstanceId = None
-        self._EndPointName = None
-        self._EndPointRegion = None
-        self._EndPointServiceName = None
-        self._ServiceType = None
-        self._IpNum = None
-
-    @property
-    def VpcId(self):
-        """VPC实例ID
-        :rtype: str
-        """
-        return self._VpcId
-
-    @VpcId.setter
-    def VpcId(self, VpcId):
-        self._VpcId = VpcId
-
-    @property
-    def AutoAcceptFlag(self):
-        """是否自动接受
-        :rtype: bool
-        """
-        return self._AutoAcceptFlag
-
-    @AutoAcceptFlag.setter
-    def AutoAcceptFlag(self, AutoAcceptFlag):
-        self._AutoAcceptFlag = AutoAcceptFlag
-
-    @property
-    def ServiceInstanceId(self):
-        """后端服务ID
-        :rtype: str
-        """
-        return self._ServiceInstanceId
-
-    @ServiceInstanceId.setter
-    def ServiceInstanceId(self, ServiceInstanceId):
-        self._ServiceInstanceId = ServiceInstanceId
-
-    @property
-    def EndPointName(self):
-        """终端节点名称
-        :rtype: str
-        """
-        return self._EndPointName
-
-    @EndPointName.setter
-    def EndPointName(self, EndPointName):
-        self._EndPointName = EndPointName
-
-    @property
-    def EndPointRegion(self):
-        """终端节点地域，必须要和终端节点服务所属地域一致
-        :rtype: str
-        """
-        return self._EndPointRegion
-
-    @EndPointRegion.setter
-    def EndPointRegion(self, EndPointRegion):
-        self._EndPointRegion = EndPointRegion
-
-    @property
-    def EndPointServiceName(self):
-        """终端节点服务名称
-        :rtype: str
-        """
-        return self._EndPointServiceName
-
-    @EndPointServiceName.setter
-    def EndPointServiceName(self, EndPointServiceName):
-        self._EndPointServiceName = EndPointServiceName
-
-    @property
-    def ServiceType(self):
-        """挂载的PAAS服务类型，CLB,CDB,CRS
-        :rtype: str
+        :param _Account: 私有域解析账号
+        :type Account: :class:`tencentcloud.privatedns.v20201028.models.PrivateDNSAccount`
         """
-        return self._ServiceType
-
-    @ServiceType.setter
-    def ServiceType(self, ServiceType):
-        self._ServiceType = ServiceType
+        self._Account = None
 
     @property
-    def IpNum(self):
-        """终端节点ip数量
-        :rtype: int
+    def Account(self):
+        """私有域解析账号
+        :rtype: :class:`tencentcloud.privatedns.v20201028.models.PrivateDNSAccount`
         """
-        return self._IpNum
+        return self._Account
 
-    @IpNum.setter
-    def IpNum(self, IpNum):
-        self._IpNum = IpNum
+    @Account.setter
+    def Account(self, Account):
+        self._Account = Account
 
 
     def _deserialize(self, params):
-        self._VpcId = params.get("VpcId")
-        self._AutoAcceptFlag = params.get("AutoAcceptFlag")
-        self._ServiceInstanceId = params.get("ServiceInstanceId")
-        self._EndPointName = params.get("EndPointName")
-        self._EndPointRegion = params.get("EndPointRegion")
-        self._EndPointServiceName = params.get("EndPointServiceName")
-        self._ServiceType = params.get("ServiceType")
-        self._IpNum = params.get("IpNum")
+        if params.get("Account") is not None:
+            self._Account = PrivateDNSAccount()
+            self._Account._deserialize(params.get("Account"))
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -736,74 +633,18 @@ class CreateEndPointAndEndPointServiceRequest(AbstractModel):
         
 
 
-class CreateEndPointAndEndPointServiceResponse(AbstractModel):
-    """CreateEndPointAndEndPointService返回参数结构体
+class CreatePrivateDNSAccountResponse(AbstractModel):
+    """CreatePrivateDNSAccount返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _EndPointId: 终端节点id
-        :type EndPointId: str
-        :param _EndPointName: 终端节点名
-        :type EndPointName: str
-        :param _EndPointServiceId: 终端节点服务ID
-        :type EndPointServiceId: str
-        :param _EndPointVipSet: 终端节点的IP列表
-        :type EndPointVipSet: list of str
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._EndPointId = None
-        self._EndPointName = None
-        self._EndPointServiceId = None
-        self._EndPointVipSet = None
         self._RequestId = None
 
-    @property
-    def EndPointId(self):
-        """终端节点id
-        :rtype: str
-        """
-        return self._EndPointId
-
-    @EndPointId.setter
-    def EndPointId(self, EndPointId):
-        self._EndPointId = EndPointId
-
-    @property
-    def EndPointName(self):
-        """终端节点名
-        :rtype: str
-        """
-        return self._EndPointName
-
-    @EndPointName.setter
-    def EndPointName(self, EndPointName):
-        self._EndPointName = EndPointName
-
-    @property
-    def EndPointServiceId(self):
-        """终端节点服务ID
-        :rtype: str
-        """
-        return self._EndPointServiceId
-
-    @EndPointServiceId.setter
-    def EndPointServiceId(self, EndPointServiceId):
-        self._EndPointServiceId = EndPointServiceId
-
-    @property
-    def EndPointVipSet(self):
-        """终端节点的IP列表
-        :rtype: list of str
-        """
-        return self._EndPointVipSet
-
-    @EndPointVipSet.setter
-    def EndPointVipSet(self, EndPointVipSet):
-        self._EndPointVipSet = EndPointVipSet
-
     @property
     def RequestId(self):
         """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
@@ -817,84 +658,125 @@ class CreateEndPointAndEndPointServiceResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._EndPointId = params.get("EndPointId")
-        self._EndPointName = params.get("EndPointName")
-        self._EndPointServiceId = params.get("EndPointServiceId")
-        self._EndPointVipSet = params.get("EndPointVipSet")
         self._RequestId = params.get("RequestId")
 
 
-class CreateEndPointRequest(AbstractModel):
-    """CreateEndPoint请求参数结构体
+class CreatePrivateZoneRecordRequest(AbstractModel):
+    """CreatePrivateZoneRecord请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _EndPointName: 终端节点名称
-        :type EndPointName: str
-        :param _EndPointServiceId: 终端节点服务ID（vpc终端节点服务ID）
-        :type EndPointServiceId: str
-        :param _EndPointRegion: 终端节点地域，必须要和终端节点服务所属地域一致
-        :type EndPointRegion: str
-        :param _IpNum: 终端节点ip数量
-        :type IpNum: int
+        :param _ZoneId: 私有域ID
+        :type ZoneId: str
+        :param _RecordType: 记录类型，可选的记录类型为："A", "AAAA", "CNAME", "MX", "TXT", "PTR"
+        :type RecordType: str
+        :param _SubDomain: 子域名，例如 "www", "m", "@"
+        :type SubDomain: str
+        :param _RecordValue: 记录值，例如 IP：192.168.10.2，CNAME：cname.qcloud.com.，MX：mail.qcloud.com.
+        :type RecordValue: str
+        :param _Weight: 记录权重，值为1-100
+        :type Weight: int
+        :param _MX: MX优先级：记录类型为MX时必填。取值范围：5,10,15,20,30,40,50
+        :type MX: int
+        :param _TTL: 记录缓存时间，数值越小生效越快，取值1-86400s, 默认 600
+        :type TTL: int
         """
-        self._EndPointName = None
-        self._EndPointServiceId = None
-        self._EndPointRegion = None
-        self._IpNum = None
+        self._ZoneId = None
+        self._RecordType = None
+        self._SubDomain = None
+        self._RecordValue = None
+        self._Weight = None
+        self._MX = None
+        self._TTL = None
 
     @property
-    def EndPointName(self):
-        """终端节点名称
+    def ZoneId(self):
+        """私有域ID
         :rtype: str
         """
-        return self._EndPointName
+        return self._ZoneId
 
-    @EndPointName.setter
-    def EndPointName(self, EndPointName):
-        self._EndPointName = EndPointName
+    @ZoneId.setter
+    def ZoneId(self, ZoneId):
+        self._ZoneId = ZoneId
+
+    @property
+    def RecordType(self):
+        """记录类型，可选的记录类型为："A", "AAAA", "CNAME", "MX", "TXT", "PTR"
+        :rtype: str
+        """
+        return self._RecordType
+
+    @RecordType.setter
+    def RecordType(self, RecordType):
+        self._RecordType = RecordType
 
     @property
-    def EndPointServiceId(self):
-        """终端节点服务ID（vpc终端节点服务ID）
+    def SubDomain(self):
+        """子域名，例如 "www", "m", "@"
         :rtype: str
         """
-        return self._EndPointServiceId
+        return self._SubDomain
 
-    @EndPointServiceId.setter
-    def EndPointServiceId(self, EndPointServiceId):
-        self._EndPointServiceId = EndPointServiceId
+    @SubDomain.setter
+    def SubDomain(self, SubDomain):
+        self._SubDomain = SubDomain
 
     @property
-    def EndPointRegion(self):
-        """终端节点地域，必须要和终端节点服务所属地域一致
+    def RecordValue(self):
+        """记录值，例如 IP：192.168.10.2，CNAME：cname.qcloud.com.，MX：mail.qcloud.com.
         :rtype: str
         """
-        return self._EndPointRegion
+        return self._RecordValue
+
+    @RecordValue.setter
+    def RecordValue(self, RecordValue):
+        self._RecordValue = RecordValue
+
+    @property
+    def Weight(self):
+        """记录权重，值为1-100
+        :rtype: int
+        """
+        return self._Weight
+
+    @Weight.setter
+    def Weight(self, Weight):
+        self._Weight = Weight
+
+    @property
+    def MX(self):
+        """MX优先级：记录类型为MX时必填。取值范围：5,10,15,20,30,40,50
+        :rtype: int
+        """
+        return self._MX
 
-    @EndPointRegion.setter
-    def EndPointRegion(self, EndPointRegion):
-        self._EndPointRegion = EndPointRegion
+    @MX.setter
+    def MX(self, MX):
+        self._MX = MX
 
     @property
-    def IpNum(self):
-        """终端节点ip数量
+    def TTL(self):
+        """记录缓存时间，数值越小生效越快，取值1-86400s, 默认 600
         :rtype: int
         """
-        return self._IpNum
+        return self._TTL
 
-    @IpNum.setter
-    def IpNum(self, IpNum):
-        self._IpNum = IpNum
+    @TTL.setter
+    def TTL(self, TTL):
+        self._TTL = TTL
 
 
     def _deserialize(self, params):
-        self._EndPointName = params.get("EndPointName")
-        self._EndPointServiceId = params.get("EndPointServiceId")
-        self._EndPointRegion = params.get("EndPointRegion")
-        self._IpNum = params.get("IpNum")
+        self._ZoneId = params.get("ZoneId")
+        self._RecordType = params.get("RecordType")
+        self._SubDomain = params.get("SubDomain")
+        self._RecordValue = params.get("RecordValue")
+        self._Weight = params.get("Weight")
+        self._MX = params.get("MX")
+        self._TTL = params.get("TTL")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -905,73 +787,31 @@ class CreateEndPointRequest(AbstractModel):
         
 
 
-class CreateEndPointResponse(AbstractModel):
-    """CreateEndPoint返回参数结构体
+class CreatePrivateZoneRecordResponse(AbstractModel):
+    """CreatePrivateZoneRecord返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _EndPointId: 终端节点id
-        :type EndPointId: str
-        :param _EndPointName: 终端节点名称
-        :type EndPointName: str
-        :param _EndPointServiceId: 终端节点服务ID
-        :type EndPointServiceId: str
-        :param _EndPointVipSet: 终端节点的IP列表
-        :type EndPointVipSet: list of str
+        :param _RecordId: 记录Id
+        :type RecordId: str
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._EndPointId = None
-        self._EndPointName = None
-        self._EndPointServiceId = None
-        self._EndPointVipSet = None
+        self._RecordId = None
         self._RequestId = None
 
     @property
-    def EndPointId(self):
-        """终端节点id
-        :rtype: str
-        """
-        return self._EndPointId
-
-    @EndPointId.setter
-    def EndPointId(self, EndPointId):
-        self._EndPointId = EndPointId
-
-    @property
-    def EndPointName(self):
-        """终端节点名称
-        :rtype: str
-        """
-        return self._EndPointName
-
-    @EndPointName.setter
-    def EndPointName(self, EndPointName):
-        self._EndPointName = EndPointName
-
-    @property
-    def EndPointServiceId(self):
-        """终端节点服务ID
+    def RecordId(self):
+        """记录Id
         :rtype: str
         """
-        return self._EndPointServiceId
-
-    @EndPointServiceId.setter
-    def EndPointServiceId(self, EndPointServiceId):
-        self._EndPointServiceId = EndPointServiceId
-
-    @property
-    def EndPointVipSet(self):
-        """终端节点的IP列表
-        :rtype: list of str
-        """
-        return self._EndPointVipSet
+        return self._RecordId
 
-    @EndPointVipSet.setter
-    def EndPointVipSet(self, EndPointVipSet):
-        self._EndPointVipSet = EndPointVipSet
+    @RecordId.setter
+    def RecordId(self, RecordId):
+        self._RecordId = RecordId
 
     @property
     def RequestId(self):
@@ -986,84 +826,161 @@ class CreateEndPointResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._EndPointId = params.get("EndPointId")
-        self._EndPointName = params.get("EndPointName")
-        self._EndPointServiceId = params.get("EndPointServiceId")
-        self._EndPointVipSet = params.get("EndPointVipSet")
+        self._RecordId = params.get("RecordId")
         self._RequestId = params.get("RequestId")
 
 
-class CreateForwardRuleRequest(AbstractModel):
-    """CreateForwardRule请求参数结构体
+class CreatePrivateZoneRequest(AbstractModel):
+    """CreatePrivateZone请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _RuleName: 转发规则名称
-        :type RuleName: str
-        :param _RuleType: 转发规则类型：云上到云下DOWN，云下到云上UP
-        :type RuleType: str
-        :param _ZoneId: 私有域ID，可在私有域列表页面查看
-        :type ZoneId: str
-        :param _EndPointId: 终端节点ID
-        :type EndPointId: str
+        :param _Domain: 域名，格式必须是标准的TLD
+        :type Domain: str
+        :param _TagSet: 创建私有域的同时，为其打上标签
+        :type TagSet: list of TagInfo
+        :param _VpcSet: 创建私有域的同时，将其关联至VPC
+        :type VpcSet: list of VpcInfo
+        :param _Remark: 备注
+        :type Remark: str
+        :param _DnsForwardStatus: 是否开启子域名递归, ENABLED， DISABLED。默认值为ENABLED
+        :type DnsForwardStatus: str
+        :param _Vpcs: 创建私有域的同时，将其关联至VPC
+        :type Vpcs: list of VpcInfo
+        :param _AccountVpcSet: 创建私有域同时绑定关联账号的VPC
+        :type AccountVpcSet: list of AccountVpcInfo
+        :param _CnameSpeedupStatus: 是否CNAME加速：ENABLED，DISABLED，默认值为ENABLED
+        :type CnameSpeedupStatus: str
         """
-        self._RuleName = None
-        self._RuleType = None
-        self._ZoneId = None
-        self._EndPointId = None
-
-    @property
-    def RuleName(self):
-        """转发规则名称
+        self._Domain = None
+        self._TagSet = None
+        self._VpcSet = None
+        self._Remark = None
+        self._DnsForwardStatus = None
+        self._Vpcs = None
+        self._AccountVpcSet = None
+        self._CnameSpeedupStatus = None
+
+    @property
+    def Domain(self):
+        """域名，格式必须是标准的TLD
         :rtype: str
         """
-        return self._RuleName
+        return self._Domain
+
+    @Domain.setter
+    def Domain(self, Domain):
+        self._Domain = Domain
+
+    @property
+    def TagSet(self):
+        """创建私有域的同时，为其打上标签
+        :rtype: list of TagInfo
+        """
+        return self._TagSet
+
+    @TagSet.setter
+    def TagSet(self, TagSet):
+        self._TagSet = TagSet
+
+    @property
+    def VpcSet(self):
+        """创建私有域的同时，将其关联至VPC
+        :rtype: list of VpcInfo
+        """
+        return self._VpcSet
 
-    @RuleName.setter
-    def RuleName(self, RuleName):
-        self._RuleName = RuleName
+    @VpcSet.setter
+    def VpcSet(self, VpcSet):
+        self._VpcSet = VpcSet
 
     @property
-    def RuleType(self):
-        """转发规则类型：云上到云下DOWN，云下到云上UP
+    def Remark(self):
+        """备注
         :rtype: str
         """
-        return self._RuleType
+        return self._Remark
 
-    @RuleType.setter
-    def RuleType(self, RuleType):
-        self._RuleType = RuleType
+    @Remark.setter
+    def Remark(self, Remark):
+        self._Remark = Remark
 
     @property
-    def ZoneId(self):
-        """私有域ID，可在私有域列表页面查看
+    def DnsForwardStatus(self):
+        """是否开启子域名递归, ENABLED， DISABLED。默认值为ENABLED
         :rtype: str
         """
-        return self._ZoneId
+        return self._DnsForwardStatus
 
-    @ZoneId.setter
-    def ZoneId(self, ZoneId):
-        self._ZoneId = ZoneId
+    @DnsForwardStatus.setter
+    def DnsForwardStatus(self, DnsForwardStatus):
+        self._DnsForwardStatus = DnsForwardStatus
+
+    @property
+    def Vpcs(self):
+        """创建私有域的同时，将其关联至VPC
+        :rtype: list of VpcInfo
+        """
+        return self._Vpcs
+
+    @Vpcs.setter
+    def Vpcs(self, Vpcs):
+        self._Vpcs = Vpcs
+
+    @property
+    def AccountVpcSet(self):
+        """创建私有域同时绑定关联账号的VPC
+        :rtype: list of AccountVpcInfo
+        """
+        return self._AccountVpcSet
+
+    @AccountVpcSet.setter
+    def AccountVpcSet(self, AccountVpcSet):
+        self._AccountVpcSet = AccountVpcSet
 
     @property
-    def EndPointId(self):
-        """终端节点ID
+    def CnameSpeedupStatus(self):
+        """是否CNAME加速：ENABLED，DISABLED，默认值为ENABLED
         :rtype: str
         """
-        return self._EndPointId
+        return self._CnameSpeedupStatus
 
-    @EndPointId.setter
-    def EndPointId(self, EndPointId):
-        self._EndPointId = EndPointId
+    @CnameSpeedupStatus.setter
+    def CnameSpeedupStatus(self, CnameSpeedupStatus):
+        self._CnameSpeedupStatus = CnameSpeedupStatus
 
 
     def _deserialize(self, params):
-        self._RuleName = params.get("RuleName")
-        self._RuleType = params.get("RuleType")
-        self._ZoneId = params.get("ZoneId")
-        self._EndPointId = params.get("EndPointId")
+        self._Domain = params.get("Domain")
+        if params.get("TagSet") is not None:
+            self._TagSet = []
+            for item in params.get("TagSet"):
+                obj = TagInfo()
+                obj._deserialize(item)
+                self._TagSet.append(obj)
+        if params.get("VpcSet") is not None:
+            self._VpcSet = []
+            for item in params.get("VpcSet"):
+                obj = VpcInfo()
+                obj._deserialize(item)
+                self._VpcSet.append(obj)
+        self._Remark = params.get("Remark")
+        self._DnsForwardStatus = params.get("DnsForwardStatus")
+        if params.get("Vpcs") is not None:
+            self._Vpcs = []
+            for item in params.get("Vpcs"):
+                obj = VpcInfo()
+                obj._deserialize(item)
+                self._Vpcs.append(obj)
+        if params.get("AccountVpcSet") is not None:
+            self._AccountVpcSet = []
+            for item in params.get("AccountVpcSet"):
+                obj = AccountVpcInfo()
+                obj._deserialize(item)
+                self._AccountVpcSet.append(obj)
+        self._CnameSpeedupStatus = params.get("CnameSpeedupStatus")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -1074,69 +991,27 @@ class CreateForwardRuleRequest(AbstractModel):
         
 
 
-class CreateForwardRuleResponse(AbstractModel):
-    """CreateForwardRule返回参数结构体
+class CreatePrivateZoneResponse(AbstractModel):
+    """CreatePrivateZone返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _RuleId: 转发规则ID
-        :type RuleId: str
-        :param _RuleName: 转发规则名称
-        :type RuleName: str
-        :param _RuleType: 转发规则类型
-        :type RuleType: str
-        :param _ZoneId: 私有域ID
+        :param _ZoneId: 私有域ID, zone-xxxxxx
         :type ZoneId: str
-        :param _EndPointId: 终端节点ID
-        :type EndPointId: str
+        :param _Domain: 私有域名
+        :type Domain: str
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._RuleId = None
-        self._RuleName = None
-        self._RuleType = None
         self._ZoneId = None
-        self._EndPointId = None
+        self._Domain = None
         self._RequestId = None
 
-    @property
-    def RuleId(self):
-        """转发规则ID
-        :rtype: str
-        """
-        return self._RuleId
-
-    @RuleId.setter
-    def RuleId(self, RuleId):
-        self._RuleId = RuleId
-
-    @property
-    def RuleName(self):
-        """转发规则名称
-        :rtype: str
-        """
-        return self._RuleName
-
-    @RuleName.setter
-    def RuleName(self, RuleName):
-        self._RuleName = RuleName
-
-    @property
-    def RuleType(self):
-        """转发规则类型
-        :rtype: str
-        """
-        return self._RuleType
-
-    @RuleType.setter
-    def RuleType(self, RuleType):
-        self._RuleType = RuleType
-
     @property
     def ZoneId(self):
-        """私有域ID
+        """私有域ID, zone-xxxxxx
         :rtype: str
         """
         return self._ZoneId
@@ -1146,15 +1021,15 @@ class CreateForwardRuleResponse(AbstractModel):
         self._ZoneId = ZoneId
 
     @property
-    def EndPointId(self):
-        """终端节点ID
+    def Domain(self):
+        """私有域名
         :rtype: str
         """
-        return self._EndPointId
+        return self._Domain
 
-    @EndPointId.setter
-    def EndPointId(self, EndPointId):
-        self._EndPointId = EndPointId
+    @Domain.setter
+    def Domain(self, Domain):
+        self._Domain = Domain
 
     @property
     def RequestId(self):
@@ -1169,16 +1044,64 @@ class CreateForwardRuleResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._RuleId = params.get("RuleId")
-        self._RuleName = params.get("RuleName")
-        self._RuleType = params.get("RuleType")
         self._ZoneId = params.get("ZoneId")
-        self._EndPointId = params.get("EndPointId")
+        self._Domain = params.get("Domain")
         self._RequestId = params.get("RequestId")
 
 
-class CreatePrivateDNSAccountRequest(AbstractModel):
-    """CreatePrivateDNSAccount请求参数结构体
+class DatePoint(AbstractModel):
+    """时间统计值
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Date: 时间
+        :type Date: str
+        :param _Value: 值
+        :type Value: int
+        """
+        self._Date = None
+        self._Value = None
+
+    @property
+    def Date(self):
+        """时间
+        :rtype: str
+        """
+        return self._Date
+
+    @Date.setter
+    def Date(self, Date):
+        self._Date = Date
+
+    @property
+    def Value(self):
+        """值
+        :rtype: int
+        """
+        return self._Value
+
+    @Value.setter
+    def Value(self, Value):
+        self._Value = Value
+
+
+    def _deserialize(self, params):
+        self._Date = params.get("Date")
+        self._Value = params.get("Value")
+        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 DeletePrivateDNSAccountRequest(AbstractModel):
+    """DeletePrivateDNSAccount请求参数结构体
 
     """
 
@@ -1215,8 +1138,8 @@ class CreatePrivateDNSAccountRequest(AbstractModel):
         
 
 
-class CreatePrivateDNSAccountResponse(AbstractModel):
-    """CreatePrivateDNSAccount返回参数结构体
+class DeletePrivateDNSAccountResponse(AbstractModel):
+    """DeletePrivateDNSAccount返回参数结构体
 
     """
 
@@ -1243,8 +1166,8 @@ class CreatePrivateDNSAccountResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
-class CreatePrivateZoneRecordRequest(AbstractModel):
-    """CreatePrivateZoneRecord请求参数结构体
+class DeletePrivateZoneRecordRequest(AbstractModel):
+    """DeletePrivateZoneRecord请求参数结构体
 
     """
 
@@ -1252,26 +1175,14 @@ class CreatePrivateZoneRecordRequest(AbstractModel):
         r"""
         :param _ZoneId: 私有域ID
         :type ZoneId: str
-        :param _RecordType: 记录类型，可选的记录类型为："A", "AAAA", "CNAME", "MX", "TXT", "PTR"
-        :type RecordType: str
-        :param _SubDomain: 子域名，例如 "www", "m", "@"
-        :type SubDomain: str
-        :param _RecordValue: 记录值，例如 IP：192.168.10.2，CNAME：cname.qcloud.com.，MX：mail.qcloud.com.
-        :type RecordValue: str
-        :param _Weight: 记录权重，值为1-100
-        :type Weight: int
-        :param _MX: MX优先级：记录类型为MX时必填。取值范围：5,10,15,20,30,40,50
-        :type MX: int
-        :param _TTL: 记录缓存时间，数值越小生效越快，取值1-86400s, 默认 600
-        :type TTL: int
+        :param _RecordId: 记录ID（调用DescribePrivateZoneRecordList可获取到RecordId）
+        :type RecordId: str
+        :param _RecordIdSet: 记录ID数组，RecordId 优先
+        :type RecordIdSet: list of str
         """
         self._ZoneId = None
-        self._RecordType = None
-        self._SubDomain = None
-        self._RecordValue = None
-        self._Weight = None
-        self._MX = None
-        self._TTL = None
+        self._RecordId = None
+        self._RecordIdSet = None
 
     @property
     def ZoneId(self):
@@ -1285,80 +1196,111 @@ class CreatePrivateZoneRecordRequest(AbstractModel):
         self._ZoneId = ZoneId
 
     @property
-    def RecordType(self):
-        """记录类型，可选的记录类型为："A", "AAAA", "CNAME", "MX", "TXT", "PTR"
+    def RecordId(self):
+        """记录ID（调用DescribePrivateZoneRecordList可获取到RecordId）
         :rtype: str
         """
-        return self._RecordType
+        return self._RecordId
 
-    @RecordType.setter
-    def RecordType(self, RecordType):
-        self._RecordType = RecordType
+    @RecordId.setter
+    def RecordId(self, RecordId):
+        self._RecordId = RecordId
 
     @property
-    def SubDomain(self):
-        """子域名，例如 "www", "m", "@"
-        :rtype: str
+    def RecordIdSet(self):
+        """记录ID数组，RecordId 优先
+        :rtype: list of str
         """
-        return self._SubDomain
-
-    @SubDomain.setter
-    def SubDomain(self, SubDomain):
-        self._SubDomain = SubDomain
+        return self._RecordIdSet
 
-    @property
-    def RecordValue(self):
-        """记录值，例如 IP：192.168.10.2，CNAME：cname.qcloud.com.，MX：mail.qcloud.com.
-        :rtype: str
-        """
-        return self._RecordValue
+    @RecordIdSet.setter
+    def RecordIdSet(self, RecordIdSet):
+        self._RecordIdSet = RecordIdSet
 
-    @RecordValue.setter
-    def RecordValue(self, RecordValue):
-        self._RecordValue = RecordValue
+
+    def _deserialize(self, params):
+        self._ZoneId = params.get("ZoneId")
+        self._RecordId = params.get("RecordId")
+        self._RecordIdSet = params.get("RecordIdSet")
+        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 DeletePrivateZoneRecordResponse(AbstractModel):
+    """DeletePrivateZoneRecord返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._RequestId = None
 
     @property
-    def Weight(self):
-        """记录权重，值为1-100
-        :rtype: int
+    def RequestId(self):
+        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
         """
-        return self._Weight
+        return self._RequestId
 
-    @Weight.setter
-    def Weight(self, Weight):
-        self._Weight = Weight
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._RequestId = params.get("RequestId")
+
+
+class DeletePrivateZoneRequest(AbstractModel):
+    """DeletePrivateZone请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _ZoneId: 私有域ID
+        :type ZoneId: str
+        :param _ZoneIdSet: 私有域ID数组，ZoneId 优先
+        :type ZoneIdSet: list of str
+        """
+        self._ZoneId = None
+        self._ZoneIdSet = None
 
     @property
-    def MX(self):
-        """MX优先级：记录类型为MX时必填。取值范围：5,10,15,20,30,40,50
-        :rtype: int
+    def ZoneId(self):
+        """私有域ID
+        :rtype: str
         """
-        return self._MX
+        return self._ZoneId
 
-    @MX.setter
-    def MX(self, MX):
-        self._MX = MX
+    @ZoneId.setter
+    def ZoneId(self, ZoneId):
+        self._ZoneId = ZoneId
 
     @property
-    def TTL(self):
-        """记录缓存时间，数值越小生效越快，取值1-86400s, 默认 600
-        :rtype: int
+    def ZoneIdSet(self):
+        """私有域ID数组，ZoneId 优先
+        :rtype: list of str
         """
-        return self._TTL
+        return self._ZoneIdSet
 
-    @TTL.setter
-    def TTL(self, TTL):
-        self._TTL = TTL
+    @ZoneIdSet.setter
+    def ZoneIdSet(self, ZoneIdSet):
+        self._ZoneIdSet = ZoneIdSet
 
 
     def _deserialize(self, params):
         self._ZoneId = params.get("ZoneId")
-        self._RecordType = params.get("RecordType")
-        self._SubDomain = params.get("SubDomain")
-        self._RecordValue = params.get("RecordValue")
-        self._Weight = params.get("Weight")
-        self._MX = params.get("MX")
-        self._TTL = params.get("TTL")
+        self._ZoneIdSet = params.get("ZoneIdSet")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -1369,32 +1311,18 @@ class CreatePrivateZoneRecordRequest(AbstractModel):
         
 
 
-class CreatePrivateZoneRecordResponse(AbstractModel):
-    """CreatePrivateZoneRecord返回参数结构体
+class DeletePrivateZoneResponse(AbstractModel):
+    """DeletePrivateZone返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _RecordId: 记录Id
-        :type RecordId: str
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._RecordId = None
         self._RequestId = None
 
-    @property
-    def RecordId(self):
-        """记录Id
-        :rtype: str
-        """
-        return self._RecordId
-
-    @RecordId.setter
-    def RecordId(self, RecordId):
-        self._RecordId = RecordId
-
     @property
     def RequestId(self):
         """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
@@ -1408,68 +1336,44 @@ class CreatePrivateZoneRecordResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._RecordId = params.get("RecordId")
         self._RequestId = params.get("RequestId")
 
 
-class CreatePrivateZoneRequest(AbstractModel):
-    """CreatePrivateZone请求参数结构体
+class DeleteSpecifyPrivateZoneVpcRequest(AbstractModel):
+    """DeleteSpecifyPrivateZoneVpc请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _Domain: 域名，格式必须是标准的TLD
-        :type Domain: str
-        :param _TagSet: 创建私有域的同时，为其打上标签
-        :type TagSet: list of TagInfo
-        :param _VpcSet: 创建私有域的同时，将其关联至VPC
+        :param _ZoneId: 私有域id
+        :type ZoneId: str
+        :param _VpcSet: 本次删除的VPC
         :type VpcSet: list of VpcInfo
-        :param _Remark: 备注
-        :type Remark: str
-        :param _DnsForwardStatus: 是否开启子域名递归, ENABLED， DISABLED。默认值为ENABLED
-        :type DnsForwardStatus: str
-        :param _Vpcs: 创建私有域的同时，将其关联至VPC
-        :type Vpcs: list of VpcInfo
-        :param _AccountVpcSet: 创建私有域同时绑定关联账号的VPC
+        :param _AccountVpcSet: 本次删除的关联账户VPC
         :type AccountVpcSet: list of AccountVpcInfo
-        :param _CnameSpeedupStatus: 是否CNAME加速：ENABLED，DISABLED，默认值为ENABLED
-        :type CnameSpeedupStatus: str
+        :param _Sync: 是否为同步操作
+        :type Sync: bool
         """
-        self._Domain = None
-        self._TagSet = None
+        self._ZoneId = None
         self._VpcSet = None
-        self._Remark = None
-        self._DnsForwardStatus = None
-        self._Vpcs = None
         self._AccountVpcSet = None
-        self._CnameSpeedupStatus = None
+        self._Sync = None
 
     @property
-    def Domain(self):
-        """域名，格式必须是标准的TLD
+    def ZoneId(self):
+        """私有域id
         :rtype: str
         """
-        return self._Domain
-
-    @Domain.setter
-    def Domain(self, Domain):
-        self._Domain = Domain
-
-    @property
-    def TagSet(self):
-        """创建私有域的同时，为其打上标签
-        :rtype: list of TagInfo
-        """
-        return self._TagSet
+        return self._ZoneId
 
-    @TagSet.setter
-    def TagSet(self, TagSet):
-        self._TagSet = TagSet
+    @ZoneId.setter
+    def ZoneId(self, ZoneId):
+        self._ZoneId = ZoneId
 
     @property
     def VpcSet(self):
-        """创建私有域的同时，将其关联至VPC
+        """本次删除的VPC
         :rtype: list of VpcInfo
         """
         return self._VpcSet
@@ -1478,42 +1382,9 @@ class CreatePrivateZoneRequest(AbstractModel):
     def VpcSet(self, VpcSet):
         self._VpcSet = VpcSet
 
-    @property
-    def Remark(self):
-        """备注
-        :rtype: str
-        """
-        return self._Remark
-
-    @Remark.setter
-    def Remark(self, Remark):
-        self._Remark = Remark
-
-    @property
-    def DnsForwardStatus(self):
-        """是否开启子域名递归, ENABLED， DISABLED。默认值为ENABLED
-        :rtype: str
-        """
-        return self._DnsForwardStatus
-
-    @DnsForwardStatus.setter
-    def DnsForwardStatus(self, DnsForwardStatus):
-        self._DnsForwardStatus = DnsForwardStatus
-
-    @property
-    def Vpcs(self):
-        """创建私有域的同时，将其关联至VPC
-        :rtype: list of VpcInfo
-        """
-        return self._Vpcs
-
-    @Vpcs.setter
-    def Vpcs(self, Vpcs):
-        self._Vpcs = Vpcs
-
     @property
     def AccountVpcSet(self):
-        """创建私有域同时绑定关联账号的VPC
+        """本次删除的关联账户VPC
         :rtype: list of AccountVpcInfo
         """
         return self._AccountVpcSet
@@ -1523,46 +1394,32 @@ class CreatePrivateZoneRequest(AbstractModel):
         self._AccountVpcSet = AccountVpcSet
 
     @property
-    def CnameSpeedupStatus(self):
-        """是否CNAME加速：ENABLED，DISABLED，默认值为ENABLED
-        :rtype: str
+    def Sync(self):
+        """是否为同步操作
+        :rtype: bool
         """
-        return self._CnameSpeedupStatus
+        return self._Sync
 
-    @CnameSpeedupStatus.setter
-    def CnameSpeedupStatus(self, CnameSpeedupStatus):
-        self._CnameSpeedupStatus = CnameSpeedupStatus
+    @Sync.setter
+    def Sync(self, Sync):
+        self._Sync = Sync
 
 
     def _deserialize(self, params):
-        self._Domain = params.get("Domain")
-        if params.get("TagSet") is not None:
-            self._TagSet = []
-            for item in params.get("TagSet"):
-                obj = TagInfo()
-                obj._deserialize(item)
-                self._TagSet.append(obj)
+        self._ZoneId = params.get("ZoneId")
         if params.get("VpcSet") is not None:
             self._VpcSet = []
             for item in params.get("VpcSet"):
                 obj = VpcInfo()
                 obj._deserialize(item)
                 self._VpcSet.append(obj)
-        self._Remark = params.get("Remark")
-        self._DnsForwardStatus = params.get("DnsForwardStatus")
-        if params.get("Vpcs") is not None:
-            self._Vpcs = []
-            for item in params.get("Vpcs"):
-                obj = VpcInfo()
-                obj._deserialize(item)
-                self._Vpcs.append(obj)
         if params.get("AccountVpcSet") is not None:
             self._AccountVpcSet = []
             for item in params.get("AccountVpcSet"):
                 obj = AccountVpcInfo()
                 obj._deserialize(item)
                 self._AccountVpcSet.append(obj)
-        self._CnameSpeedupStatus = params.get("CnameSpeedupStatus")
+        self._Sync = params.get("Sync")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -1573,27 +1430,34 @@ class CreatePrivateZoneRequest(AbstractModel):
         
 
 
-class CreatePrivateZoneResponse(AbstractModel):
-    """CreatePrivateZone返回参数结构体
+class DeleteSpecifyPrivateZoneVpcResponse(AbstractModel):
+    """DeleteSpecifyPrivateZoneVpc返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _ZoneId: 私有域ID, zone-xxxxxx
+        :param _ZoneId: 私有域id
         :type ZoneId: str
-        :param _Domain: 私有域名
-        :type Domain: str
+        :param _VpcSet: 本次删除的VPC
+        :type VpcSet: list of VpcInfo
+        :param _AccountVpcSet: 本次删除的关联账户的VPC
+        :type AccountVpcSet: list of AccountVpcInfo
+        :param _UniqId: 唯一id
+注意：此字段可能返回 null，表示取不到有效值。
+        :type UniqId: str
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
         self._ZoneId = None
-        self._Domain = None
+        self._VpcSet = None
+        self._AccountVpcSet = None
+        self._UniqId = None
         self._RequestId = None
 
     @property
     def ZoneId(self):
-        """私有域ID, zone-xxxxxx
+        """私有域id
         :rtype: str
         """
         return self._ZoneId
@@ -1603,1014 +1467,38 @@ class CreatePrivateZoneResponse(AbstractModel):
         self._ZoneId = ZoneId
 
     @property
-    def Domain(self):
-        """私有域名
-        :rtype: str
-        """
-        return self._Domain
-
-    @Domain.setter
-    def Domain(self, Domain):
-        self._Domain = Domain
-
-    @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._ZoneId = params.get("ZoneId")
-        self._Domain = params.get("Domain")
-        self._RequestId = params.get("RequestId")
-
-
-class DatePoint(AbstractModel):
-    """时间统计值
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Date: 时间
-        :type Date: str
-        :param _Value: 值
-        :type Value: int
-        """
-        self._Date = None
-        self._Value = None
-
-    @property
-    def Date(self):
-        """时间
-        :rtype: str
-        """
-        return self._Date
-
-    @Date.setter
-    def Date(self, Date):
-        self._Date = Date
-
-    @property
-    def Value(self):
-        """值
-        :rtype: int
-        """
-        return self._Value
-
-    @Value.setter
-    def Value(self, Value):
-        self._Value = Value
-
-
-    def _deserialize(self, params):
-        self._Date = params.get("Date")
-        self._Value = params.get("Value")
-        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 DeleteEndPointRequest(AbstractModel):
-    """DeleteEndPoint请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _EndPointId: 终端节点ID
-        :type EndPointId: str
-        """
-        self._EndPointId = None
-
-    @property
-    def EndPointId(self):
-        """终端节点ID
-        :rtype: str
-        """
-        return self._EndPointId
-
-    @EndPointId.setter
-    def EndPointId(self, EndPointId):
-        self._EndPointId = EndPointId
-
-
-    def _deserialize(self, params):
-        self._EndPointId = params.get("EndPointId")
-        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 DeleteEndPointResponse(AbstractModel):
-    """DeleteEndPoint返回参数结构体
-
-    """
-
-    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 DeleteForwardRuleRequest(AbstractModel):
-    """DeleteForwardRule请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _RuleIdSet: 转发规则ID数组
-        :type RuleIdSet: list of str
-        """
-        self._RuleIdSet = None
-
-    @property
-    def RuleIdSet(self):
-        """转发规则ID数组
-        :rtype: list of str
-        """
-        return self._RuleIdSet
-
-    @RuleIdSet.setter
-    def RuleIdSet(self, RuleIdSet):
-        self._RuleIdSet = RuleIdSet
-
-
-    def _deserialize(self, params):
-        self._RuleIdSet = params.get("RuleIdSet")
-        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 DeleteForwardRuleResponse(AbstractModel):
-    """DeleteForwardRule返回参数结构体
-
-    """
-
-    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 DeletePrivateDNSAccountRequest(AbstractModel):
-    """DeletePrivateDNSAccount请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Account: 私有域解析账号
-        :type Account: :class:`tencentcloud.privatedns.v20201028.models.PrivateDNSAccount`
-        """
-        self._Account = None
-
-    @property
-    def Account(self):
-        """私有域解析账号
-        :rtype: :class:`tencentcloud.privatedns.v20201028.models.PrivateDNSAccount`
+    def VpcSet(self):
+        """本次删除的VPC
+        :rtype: list of VpcInfo
         """
-        return self._Account
-
-    @Account.setter
-    def Account(self, Account):
-        self._Account = Account
-
-
-    def _deserialize(self, params):
-        if params.get("Account") is not None:
-            self._Account = PrivateDNSAccount()
-            self._Account._deserialize(params.get("Account"))
-        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 DeletePrivateDNSAccountResponse(AbstractModel):
-    """DeletePrivateDNSAccount返回参数结构体
-
-    """
+        return self._VpcSet
 
-    def __init__(self):
-        r"""
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
-        """
-        self._RequestId = None
+    @VpcSet.setter
+    def VpcSet(self, VpcSet):
+        self._VpcSet = VpcSet
 
     @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 DeletePrivateZoneRecordRequest(AbstractModel):
-    """DeletePrivateZoneRecord请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _ZoneId: 私有域ID
-        :type ZoneId: str
-        :param _RecordId: 记录ID（调用DescribePrivateZoneRecordList可获取到RecordId）
-        :type RecordId: str
-        :param _RecordIdSet: 记录ID数组，RecordId 优先
-        :type RecordIdSet: list of str
-        """
-        self._ZoneId = None
-        self._RecordId = None
-        self._RecordIdSet = None
-
-    @property
-    def ZoneId(self):
-        """私有域ID
-        :rtype: str
-        """
-        return self._ZoneId
-
-    @ZoneId.setter
-    def ZoneId(self, ZoneId):
-        self._ZoneId = ZoneId
-
-    @property
-    def RecordId(self):
-        """记录ID（调用DescribePrivateZoneRecordList可获取到RecordId）
-        :rtype: str
-        """
-        return self._RecordId
-
-    @RecordId.setter
-    def RecordId(self, RecordId):
-        self._RecordId = RecordId
-
-    @property
-    def RecordIdSet(self):
-        """记录ID数组，RecordId 优先
-        :rtype: list of str
-        """
-        return self._RecordIdSet
-
-    @RecordIdSet.setter
-    def RecordIdSet(self, RecordIdSet):
-        self._RecordIdSet = RecordIdSet
-
-
-    def _deserialize(self, params):
-        self._ZoneId = params.get("ZoneId")
-        self._RecordId = params.get("RecordId")
-        self._RecordIdSet = params.get("RecordIdSet")
-        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 DeletePrivateZoneRecordResponse(AbstractModel):
-    """DeletePrivateZoneRecord返回参数结构体
-
-    """
-
-    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 DeletePrivateZoneRequest(AbstractModel):
-    """DeletePrivateZone请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _ZoneId: 私有域ID
-        :type ZoneId: str
-        :param _ZoneIdSet: 私有域ID数组，ZoneId 优先
-        :type ZoneIdSet: list of str
-        """
-        self._ZoneId = None
-        self._ZoneIdSet = None
-
-    @property
-    def ZoneId(self):
-        """私有域ID
-        :rtype: str
-        """
-        return self._ZoneId
-
-    @ZoneId.setter
-    def ZoneId(self, ZoneId):
-        self._ZoneId = ZoneId
-
-    @property
-    def ZoneIdSet(self):
-        """私有域ID数组，ZoneId 优先
-        :rtype: list of str
-        """
-        return self._ZoneIdSet
-
-    @ZoneIdSet.setter
-    def ZoneIdSet(self, ZoneIdSet):
-        self._ZoneIdSet = ZoneIdSet
-
-
-    def _deserialize(self, params):
-        self._ZoneId = params.get("ZoneId")
-        self._ZoneIdSet = params.get("ZoneIdSet")
-        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 DeletePrivateZoneResponse(AbstractModel):
-    """DeletePrivateZone返回参数结构体
-
-    """
-
-    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 DeleteSpecifyPrivateZoneVpcRequest(AbstractModel):
-    """DeleteSpecifyPrivateZoneVpc请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _ZoneId: 私有域id
-        :type ZoneId: str
-        :param _VpcSet: 本次删除的VPC
-        :type VpcSet: list of VpcInfo
-        :param _AccountVpcSet: 本次删除的关联账户VPC
-        :type AccountVpcSet: list of AccountVpcInfo
-        :param _Sync: 是否为同步操作
-        :type Sync: bool
-        """
-        self._ZoneId = None
-        self._VpcSet = None
-        self._AccountVpcSet = None
-        self._Sync = None
-
-    @property
-    def ZoneId(self):
-        """私有域id
-        :rtype: str
-        """
-        return self._ZoneId
-
-    @ZoneId.setter
-    def ZoneId(self, ZoneId):
-        self._ZoneId = ZoneId
-
-    @property
-    def VpcSet(self):
-        """本次删除的VPC
-        :rtype: list of VpcInfo
-        """
-        return self._VpcSet
-
-    @VpcSet.setter
-    def VpcSet(self, VpcSet):
-        self._VpcSet = VpcSet
-
-    @property
-    def AccountVpcSet(self):
-        """本次删除的关联账户VPC
-        :rtype: list of AccountVpcInfo
+    def AccountVpcSet(self):
+        """本次删除的关联账户的VPC
+        :rtype: list of AccountVpcInfo
         """
         return self._AccountVpcSet
 
-    @AccountVpcSet.setter
-    def AccountVpcSet(self, AccountVpcSet):
-        self._AccountVpcSet = AccountVpcSet
-
-    @property
-    def Sync(self):
-        """是否为同步操作
-        :rtype: bool
-        """
-        return self._Sync
-
-    @Sync.setter
-    def Sync(self, Sync):
-        self._Sync = Sync
-
-
-    def _deserialize(self, params):
-        self._ZoneId = params.get("ZoneId")
-        if params.get("VpcSet") is not None:
-            self._VpcSet = []
-            for item in params.get("VpcSet"):
-                obj = VpcInfo()
-                obj._deserialize(item)
-                self._VpcSet.append(obj)
-        if params.get("AccountVpcSet") is not None:
-            self._AccountVpcSet = []
-            for item in params.get("AccountVpcSet"):
-                obj = AccountVpcInfo()
-                obj._deserialize(item)
-                self._AccountVpcSet.append(obj)
-        self._Sync = params.get("Sync")
-        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 DeleteSpecifyPrivateZoneVpcResponse(AbstractModel):
-    """DeleteSpecifyPrivateZoneVpc返回参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _ZoneId: 私有域id
-        :type ZoneId: str
-        :param _VpcSet: 本次删除的VPC
-        :type VpcSet: list of VpcInfo
-        :param _AccountVpcSet: 本次删除的关联账户的VPC
-        :type AccountVpcSet: list of AccountVpcInfo
-        :param _UniqId: 唯一id
-注意：此字段可能返回 null，表示取不到有效值。
-        :type UniqId: str
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
-        """
-        self._ZoneId = None
-        self._VpcSet = None
-        self._AccountVpcSet = None
-        self._UniqId = None
-        self._RequestId = None
-
-    @property
-    def ZoneId(self):
-        """私有域id
-        :rtype: str
-        """
-        return self._ZoneId
-
-    @ZoneId.setter
-    def ZoneId(self, ZoneId):
-        self._ZoneId = ZoneId
-
-    @property
-    def VpcSet(self):
-        """本次删除的VPC
-        :rtype: list of VpcInfo
-        """
-        return self._VpcSet
-
-    @VpcSet.setter
-    def VpcSet(self, VpcSet):
-        self._VpcSet = VpcSet
-
-    @property
-    def AccountVpcSet(self):
-        """本次删除的关联账户的VPC
-        :rtype: list of AccountVpcInfo
-        """
-        return self._AccountVpcSet
-
-    @AccountVpcSet.setter
-    def AccountVpcSet(self, AccountVpcSet):
-        self._AccountVpcSet = AccountVpcSet
-
-    @property
-    def UniqId(self):
-        """唯一id
-注意：此字段可能返回 null，表示取不到有效值。
-        :rtype: str
-        """
-        return self._UniqId
-
-    @UniqId.setter
-    def UniqId(self, UniqId):
-        self._UniqId = UniqId
-
-    @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._ZoneId = params.get("ZoneId")
-        if params.get("VpcSet") is not None:
-            self._VpcSet = []
-            for item in params.get("VpcSet"):
-                obj = VpcInfo()
-                obj._deserialize(item)
-                self._VpcSet.append(obj)
-        if params.get("AccountVpcSet") is not None:
-            self._AccountVpcSet = []
-            for item in params.get("AccountVpcSet"):
-                obj = AccountVpcInfo()
-                obj._deserialize(item)
-                self._AccountVpcSet.append(obj)
-        self._UniqId = params.get("UniqId")
-        self._RequestId = params.get("RequestId")
-
-
-class DescribeAccountVpcListRequest(AbstractModel):
-    """DescribeAccountVpcList请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _AccountUin: 关联账号的uin
-        :type AccountUin: str
-        :param _Offset: 分页偏移量，从0开始
-        :type Offset: int
-        :param _Limit: 分页限制数目， 最大100，默认20
-        :type Limit: int
-        :param _Filters: 过滤参数
-        :type Filters: list of Filter
-        """
-        self._AccountUin = None
-        self._Offset = None
-        self._Limit = None
-        self._Filters = None
-
-    @property
-    def AccountUin(self):
-        """关联账号的uin
-        :rtype: str
-        """
-        return self._AccountUin
-
-    @AccountUin.setter
-    def AccountUin(self, AccountUin):
-        self._AccountUin = AccountUin
-
-    @property
-    def Offset(self):
-        """分页偏移量，从0开始
-        :rtype: int
-        """
-        return self._Offset
-
-    @Offset.setter
-    def Offset(self, Offset):
-        self._Offset = Offset
-
-    @property
-    def Limit(self):
-        """分页限制数目， 最大100，默认20
-        :rtype: int
-        """
-        return self._Limit
-
-    @Limit.setter
-    def Limit(self, Limit):
-        self._Limit = Limit
-
-    @property
-    def Filters(self):
-        """过滤参数
-        :rtype: list of Filter
-        """
-        return self._Filters
-
-    @Filters.setter
-    def Filters(self, Filters):
-        self._Filters = Filters
-
-
-    def _deserialize(self, params):
-        self._AccountUin = params.get("AccountUin")
-        self._Offset = params.get("Offset")
-        self._Limit = params.get("Limit")
-        if params.get("Filters") is not None:
-            self._Filters = []
-            for item in params.get("Filters"):
-                obj = Filter()
-                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:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
-
-
-class DescribeAccountVpcListResponse(AbstractModel):
-    """DescribeAccountVpcList返回参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _TotalCount: VPC数量
-        :type TotalCount: int
-        :param _VpcSet: VPC 列表
-        :type VpcSet: list of AccountVpcInfoOut
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
-        """
-        self._TotalCount = None
-        self._VpcSet = None
-        self._RequestId = None
-
-    @property
-    def TotalCount(self):
-        """VPC数量
-        :rtype: int
-        """
-        return self._TotalCount
-
-    @TotalCount.setter
-    def TotalCount(self, TotalCount):
-        self._TotalCount = TotalCount
-
-    @property
-    def VpcSet(self):
-        """VPC 列表
-        :rtype: list of AccountVpcInfoOut
-        """
-        return self._VpcSet
-
-    @VpcSet.setter
-    def VpcSet(self, VpcSet):
-        self._VpcSet = VpcSet
-
-    @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._TotalCount = params.get("TotalCount")
-        if params.get("VpcSet") is not None:
-            self._VpcSet = []
-            for item in params.get("VpcSet"):
-                obj = AccountVpcInfoOut()
-                obj._deserialize(item)
-                self._VpcSet.append(obj)
-        self._RequestId = params.get("RequestId")
-
-
-class DescribeAuditLogRequest(AbstractModel):
-    """DescribeAuditLog请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _TimeRangeBegin: 请求量统计起始时间
-        :type TimeRangeBegin: str
-        :param _Filters: 筛选参数：ZoneId：私有域ID；Domain：私有域；OperatorUin：操作者账号ID
-        :type Filters: list of Filter
-        :param _TimeRangeEnd: 请求量统计结束时间
-        :type TimeRangeEnd: str
-        :param _Offset: 分页偏移量，从0开始
-        :type Offset: int
-        :param _Limit: 分页限制数目， 最大100，默认20
-        :type Limit: int
-        """
-        self._TimeRangeBegin = None
-        self._Filters = None
-        self._TimeRangeEnd = None
-        self._Offset = None
-        self._Limit = None
-
-    @property
-    def TimeRangeBegin(self):
-        """请求量统计起始时间
-        :rtype: str
-        """
-        return self._TimeRangeBegin
-
-    @TimeRangeBegin.setter
-    def TimeRangeBegin(self, TimeRangeBegin):
-        self._TimeRangeBegin = TimeRangeBegin
-
-    @property
-    def Filters(self):
-        """筛选参数：ZoneId：私有域ID；Domain：私有域；OperatorUin：操作者账号ID
-        :rtype: list of Filter
-        """
-        return self._Filters
-
-    @Filters.setter
-    def Filters(self, Filters):
-        self._Filters = Filters
-
-    @property
-    def TimeRangeEnd(self):
-        """请求量统计结束时间
-        :rtype: str
-        """
-        return self._TimeRangeEnd
-
-    @TimeRangeEnd.setter
-    def TimeRangeEnd(self, TimeRangeEnd):
-        self._TimeRangeEnd = TimeRangeEnd
-
-    @property
-    def Offset(self):
-        """分页偏移量，从0开始
-        :rtype: int
-        """
-        return self._Offset
-
-    @Offset.setter
-    def Offset(self, Offset):
-        self._Offset = Offset
-
-    @property
-    def Limit(self):
-        """分页限制数目， 最大100，默认20
-        :rtype: int
-        """
-        return self._Limit
-
-    @Limit.setter
-    def Limit(self, Limit):
-        self._Limit = Limit
-
-
-    def _deserialize(self, params):
-        self._TimeRangeBegin = params.get("TimeRangeBegin")
-        if params.get("Filters") is not None:
-            self._Filters = []
-            for item in params.get("Filters"):
-                obj = Filter()
-                obj._deserialize(item)
-                self._Filters.append(obj)
-        self._TimeRangeEnd = params.get("TimeRangeEnd")
-        self._Offset = params.get("Offset")
-        self._Limit = params.get("Limit")
-        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 DescribeAuditLogResponse(AbstractModel):
-    """DescribeAuditLog返回参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Data: 操作日志列表
-        :type Data: list of AuditLog
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
-        """
-        self._Data = None
-        self._RequestId = None
-
-    @property
-    def Data(self):
-        """操作日志列表
-        :rtype: list of AuditLog
-        """
-        return self._Data
-
-    @Data.setter
-    def Data(self, Data):
-        self._Data = Data
-
-    @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("Data") is not None:
-            self._Data = []
-            for item in params.get("Data"):
-                obj = AuditLog()
-                obj._deserialize(item)
-                self._Data.append(obj)
-        self._RequestId = params.get("RequestId")
-
-
-class DescribeDashboardRequest(AbstractModel):
-    """DescribeDashboard请求参数结构体
-
-    """
-
-
-class DescribeDashboardResponse(AbstractModel):
-    """DescribeDashboard返回参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _ZoneTotal: 私有域解析总数
-        :type ZoneTotal: int
-        :param _ZoneVpcCount: 私有域关联VPC数量
-        :type ZoneVpcCount: int
-        :param _RequestTotalCount: 历史请求量总数
-        :type RequestTotalCount: int
-        :param _FlowUsage: 流量包用量
-        :type FlowUsage: list of FlowUsage
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
-        """
-        self._ZoneTotal = None
-        self._ZoneVpcCount = None
-        self._RequestTotalCount = None
-        self._FlowUsage = None
-        self._RequestId = None
-
-    @property
-    def ZoneTotal(self):
-        """私有域解析总数
-        :rtype: int
-        """
-        return self._ZoneTotal
-
-    @ZoneTotal.setter
-    def ZoneTotal(self, ZoneTotal):
-        self._ZoneTotal = ZoneTotal
-
-    @property
-    def ZoneVpcCount(self):
-        """私有域关联VPC数量
-        :rtype: int
-        """
-        return self._ZoneVpcCount
-
-    @ZoneVpcCount.setter
-    def ZoneVpcCount(self, ZoneVpcCount):
-        self._ZoneVpcCount = ZoneVpcCount
-
-    @property
-    def RequestTotalCount(self):
-        """历史请求量总数
-        :rtype: int
-        """
-        return self._RequestTotalCount
-
-    @RequestTotalCount.setter
-    def RequestTotalCount(self, RequestTotalCount):
-        self._RequestTotalCount = RequestTotalCount
-
+    @AccountVpcSet.setter
+    def AccountVpcSet(self, AccountVpcSet):
+        self._AccountVpcSet = AccountVpcSet
+
     @property
-    def FlowUsage(self):
-        """流量包用量
-        :rtype: list of FlowUsage
+    def UniqId(self):
+        """唯一id
+注意：此字段可能返回 null，表示取不到有效值。
+        :rtype: str
         """
-        return self._FlowUsage
+        return self._UniqId
 
-    @FlowUsage.setter
-    def FlowUsage(self, FlowUsage):
-        self._FlowUsage = FlowUsage
+    @UniqId.setter
+    def UniqId(self, UniqId):
+        self._UniqId = UniqId
 
     @property
     def RequestId(self):
@@ -2625,36 +1513,55 @@ class DescribeDashboardResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._ZoneTotal = params.get("ZoneTotal")
-        self._ZoneVpcCount = params.get("ZoneVpcCount")
-        self._RequestTotalCount = params.get("RequestTotalCount")
-        if params.get("FlowUsage") is not None:
-            self._FlowUsage = []
-            for item in params.get("FlowUsage"):
-                obj = FlowUsage()
+        self._ZoneId = params.get("ZoneId")
+        if params.get("VpcSet") is not None:
+            self._VpcSet = []
+            for item in params.get("VpcSet"):
+                obj = VpcInfo()
                 obj._deserialize(item)
-                self._FlowUsage.append(obj)
+                self._VpcSet.append(obj)
+        if params.get("AccountVpcSet") is not None:
+            self._AccountVpcSet = []
+            for item in params.get("AccountVpcSet"):
+                obj = AccountVpcInfo()
+                obj._deserialize(item)
+                self._AccountVpcSet.append(obj)
+        self._UniqId = params.get("UniqId")
         self._RequestId = params.get("RequestId")
 
 
-class DescribeEndPointListRequest(AbstractModel):
-    """DescribeEndPointList请求参数结构体
+class DescribeAccountVpcListRequest(AbstractModel):
+    """DescribeAccountVpcList请求参数结构体
 
     """
 
     def __init__(self):
         r"""
+        :param _AccountUin: 关联账号的uin
+        :type AccountUin: str
         :param _Offset: 分页偏移量，从0开始
         :type Offset: int
         :param _Limit: 分页限制数目， 最大100，默认20
         :type Limit: int
-        :param _Filters: 过滤参数，支持EndPointName,EndPointId,EndPointServiceId,EndPointVip
+        :param _Filters: 过滤参数
         :type Filters: list of Filter
         """
+        self._AccountUin = None
         self._Offset = None
         self._Limit = None
         self._Filters = None
 
+    @property
+    def AccountUin(self):
+        """关联账号的uin
+        :rtype: str
+        """
+        return self._AccountUin
+
+    @AccountUin.setter
+    def AccountUin(self, AccountUin):
+        self._AccountUin = AccountUin
+
     @property
     def Offset(self):
         """分页偏移量，从0开始
@@ -2679,7 +1586,7 @@ class DescribeEndPointListRequest(AbstractModel):
 
     @property
     def Filters(self):
-        """过滤参数，支持EndPointName,EndPointId,EndPointServiceId,EndPointVip
+        """过滤参数
         :rtype: list of Filter
         """
         return self._Filters
@@ -2690,6 +1597,7 @@ class DescribeEndPointListRequest(AbstractModel):
 
 
     def _deserialize(self, params):
+        self._AccountUin = params.get("AccountUin")
         self._Offset = params.get("Offset")
         self._Limit = params.get("Limit")
         if params.get("Filters") is not None:
@@ -2708,28 +1616,27 @@ class DescribeEndPointListRequest(AbstractModel):
         
 
 
-class DescribeEndPointListResponse(AbstractModel):
-    """DescribeEndPointList返回参数结构体
+class DescribeAccountVpcListResponse(AbstractModel):
+    """DescribeAccountVpcList返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _TotalCount: 终端节点总数
+        :param _TotalCount: VPC数量
         :type TotalCount: int
-        :param _EndPointSet: 终端节点列表
-注意：此字段可能返回 null，表示取不到有效值。
-        :type EndPointSet: list of EndPointInfo
+        :param _VpcSet: VPC 列表
+        :type VpcSet: list of AccountVpcInfoOut
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
         self._TotalCount = None
-        self._EndPointSet = None
+        self._VpcSet = None
         self._RequestId = None
 
     @property
     def TotalCount(self):
-        """终端节点总数
+        """VPC数量
         :rtype: int
         """
         return self._TotalCount
@@ -2739,16 +1646,15 @@ class DescribeEndPointListResponse(AbstractModel):
         self._TotalCount = TotalCount
 
     @property
-    def EndPointSet(self):
-        """终端节点列表
-注意：此字段可能返回 null，表示取不到有效值。
-        :rtype: list of EndPointInfo
+    def VpcSet(self):
+        """VPC 列表
+        :rtype: list of AccountVpcInfoOut
         """
-        return self._EndPointSet
+        return self._VpcSet
 
-    @EndPointSet.setter
-    def EndPointSet(self, EndPointSet):
-        self._EndPointSet = EndPointSet
+    @VpcSet.setter
+    def VpcSet(self, VpcSet):
+        self._VpcSet = VpcSet
 
     @property
     def RequestId(self):
@@ -2764,86 +1670,71 @@ class DescribeEndPointListResponse(AbstractModel):
 
     def _deserialize(self, params):
         self._TotalCount = params.get("TotalCount")
-        if params.get("EndPointSet") is not None:
-            self._EndPointSet = []
-            for item in params.get("EndPointSet"):
-                obj = EndPointInfo()
+        if params.get("VpcSet") is not None:
+            self._VpcSet = []
+            for item in params.get("VpcSet"):
+                obj = AccountVpcInfoOut()
                 obj._deserialize(item)
-                self._EndPointSet.append(obj)
+                self._VpcSet.append(obj)
         self._RequestId = params.get("RequestId")
 
 
-class DescribeEndPointRegionRequest(AbstractModel):
-    """DescribeEndPointRegion请求参数结构体
-
-    """
-
-
-class DescribeEndPointRegionResponse(AbstractModel):
-    """DescribeEndPointRegion返回参数结构体
+class DescribeAuditLogRequest(AbstractModel):
+    """DescribeAuditLog请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _RegionSet: 地域数组
-        :type RegionSet: list of RegionInfo
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
+        :param _TimeRangeBegin: 请求量统计起始时间
+        :type TimeRangeBegin: str
+        :param _Filters: 筛选参数：ZoneId：私有域ID；Domain：私有域；OperatorUin：操作者账号ID
+        :type Filters: list of Filter
+        :param _TimeRangeEnd: 请求量统计结束时间
+        :type TimeRangeEnd: str
+        :param _Offset: 分页偏移量，从0开始
+        :type Offset: int
+        :param _Limit: 分页限制数目， 最大100，默认20
+        :type Limit: int
         """
-        self._RegionSet = None
-        self._RequestId = None
+        self._TimeRangeBegin = None
+        self._Filters = None
+        self._TimeRangeEnd = None
+        self._Offset = None
+        self._Limit = None
 
     @property
-    def RegionSet(self):
-        """地域数组
-        :rtype: list of RegionInfo
+    def TimeRangeBegin(self):
+        """请求量统计起始时间
+        :rtype: str
         """
-        return self._RegionSet
+        return self._TimeRangeBegin
 
-    @RegionSet.setter
-    def RegionSet(self, RegionSet):
-        self._RegionSet = RegionSet
+    @TimeRangeBegin.setter
+    def TimeRangeBegin(self, TimeRangeBegin):
+        self._TimeRangeBegin = TimeRangeBegin
 
     @property
-    def RequestId(self):
-        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :rtype: str
+    def Filters(self):
+        """筛选参数：ZoneId：私有域ID；Domain：私有域；OperatorUin：操作者账号ID
+        :rtype: list of Filter
         """
-        return self._RequestId
-
-    @RequestId.setter
-    def RequestId(self, RequestId):
-        self._RequestId = RequestId
-
-
-    def _deserialize(self, params):
-        if params.get("RegionSet") is not None:
-            self._RegionSet = []
-            for item in params.get("RegionSet"):
-                obj = RegionInfo()
-                obj._deserialize(item)
-                self._RegionSet.append(obj)
-        self._RequestId = params.get("RequestId")
-
-
-class DescribeForwardRuleListRequest(AbstractModel):
-    """DescribeForwardRuleList请求参数结构体
+        return self._Filters
 
-    """
+    @Filters.setter
+    def Filters(self, Filters):
+        self._Filters = Filters
 
-    def __init__(self):
-        r"""
-        :param _Offset: 分页偏移量，从0开始
-        :type Offset: int
-        :param _Limit: 分页限制数目， 最大100，默认20
-        :type Limit: int
-        :param _Filters: 过滤参数
-        :type Filters: list of Filter
+    @property
+    def TimeRangeEnd(self):
+        """请求量统计结束时间
+        :rtype: str
         """
-        self._Offset = None
-        self._Limit = None
-        self._Filters = None
+        return self._TimeRangeEnd
+
+    @TimeRangeEnd.setter
+    def TimeRangeEnd(self, TimeRangeEnd):
+        self._TimeRangeEnd = TimeRangeEnd
 
     @property
     def Offset(self):
@@ -2867,27 +1758,18 @@ class DescribeForwardRuleListRequest(AbstractModel):
     def Limit(self, Limit):
         self._Limit = Limit
 
-    @property
-    def Filters(self):
-        """过滤参数
-        :rtype: list of Filter
-        """
-        return self._Filters
-
-    @Filters.setter
-    def Filters(self, Filters):
-        self._Filters = Filters
-
 
     def _deserialize(self, params):
-        self._Offset = params.get("Offset")
-        self._Limit = params.get("Limit")
+        self._TimeRangeBegin = params.get("TimeRangeBegin")
         if params.get("Filters") is not None:
             self._Filters = []
             for item in params.get("Filters"):
                 obj = Filter()
                 obj._deserialize(item)
                 self._Filters.append(obj)
+        self._TimeRangeEnd = params.get("TimeRangeEnd")
+        self._Offset = params.get("Offset")
+        self._Limit = params.get("Limit")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -2898,45 +1780,31 @@ class DescribeForwardRuleListRequest(AbstractModel):
         
 
 
-class DescribeForwardRuleListResponse(AbstractModel):
-    """DescribeForwardRuleList返回参数结构体
+class DescribeAuditLogResponse(AbstractModel):
+    """DescribeAuditLog返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _TotalCount: 私有域数量
-        :type TotalCount: int
-        :param _ForwardRuleSet: 私有域列表
-        :type ForwardRuleSet: list of ForwardRule
+        :param _Data: 操作日志列表
+        :type Data: list of AuditLog
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._TotalCount = None
-        self._ForwardRuleSet = None
+        self._Data = None
         self._RequestId = None
 
     @property
-    def TotalCount(self):
-        """私有域数量
-        :rtype: int
-        """
-        return self._TotalCount
-
-    @TotalCount.setter
-    def TotalCount(self, TotalCount):
-        self._TotalCount = TotalCount
-
-    @property
-    def ForwardRuleSet(self):
-        """私有域列表
-        :rtype: list of ForwardRule
+    def Data(self):
+        """操作日志列表
+        :rtype: list of AuditLog
         """
-        return self._ForwardRuleSet
+        return self._Data
 
-    @ForwardRuleSet.setter
-    def ForwardRuleSet(self, ForwardRuleSet):
-        self._ForwardRuleSet = ForwardRuleSet
+    @Data.setter
+    def Data(self, Data):
+        self._Data = Data
 
     @property
     def RequestId(self):
@@ -2951,77 +1819,88 @@ class DescribeForwardRuleListResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._TotalCount = params.get("TotalCount")
-        if params.get("ForwardRuleSet") is not None:
-            self._ForwardRuleSet = []
-            for item in params.get("ForwardRuleSet"):
-                obj = ForwardRule()
+        if params.get("Data") is not None:
+            self._Data = []
+            for item in params.get("Data"):
+                obj = AuditLog()
                 obj._deserialize(item)
-                self._ForwardRuleSet.append(obj)
+                self._Data.append(obj)
         self._RequestId = params.get("RequestId")
 
 
-class DescribeForwardRuleRequest(AbstractModel):
-    """DescribeForwardRule请求参数结构体
+class DescribeDashboardRequest(AbstractModel):
+    """DescribeDashboard请求参数结构体
+
+    """
+
+
+class DescribeDashboardResponse(AbstractModel):
+    """DescribeDashboard返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _RuleId: 转发规则ID
-        :type RuleId: str
+        :param _ZoneTotal: 私有域解析总数
+        :type ZoneTotal: int
+        :param _ZoneVpcCount: 私有域关联VPC数量
+        :type ZoneVpcCount: int
+        :param _RequestTotalCount: 历史请求量总数
+        :type RequestTotalCount: int
+        :param _FlowUsage: 流量包用量
+        :type FlowUsage: list of FlowUsage
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
         """
-        self._RuleId = None
+        self._ZoneTotal = None
+        self._ZoneVpcCount = None
+        self._RequestTotalCount = None
+        self._FlowUsage = None
+        self._RequestId = None
 
     @property
-    def RuleId(self):
-        """转发规则ID
-        :rtype: str
+    def ZoneTotal(self):
+        """私有域解析总数
+        :rtype: int
         """
-        return self._RuleId
-
-    @RuleId.setter
-    def RuleId(self, RuleId):
-        self._RuleId = RuleId
-
-
-    def _deserialize(self, params):
-        self._RuleId = params.get("RuleId")
-        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))
-        
+        return self._ZoneTotal
 
+    @ZoneTotal.setter
+    def ZoneTotal(self, ZoneTotal):
+        self._ZoneTotal = ZoneTotal
 
-class DescribeForwardRuleResponse(AbstractModel):
-    """DescribeForwardRule返回参数结构体
+    @property
+    def ZoneVpcCount(self):
+        """私有域关联VPC数量
+        :rtype: int
+        """
+        return self._ZoneVpcCount
 
-    """
+    @ZoneVpcCount.setter
+    def ZoneVpcCount(self, ZoneVpcCount):
+        self._ZoneVpcCount = ZoneVpcCount
 
-    def __init__(self):
-        r"""
-        :param _ForwardRule: 转发规则详情
-        :type ForwardRule: :class:`tencentcloud.privatedns.v20201028.models.ForwardRule`
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
+    @property
+    def RequestTotalCount(self):
+        """历史请求量总数
+        :rtype: int
         """
-        self._ForwardRule = None
-        self._RequestId = None
+        return self._RequestTotalCount
+
+    @RequestTotalCount.setter
+    def RequestTotalCount(self, RequestTotalCount):
+        self._RequestTotalCount = RequestTotalCount
 
     @property
-    def ForwardRule(self):
-        """转发规则详情
-        :rtype: :class:`tencentcloud.privatedns.v20201028.models.ForwardRule`
+    def FlowUsage(self):
+        """流量包用量
+        :rtype: list of FlowUsage
         """
-        return self._ForwardRule
+        return self._FlowUsage
 
-    @ForwardRule.setter
-    def ForwardRule(self, ForwardRule):
-        self._ForwardRule = ForwardRule
+    @FlowUsage.setter
+    def FlowUsage(self, FlowUsage):
+        self._FlowUsage = FlowUsage
 
     @property
     def RequestId(self):
@@ -3036,9 +1915,15 @@ class DescribeForwardRuleResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        if params.get("ForwardRule") is not None:
-            self._ForwardRule = ForwardRule()
-            self._ForwardRule._deserialize(params.get("ForwardRule"))
+        self._ZoneTotal = params.get("ZoneTotal")
+        self._ZoneVpcCount = params.get("ZoneVpcCount")
+        self._RequestTotalCount = params.get("RequestTotalCount")
+        if params.get("FlowUsage") is not None:
+            self._FlowUsage = []
+            for item in params.get("FlowUsage"):
+                obj = FlowUsage()
+                obj._deserialize(item)
+                self._FlowUsage.append(obj)
         self._RequestId = params.get("RequestId")
 
 
@@ -3774,448 +2659,113 @@ class DescribeRequestDataResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
-class EndPointInfo(AbstractModel):
-    """终端节点信息
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _EndPointId: 终端节点ID
-        :type EndPointId: str
-        :param _EndPointName: 终端节点名称
-        :type EndPointName: str
-        :param _EndPointServiceId: 终端节点服务ID
-        :type EndPointServiceId: str
-        :param _EndPointVipSet: 终端节点VIP列表
-        :type EndPointVipSet: list of str
-        :param _RegionCode: ap-guangzhou
-注意：此字段可能返回 null，表示取不到有效值。
-        :type RegionCode: str
-        :param _Tags: 标签键值对集合
-注意：此字段可能返回 null，表示取不到有效值。
-        :type Tags: list of TagInfo
-        """
-        self._EndPointId = None
-        self._EndPointName = None
-        self._EndPointServiceId = None
-        self._EndPointVipSet = None
-        self._RegionCode = None
-        self._Tags = None
-
-    @property
-    def EndPointId(self):
-        """终端节点ID
-        :rtype: str
-        """
-        return self._EndPointId
-
-    @EndPointId.setter
-    def EndPointId(self, EndPointId):
-        self._EndPointId = EndPointId
-
-    @property
-    def EndPointName(self):
-        """终端节点名称
-        :rtype: str
-        """
-        return self._EndPointName
-
-    @EndPointName.setter
-    def EndPointName(self, EndPointName):
-        self._EndPointName = EndPointName
-
-    @property
-    def EndPointServiceId(self):
-        """终端节点服务ID
-        :rtype: str
-        """
-        return self._EndPointServiceId
-
-    @EndPointServiceId.setter
-    def EndPointServiceId(self, EndPointServiceId):
-        self._EndPointServiceId = EndPointServiceId
-
-    @property
-    def EndPointVipSet(self):
-        """终端节点VIP列表
-        :rtype: list of str
-        """
-        return self._EndPointVipSet
-
-    @EndPointVipSet.setter
-    def EndPointVipSet(self, EndPointVipSet):
-        self._EndPointVipSet = EndPointVipSet
-
-    @property
-    def RegionCode(self):
-        """ap-guangzhou
-注意：此字段可能返回 null，表示取不到有效值。
-        :rtype: str
-        """
-        return self._RegionCode
-
-    @RegionCode.setter
-    def RegionCode(self, RegionCode):
-        self._RegionCode = RegionCode
-
-    @property
-    def Tags(self):
-        """标签键值对集合
-注意：此字段可能返回 null，表示取不到有效值。
-        :rtype: list of TagInfo
-        """
-        return self._Tags
-
-    @Tags.setter
-    def Tags(self, Tags):
-        self._Tags = Tags
-
-
-    def _deserialize(self, params):
-        self._EndPointId = params.get("EndPointId")
-        self._EndPointName = params.get("EndPointName")
-        self._EndPointServiceId = params.get("EndPointServiceId")
-        self._EndPointVipSet = params.get("EndPointVipSet")
-        self._RegionCode = params.get("RegionCode")
-        if params.get("Tags") is not None:
-            self._Tags = []
-            for item in params.get("Tags"):
-                obj = TagInfo()
-                obj._deserialize(item)
-                self._Tags.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:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
-
-
-class Filter(AbstractModel):
-    """筛选参数
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Name: 参数名
-        :type Name: str
-        :param _Values: 参数值数组
-        :type Values: list of str
-        """
-        self._Name = None
-        self._Values = None
-
-    @property
-    def Name(self):
-        """参数名
-        :rtype: str
-        """
-        return self._Name
-
-    @Name.setter
-    def Name(self, Name):
-        self._Name = Name
-
-    @property
-    def Values(self):
-        """参数值数组
-        :rtype: list of str
-        """
-        return self._Values
-
-    @Values.setter
-    def Values(self, Values):
-        self._Values = Values
-
-
-    def _deserialize(self, params):
-        self._Name = params.get("Name")
-        self._Values = params.get("Values")
-        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 FlowUsage(AbstractModel):
-    """流量包用量
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _FlowType: 流量包类型：ZONE 私有域；TRAFFIC 解析流量包
-        :type FlowType: str
-        :param _TotalQuantity: 流量包总额度
-        :type TotalQuantity: int
-        :param _AvailableQuantity: 流量包可用额度
-        :type AvailableQuantity: int
-        """
-        self._FlowType = None
-        self._TotalQuantity = None
-        self._AvailableQuantity = None
-
-    @property
-    def FlowType(self):
-        """流量包类型：ZONE 私有域；TRAFFIC 解析流量包
-        :rtype: str
-        """
-        return self._FlowType
-
-    @FlowType.setter
-    def FlowType(self, FlowType):
-        self._FlowType = FlowType
-
-    @property
-    def TotalQuantity(self):
-        """流量包总额度
-        :rtype: int
-        """
-        return self._TotalQuantity
-
-    @TotalQuantity.setter
-    def TotalQuantity(self, TotalQuantity):
-        self._TotalQuantity = TotalQuantity
-
-    @property
-    def AvailableQuantity(self):
-        """流量包可用额度
-        :rtype: int
-        """
-        return self._AvailableQuantity
-
-    @AvailableQuantity.setter
-    def AvailableQuantity(self, AvailableQuantity):
-        self._AvailableQuantity = AvailableQuantity
-
-
-    def _deserialize(self, params):
-        self._FlowType = params.get("FlowType")
-        self._TotalQuantity = params.get("TotalQuantity")
-        self._AvailableQuantity = params.get("AvailableQuantity")
-        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 ForwardRule(AbstractModel):
-    """转发规则详情
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Domain: 私有域名
-        :type Domain: str
-        :param _RuleName: 转发规则名称
-        :type RuleName: str
-        :param _RuleId: 规则id
-        :type RuleId: str
-        :param _RuleType: 转发规则类型：云上到云下DOWN、云下到云上DOWN
-        :type RuleType: str
-        :param _CreatedAt: 创建时间
-        :type CreatedAt: str
-        :param _UpdatedAt: 更新时间
-        :type UpdatedAt: str
-        :param _EndPointName: 终端节点名称
-        :type EndPointName: str
-        :param _EndPointId: 终端节点ID
-        :type EndPointId: str
-        :param _ForwardAddress: 转发地址
-        :type ForwardAddress: list of str
-        :param _VpcSet: 私有域绑定的vpc列表
-注意：此字段可能返回 null，表示取不到有效值。
-        :type VpcSet: list of VpcInfo
-        :param _ZoneId: 绑定的私有域ID
-        :type ZoneId: str
-        :param _Tags: 标签
-注意：此字段可能返回 null，表示取不到有效值。
-        :type Tags: list of TagInfo
-        """
-        self._Domain = None
-        self._RuleName = None
-        self._RuleId = None
-        self._RuleType = None
-        self._CreatedAt = None
-        self._UpdatedAt = None
-        self._EndPointName = None
-        self._EndPointId = None
-        self._ForwardAddress = None
-        self._VpcSet = None
-        self._ZoneId = None
-        self._Tags = None
-
-    @property
-    def Domain(self):
-        """私有域名
-        :rtype: str
-        """
-        return self._Domain
-
-    @Domain.setter
-    def Domain(self, Domain):
-        self._Domain = Domain
-
-    @property
-    def RuleName(self):
-        """转发规则名称
-        :rtype: str
-        """
-        return self._RuleName
+class Filter(AbstractModel):
+    """筛选参数
 
-    @RuleName.setter
-    def RuleName(self, RuleName):
-        self._RuleName = RuleName
+    """
 
-    @property
-    def RuleId(self):
-        """规则id
-        :rtype: str
+    def __init__(self):
+        r"""
+        :param _Name: 参数名
+        :type Name: str
+        :param _Values: 参数值数组
+        :type Values: list of str
         """
-        return self._RuleId
-
-    @RuleId.setter
-    def RuleId(self, RuleId):
-        self._RuleId = RuleId
+        self._Name = None
+        self._Values = None
 
     @property
-    def RuleType(self):
-        """转发规则类型：云上到云下DOWN、云下到云上DOWN
+    def Name(self):
+        """参数名
         :rtype: str
         """
-        return self._RuleType
+        return self._Name
 
-    @RuleType.setter
-    def RuleType(self, RuleType):
-        self._RuleType = RuleType
+    @Name.setter
+    def Name(self, Name):
+        self._Name = Name
 
     @property
-    def CreatedAt(self):
-        """创建时间
-        :rtype: str
+    def Values(self):
+        """参数值数组
+        :rtype: list of str
         """
-        return self._CreatedAt
-
-    @CreatedAt.setter
-    def CreatedAt(self, CreatedAt):
-        self._CreatedAt = CreatedAt
+        return self._Values
 
-    @property
-    def UpdatedAt(self):
-        """更新时间
-        :rtype: str
-        """
-        return self._UpdatedAt
+    @Values.setter
+    def Values(self, Values):
+        self._Values = Values
 
-    @UpdatedAt.setter
-    def UpdatedAt(self, UpdatedAt):
-        self._UpdatedAt = UpdatedAt
 
-    @property
-    def EndPointName(self):
-        """终端节点名称
-        :rtype: str
-        """
-        return self._EndPointName
+    def _deserialize(self, params):
+        self._Name = params.get("Name")
+        self._Values = params.get("Values")
+        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))
+        
 
-    @EndPointName.setter
-    def EndPointName(self, EndPointName):
-        self._EndPointName = EndPointName
 
-    @property
-    def EndPointId(self):
-        """终端节点ID
-        :rtype: str
-        """
-        return self._EndPointId
+class FlowUsage(AbstractModel):
+    """流量包用量
 
-    @EndPointId.setter
-    def EndPointId(self, EndPointId):
-        self._EndPointId = EndPointId
+    """
 
-    @property
-    def ForwardAddress(self):
-        """转发地址
-        :rtype: list of str
+    def __init__(self):
+        r"""
+        :param _FlowType: 流量包类型：ZONE 私有域；TRAFFIC 解析流量包
+        :type FlowType: str
+        :param _TotalQuantity: 流量包总额度
+        :type TotalQuantity: int
+        :param _AvailableQuantity: 流量包可用额度
+        :type AvailableQuantity: int
         """
-        return self._ForwardAddress
-
-    @ForwardAddress.setter
-    def ForwardAddress(self, ForwardAddress):
-        self._ForwardAddress = ForwardAddress
+        self._FlowType = None
+        self._TotalQuantity = None
+        self._AvailableQuantity = None
 
     @property
-    def VpcSet(self):
-        """私有域绑定的vpc列表
-注意：此字段可能返回 null，表示取不到有效值。
-        :rtype: list of VpcInfo
+    def FlowType(self):
+        """流量包类型：ZONE 私有域；TRAFFIC 解析流量包
+        :rtype: str
         """
-        return self._VpcSet
+        return self._FlowType
 
-    @VpcSet.setter
-    def VpcSet(self, VpcSet):
-        self._VpcSet = VpcSet
+    @FlowType.setter
+    def FlowType(self, FlowType):
+        self._FlowType = FlowType
 
     @property
-    def ZoneId(self):
-        """绑定的私有域ID
-        :rtype: str
+    def TotalQuantity(self):
+        """流量包总额度
+        :rtype: int
         """
-        return self._ZoneId
+        return self._TotalQuantity
 
-    @ZoneId.setter
-    def ZoneId(self, ZoneId):
-        self._ZoneId = ZoneId
+    @TotalQuantity.setter
+    def TotalQuantity(self, TotalQuantity):
+        self._TotalQuantity = TotalQuantity
 
     @property
-    def Tags(self):
-        """标签
-注意：此字段可能返回 null，表示取不到有效值。
-        :rtype: list of TagInfo
+    def AvailableQuantity(self):
+        """流量包可用额度
+        :rtype: int
         """
-        return self._Tags
+        return self._AvailableQuantity
 
-    @Tags.setter
-    def Tags(self, Tags):
-        self._Tags = Tags
+    @AvailableQuantity.setter
+    def AvailableQuantity(self, AvailableQuantity):
+        self._AvailableQuantity = AvailableQuantity
 
 
     def _deserialize(self, params):
-        self._Domain = params.get("Domain")
-        self._RuleName = params.get("RuleName")
-        self._RuleId = params.get("RuleId")
-        self._RuleType = params.get("RuleType")
-        self._CreatedAt = params.get("CreatedAt")
-        self._UpdatedAt = params.get("UpdatedAt")
-        self._EndPointName = params.get("EndPointName")
-        self._EndPointId = params.get("EndPointId")
-        self._ForwardAddress = params.get("ForwardAddress")
-        if params.get("VpcSet") is not None:
-            self._VpcSet = []
-            for item in params.get("VpcSet"):
-                obj = VpcInfo()
-                obj._deserialize(item)
-                self._VpcSet.append(obj)
-        self._ZoneId = params.get("ZoneId")
-        if params.get("Tags") is not None:
-            self._Tags = []
-            for item in params.get("Tags"):
-                obj = TagInfo()
-                obj._deserialize(item)
-                self._Tags.append(obj)
+        self._FlowType = params.get("FlowType")
+        self._TotalQuantity = params.get("TotalQuantity")
+        self._AvailableQuantity = params.get("AvailableQuantity")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -4314,100 +2864,6 @@ class MetricData(AbstractModel):
         
 
 
-class ModifyForwardRuleRequest(AbstractModel):
-    """ModifyForwardRule请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _RuleId: 转发规则ID
-        :type RuleId: str
-        :param _RuleName: 转发规则名称
-        :type RuleName: str
-        :param _EndPointId: 终端节点ID
-        :type EndPointId: str
-        """
-        self._RuleId = None
-        self._RuleName = None
-        self._EndPointId = None
-
-    @property
-    def RuleId(self):
-        """转发规则ID
-        :rtype: str
-        """
-        return self._RuleId
-
-    @RuleId.setter
-    def RuleId(self, RuleId):
-        self._RuleId = RuleId
-
-    @property
-    def RuleName(self):
-        """转发规则名称
-        :rtype: str
-        """
-        return self._RuleName
-
-    @RuleName.setter
-    def RuleName(self, RuleName):
-        self._RuleName = RuleName
-
-    @property
-    def EndPointId(self):
-        """终端节点ID
-        :rtype: str
-        """
-        return self._EndPointId
-
-    @EndPointId.setter
-    def EndPointId(self, EndPointId):
-        self._EndPointId = EndPointId
-
-
-    def _deserialize(self, params):
-        self._RuleId = params.get("RuleId")
-        self._RuleName = params.get("RuleName")
-        self._EndPointId = params.get("EndPointId")
-        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 ModifyForwardRuleResponse(AbstractModel):
-    """ModifyForwardRule返回参数结构体
-
-    """
-
-    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 ModifyPrivateZoneRecordRequest(AbstractModel):
     """ModifyPrivateZoneRecord请求参数结构体
 
@@ -5716,108 +4172,6 @@ failed 执行失败
         self._RequestId = params.get("RequestId")
 
 
-class RegionInfo(AbstractModel):
-    """地域信息
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _RegionCode: 地域编码
-        :type RegionCode: str
-        :param _CnName: 地域中文名
-注意：此字段可能返回 null，表示取不到有效值。
-        :type CnName: str
-        :param _EnName: 地域英文名
-        :type EnName: str
-        :param _RegionId: 地域ID
-注意：此字段可能返回 null，表示取不到有效值。
-        :type RegionId: int
-        :param _AvailableZoneNum: 可用区数量
-注意：此字段可能返回 null，表示取不到有效值。
-        :type AvailableZoneNum: int
-        """
-        self._RegionCode = None
-        self._CnName = None
-        self._EnName = None
-        self._RegionId = None
-        self._AvailableZoneNum = None
-
-    @property
-    def RegionCode(self):
-        """地域编码
-        :rtype: str
-        """
-        return self._RegionCode
-
-    @RegionCode.setter
-    def RegionCode(self, RegionCode):
-        self._RegionCode = RegionCode
-
-    @property
-    def CnName(self):
-        """地域中文名
-注意：此字段可能返回 null，表示取不到有效值。
-        :rtype: str
-        """
-        return self._CnName
-
-    @CnName.setter
-    def CnName(self, CnName):
-        self._CnName = CnName
-
-    @property
-    def EnName(self):
-        """地域英文名
-        :rtype: str
-        """
-        return self._EnName
-
-    @EnName.setter
-    def EnName(self, EnName):
-        self._EnName = EnName
-
-    @property
-    def RegionId(self):
-        """地域ID
-注意：此字段可能返回 null，表示取不到有效值。
-        :rtype: int
-        """
-        return self._RegionId
-
-    @RegionId.setter
-    def RegionId(self, RegionId):
-        self._RegionId = RegionId
-
-    @property
-    def AvailableZoneNum(self):
-        """可用区数量
-注意：此字段可能返回 null，表示取不到有效值。
-        :rtype: int
-        """
-        return self._AvailableZoneNum
-
-    @AvailableZoneNum.setter
-    def AvailableZoneNum(self, AvailableZoneNum):
-        self._AvailableZoneNum = AvailableZoneNum
-
-
-    def _deserialize(self, params):
-        self._RegionCode = params.get("RegionCode")
-        self._CnName = params.get("CnName")
-        self._EnName = params.get("EnName")
-        self._RegionId = params.get("RegionId")
-        self._AvailableZoneNum = params.get("AvailableZoneNum")
-        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 SubscribePrivateZoneServiceRequest(AbstractModel):
     """SubscribePrivateZoneService请求参数结构体