tencentcloud-sdk-python-postgres 3.1.160__py2.py3-none-any.whl → 3.1.172__py2.py3-none-any.whl

tencentcloud/postgres/v20170312/models.py

@@ -25,27 +25,26 @@ class AccountInfo(AbstractModel):
 
     def __init__(self):
         r"""
-        :param _DBInstanceId: 实例ID，形如postgres-lnp6j617
+        :param _DBInstanceId: <p>实例ID，形如postgres-lnp6j617</p>
         :type DBInstanceId: str
-        :param _UserName: 账号
+        :param _UserName: <p>账号</p>
         :type UserName: str
-        :param _Remark: 账号备注
+        :param _Remark: <p>账号备注</p>
         :type Remark: str
-        :param _Status: 账号状态。 1-创建中，2-正常，3-修改中，4-密码重置中，5-锁定中，-1-删除中
+        :param _Status: <p>账号状态。 1-创建中，2-正常，3-修改中，4-密码重置中，5-锁定中，-1-删除中</p>
         :type Status: int
-        :param _CreateTime: 账号创建时间
+        :param _CreateTime: <p>账号创建时间</p>
         :type CreateTime: str
-        :param _UpdateTime: 账号最后一次更新时间
+        :param _UpdateTime: <p>账号最后一次更新时间</p>
         :type UpdateTime: str
-        :param _PasswordUpdateTime: 账号密码最近一次修改时间。
-
-此字段只在2025-10-31后才生效，之前无论是否修改密码，该值统一为默认值：0000-00-00 00:00:00
-同时仅通过云API或者管控控制台修改密码，才会更新该字段。
+        :param _PasswordUpdateTime: <p>账号密码最近一次修改时间。</p><p>此字段只在2025-10-31后才生效，之前无论是否修改密码，该值统一为默认值：0000-00-00 00:00:00<br>同时仅通过云API或者管控控制台修改密码，才会更新该字段。</p>
         :type PasswordUpdateTime: str
-        :param _UserType: 账号类型。支持normal、tencentDBSuper。normal指代普通用户，tencentDBSuper为拥有pg_tencentdb_superuser角色的账号。
+        :param _UserType: <p>账号类型。支持normal、tencentDBSuper。normal指代普通用户，tencentDBSuper为拥有pg_tencentdb_superuser角色的账号。</p>
         :type UserType: str
-        :param _OpenCam: 用户账号是否启用CAM验证
+        :param _OpenCam: <p>用户账号是否启用CAM验证</p>
         :type OpenCam: bool
+        :param _PGRoles: <p>该账号实际加入了哪些预设角色</p>
+        :type PGRoles: list of str
         """
         self._DBInstanceId = None
         self._UserName = None
@@ -56,10 +55,11 @@ class AccountInfo(AbstractModel):
         self._PasswordUpdateTime = None
         self._UserType = None
         self._OpenCam = None
+        self._PGRoles = None
 
     @property
     def DBInstanceId(self):
-        r"""实例ID，形如postgres-lnp6j617
+        r"""<p>实例ID，形如postgres-lnp6j617</p>
         :rtype: str
         """
         return self._DBInstanceId
@@ -70,7 +70,7 @@ class AccountInfo(AbstractModel):
 
     @property
     def UserName(self):
-        r"""账号
+        r"""<p>账号</p>
         :rtype: str
         """
         return self._UserName
@@ -81,7 +81,7 @@ class AccountInfo(AbstractModel):
 
     @property
     def Remark(self):
-        r"""账号备注
+        r"""<p>账号备注</p>
         :rtype: str
         """
         return self._Remark
@@ -92,7 +92,7 @@ class AccountInfo(AbstractModel):
 
     @property
     def Status(self):
-        r"""账号状态。 1-创建中，2-正常，3-修改中，4-密码重置中，5-锁定中，-1-删除中
+        r"""<p>账号状态。 1-创建中，2-正常，3-修改中，4-密码重置中，5-锁定中，-1-删除中</p>
         :rtype: int
         """
         return self._Status
@@ -103,7 +103,7 @@ class AccountInfo(AbstractModel):
 
     @property
     def CreateTime(self):
-        r"""账号创建时间
+        r"""<p>账号创建时间</p>
         :rtype: str
         """
         return self._CreateTime
@@ -114,7 +114,7 @@ class AccountInfo(AbstractModel):
 
     @property
     def UpdateTime(self):
-        r"""账号最后一次更新时间
+        r"""<p>账号最后一次更新时间</p>
         :rtype: str
         """
         return self._UpdateTime
@@ -125,10 +125,7 @@ class AccountInfo(AbstractModel):
 
     @property
     def PasswordUpdateTime(self):
-        r"""账号密码最近一次修改时间。
-
-此字段只在2025-10-31后才生效，之前无论是否修改密码，该值统一为默认值：0000-00-00 00:00:00
-同时仅通过云API或者管控控制台修改密码，才会更新该字段。
+        r"""<p>账号密码最近一次修改时间。</p><p>此字段只在2025-10-31后才生效，之前无论是否修改密码，该值统一为默认值：0000-00-00 00:00:00<br>同时仅通过云API或者管控控制台修改密码，才会更新该字段。</p>
         :rtype: str
         """
         return self._PasswordUpdateTime
@@ -139,7 +136,7 @@ class AccountInfo(AbstractModel):
 
     @property
     def UserType(self):
-        r"""账号类型。支持normal、tencentDBSuper。normal指代普通用户，tencentDBSuper为拥有pg_tencentdb_superuser角色的账号。
+        r"""<p>账号类型。支持normal、tencentDBSuper。normal指代普通用户，tencentDBSuper为拥有pg_tencentdb_superuser角色的账号。</p>
         :rtype: str
         """
         return self._UserType
@@ -150,7 +147,7 @@ class AccountInfo(AbstractModel):
 
     @property
     def OpenCam(self):
-        r"""用户账号是否启用CAM验证
+        r"""<p>用户账号是否启用CAM验证</p>
         :rtype: bool
         """
         return self._OpenCam
@@ -159,6 +156,17 @@ class AccountInfo(AbstractModel):
     def OpenCam(self, OpenCam):
         self._OpenCam = OpenCam
 
+    @property
+    def PGRoles(self):
+        r"""<p>该账号实际加入了哪些预设角色</p>
+        :rtype: list of str
+        """
+        return self._PGRoles
+
+    @PGRoles.setter
+    def PGRoles(self, PGRoles):
+        self._PGRoles = PGRoles
+
 
     def _deserialize(self, params):
         self._DBInstanceId = params.get("DBInstanceId")
@@ -170,6 +178,7 @@ class AccountInfo(AbstractModel):
         self._PasswordUpdateTime = params.get("PasswordUpdateTime")
         self._UserType = params.get("UserType")
         self._OpenCam = params.get("OpenCam")
+        self._PGRoles = params.get("PGRoles")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -2714,6 +2723,273 @@ class CloseDBExtranetAccessResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class CloseDBProxyAddressRequest(AbstractModel):
+    r"""CloseDBProxyAddress请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DBInstanceId: <p>实例 ID，指定要关闭代理地址的目标实例</p>
+        :type DBInstanceId: str
+        :param _AddressId: <p>代理地址 ID，指定要关闭（删除）的代理地址</p>
+        :type AddressId: str
+        :param _ProxyGroupId: <p>代理组 ID。不传则按实例自动查找其默认代理组</p>
+        :type ProxyGroupId: str
+        """
+        self._DBInstanceId = None
+        self._AddressId = None
+        self._ProxyGroupId = None
+
+    @property
+    def DBInstanceId(self):
+        r"""<p>实例 ID，指定要关闭代理地址的目标实例</p>
+        :rtype: str
+        """
+        return self._DBInstanceId
+
+    @DBInstanceId.setter
+    def DBInstanceId(self, DBInstanceId):
+        self._DBInstanceId = DBInstanceId
+
+    @property
+    def AddressId(self):
+        r"""<p>代理地址 ID，指定要关闭（删除）的代理地址</p>
+        :rtype: str
+        """
+        return self._AddressId
+
+    @AddressId.setter
+    def AddressId(self, AddressId):
+        self._AddressId = AddressId
+
+    @property
+    def ProxyGroupId(self):
+        r"""<p>代理组 ID。不传则按实例自动查找其默认代理组</p>
+        :rtype: str
+        """
+        return self._ProxyGroupId
+
+    @ProxyGroupId.setter
+    def ProxyGroupId(self, ProxyGroupId):
+        self._ProxyGroupId = ProxyGroupId
+
+
+    def _deserialize(self, params):
+        self._DBInstanceId = params.get("DBInstanceId")
+        self._AddressId = params.get("AddressId")
+        self._ProxyGroupId = params.get("ProxyGroupId")
+        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 CloseDBProxyAddressResponse(AbstractModel):
+    r"""CloseDBProxyAddress返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _TaskId: <p>异步任务 ID，可通过 DescribeFlow 查询任务进度</p>
+        :type TaskId: int
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._TaskId = None
+        self._RequestId = None
+
+    @property
+    def TaskId(self):
+        r"""<p>异步任务 ID，可通过 DescribeFlow 查询任务进度</p>
+        :rtype: int
+        """
+        return self._TaskId
+
+    @TaskId.setter
+    def TaskId(self, TaskId):
+        self._TaskId = TaskId
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._TaskId = params.get("TaskId")
+        self._RequestId = params.get("RequestId")
+
+
+class CloseMem0ServiceRequest(AbstractModel):
+    r"""CloseMem0Service请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DBInstanceId: <p>实例ID</p>
+        :type DBInstanceId: str
+        """
+        self._DBInstanceId = None
+
+    @property
+    def DBInstanceId(self):
+        r"""<p>实例ID</p>
+        :rtype: str
+        """
+        return self._DBInstanceId
+
+    @DBInstanceId.setter
+    def DBInstanceId(self, DBInstanceId):
+        self._DBInstanceId = DBInstanceId
+
+
+    def _deserialize(self, params):
+        self._DBInstanceId = params.get("DBInstanceId")
+        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 CloseMem0ServiceResponse(AbstractModel):
+    r"""CloseMem0Service返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _TaskId: <p>关闭mem0服务任务ID</p>
+        :type TaskId: int
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._TaskId = None
+        self._RequestId = None
+
+    @property
+    def TaskId(self):
+        r"""<p>关闭mem0服务任务ID</p>
+        :rtype: int
+        """
+        return self._TaskId
+
+    @TaskId.setter
+    def TaskId(self, TaskId):
+        self._TaskId = TaskId
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._TaskId = params.get("TaskId")
+        self._RequestId = params.get("RequestId")
+
+
+class ClosePostgRESTServiceRequest(AbstractModel):
+    r"""ClosePostgRESTService请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DBInstanceId: <p>实例ID</p><p>参数格式：postgres-0uwjmh8t</p>
+        :type DBInstanceId: str
+        """
+        self._DBInstanceId = None
+
+    @property
+    def DBInstanceId(self):
+        r"""<p>实例ID</p><p>参数格式：postgres-0uwjmh8t</p>
+        :rtype: str
+        """
+        return self._DBInstanceId
+
+    @DBInstanceId.setter
+    def DBInstanceId(self, DBInstanceId):
+        self._DBInstanceId = DBInstanceId
+
+
+    def _deserialize(self, params):
+        self._DBInstanceId = params.get("DBInstanceId")
+        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 ClosePostgRESTServiceResponse(AbstractModel):
+    r"""ClosePostgRESTService返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _TaskId: <p>关闭PostgREST服务任务ID</p>
+        :type TaskId: int
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._TaskId = None
+        self._RequestId = None
+
+    @property
+    def TaskId(self):
+        r"""<p>关闭PostgREST服务任务ID</p>
+        :rtype: int
+        """
+        return self._TaskId
+
+    @TaskId.setter
+    def TaskId(self, TaskId):
+        self._TaskId = TaskId
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._TaskId = params.get("TaskId")
+        self._RequestId = params.get("RequestId")
+
+
 class CreateAccountRequest(AbstractModel):
     r"""CreateAccount请求参数结构体
 
@@ -2976,24 +3252,39 @@ class CreateAuditLogFileResponse(AbstractModel):
 
     def __init__(self):
         r"""
+        :param _FileName: <p>文件名称</p>
+        :type FileName: str
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
+        self._FileName = None
         self._RequestId = None
 
     @property
-    def RequestId(self):
-        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+    def FileName(self):
+        r"""<p>文件名称</p>
         :rtype: str
         """
-        return self._RequestId
+        return self._FileName
 
-    @RequestId.setter
+    @FileName.setter
+    def FileName(self, FileName):
+        self._FileName = FileName
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
     def RequestId(self, RequestId):
         self._RequestId = RequestId
 
 
     def _deserialize(self, params):
+        self._FileName = params.get("FileName")
         self._RequestId = params.get("RequestId")
 
 
@@ -3416,6 +3707,285 @@ class CreateDBInstanceNetworkAccessResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class CreateDBProxyAddressRequest(AbstractModel):
+    r"""CreateDBProxyAddress请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DBInstanceId: <p>实例 ID，指定要创建代理地址的目标实例</p>
+        :type DBInstanceId: str
+        :param _VpcId: <p>VPC ID，代理地址所属的私有网络</p>
+        :type VpcId: str
+        :param _SubnetId: <p>子网 ID，代理地址所属的子网</p>
+        :type SubnetId: str
+        :param _ProxyGroupId: <p>代理组 ID。不传则按实例自动查找其默认代理组</p>
+        :type ProxyGroupId: str
+        :param _SecurityGroup: <p>安全组 ID 列表，用于代理地址的网络安全控制</p>
+        :type SecurityGroup: list of str
+        :param _Description: <p>代理地址备注信息，最长 256 个字符</p>
+        :type Description: str
+        :param _ConnectionPool: <p>连接池开关。true：开启连接池；false：关闭连接池</p>
+        :type ConnectionPool: bool
+        :param _WeightMode: <p>权重模式。取值：<ul><li>system：系统自动分配权重</li><li>custom：手动指定权重，需配合 ProxyAllocation 参数使用</li></ul></p>
+        :type WeightMode: str
+        :param _ProxyAllocation: <p>路由权重列表。WeightMode 为 custom 时必填。若WeightMode传system或不传 ，则传入的权重不生效，由系统分配默认权重。</p>
+        :type ProxyAllocation: list of ProxyRoute
+        :param _RoAutoAdd: <p>是否自动将新增的只读实例加入读写分离。true：自动加入；false：不自动加入</p>
+        :type RoAutoAdd: bool
+        :param _LatencyRemove: <p>延迟剔除开关。true：开启延迟剔除，当只读实例延迟超过阈值时自动剔除路由；false：关闭延迟剔除。开启时 LatencyRemoveTime 必填</p>
+        :type LatencyRemove: bool
+        :param _LatencyRemoveTime: <p>延迟剔除阈值，单位秒，取值范围 [1, 10000]。LatencyRemove 为 true 时必填</p>
+        :type LatencyRemoveTime: int
+        :param _MinRouteNum: <p>最小路由节点数，取值范围 [0, 256]。用于防止延迟剔除将所有节点剔除后的兜底策略</p>
+        :type MinRouteNum: int
+        :param _LoadBalancePolicy: <p>负载均衡策略</p><p>枚举值：</p><ul><li>0： 按活跃连接数(默认)</li><li>1： 按请求数</li></ul>
+        :type LoadBalancePolicy: int
+        """
+        self._DBInstanceId = None
+        self._VpcId = None
+        self._SubnetId = None
+        self._ProxyGroupId = None
+        self._SecurityGroup = None
+        self._Description = None
+        self._ConnectionPool = None
+        self._WeightMode = None
+        self._ProxyAllocation = None
+        self._RoAutoAdd = None
+        self._LatencyRemove = None
+        self._LatencyRemoveTime = None
+        self._MinRouteNum = None
+        self._LoadBalancePolicy = None
+
+    @property
+    def DBInstanceId(self):
+        r"""<p>实例 ID，指定要创建代理地址的目标实例</p>
+        :rtype: str
+        """
+        return self._DBInstanceId
+
+    @DBInstanceId.setter
+    def DBInstanceId(self, DBInstanceId):
+        self._DBInstanceId = DBInstanceId
+
+    @property
+    def VpcId(self):
+        r"""<p>VPC ID，代理地址所属的私有网络</p>
+        :rtype: str
+        """
+        return self._VpcId
+
+    @VpcId.setter
+    def VpcId(self, VpcId):
+        self._VpcId = VpcId
+
+    @property
+    def SubnetId(self):
+        r"""<p>子网 ID，代理地址所属的子网</p>
+        :rtype: str
+        """
+        return self._SubnetId
+
+    @SubnetId.setter
+    def SubnetId(self, SubnetId):
+        self._SubnetId = SubnetId
+
+    @property
+    def ProxyGroupId(self):
+        r"""<p>代理组 ID。不传则按实例自动查找其默认代理组</p>
+        :rtype: str
+        """
+        return self._ProxyGroupId
+
+    @ProxyGroupId.setter
+    def ProxyGroupId(self, ProxyGroupId):
+        self._ProxyGroupId = ProxyGroupId
+
+    @property
+    def SecurityGroup(self):
+        r"""<p>安全组 ID 列表，用于代理地址的网络安全控制</p>
+        :rtype: list of str
+        """
+        return self._SecurityGroup
+
+    @SecurityGroup.setter
+    def SecurityGroup(self, SecurityGroup):
+        self._SecurityGroup = SecurityGroup
+
+    @property
+    def Description(self):
+        r"""<p>代理地址备注信息，最长 256 个字符</p>
+        :rtype: str
+        """
+        return self._Description
+
+    @Description.setter
+    def Description(self, Description):
+        self._Description = Description
+
+    @property
+    def ConnectionPool(self):
+        r"""<p>连接池开关。true：开启连接池；false：关闭连接池</p>
+        :rtype: bool
+        """
+        return self._ConnectionPool
+
+    @ConnectionPool.setter
+    def ConnectionPool(self, ConnectionPool):
+        self._ConnectionPool = ConnectionPool
+
+    @property
+    def WeightMode(self):
+        r"""<p>权重模式。取值：<ul><li>system：系统自动分配权重</li><li>custom：手动指定权重，需配合 ProxyAllocation 参数使用</li></ul></p>
+        :rtype: str
+        """
+        return self._WeightMode
+
+    @WeightMode.setter
+    def WeightMode(self, WeightMode):
+        self._WeightMode = WeightMode
+
+    @property
+    def ProxyAllocation(self):
+        r"""<p>路由权重列表。WeightMode 为 custom 时必填。若WeightMode传system或不传 ，则传入的权重不生效，由系统分配默认权重。</p>
+        :rtype: list of ProxyRoute
+        """
+        return self._ProxyAllocation
+
+    @ProxyAllocation.setter
+    def ProxyAllocation(self, ProxyAllocation):
+        self._ProxyAllocation = ProxyAllocation
+
+    @property
+    def RoAutoAdd(self):
+        r"""<p>是否自动将新增的只读实例加入读写分离。true：自动加入；false：不自动加入</p>
+        :rtype: bool
+        """
+        return self._RoAutoAdd
+
+    @RoAutoAdd.setter
+    def RoAutoAdd(self, RoAutoAdd):
+        self._RoAutoAdd = RoAutoAdd
+
+    @property
+    def LatencyRemove(self):
+        r"""<p>延迟剔除开关。true：开启延迟剔除，当只读实例延迟超过阈值时自动剔除路由；false：关闭延迟剔除。开启时 LatencyRemoveTime 必填</p>
+        :rtype: bool
+        """
+        return self._LatencyRemove
+
+    @LatencyRemove.setter
+    def LatencyRemove(self, LatencyRemove):
+        self._LatencyRemove = LatencyRemove
+
+    @property
+    def LatencyRemoveTime(self):
+        r"""<p>延迟剔除阈值，单位秒，取值范围 [1, 10000]。LatencyRemove 为 true 时必填</p>
+        :rtype: int
+        """
+        return self._LatencyRemoveTime
+
+    @LatencyRemoveTime.setter
+    def LatencyRemoveTime(self, LatencyRemoveTime):
+        self._LatencyRemoveTime = LatencyRemoveTime
+
+    @property
+    def MinRouteNum(self):
+        r"""<p>最小路由节点数，取值范围 [0, 256]。用于防止延迟剔除将所有节点剔除后的兜底策略</p>
+        :rtype: int
+        """
+        return self._MinRouteNum
+
+    @MinRouteNum.setter
+    def MinRouteNum(self, MinRouteNum):
+        self._MinRouteNum = MinRouteNum
+
+    @property
+    def LoadBalancePolicy(self):
+        r"""<p>负载均衡策略</p><p>枚举值：</p><ul><li>0： 按活跃连接数(默认)</li><li>1： 按请求数</li></ul>
+        :rtype: int
+        """
+        return self._LoadBalancePolicy
+
+    @LoadBalancePolicy.setter
+    def LoadBalancePolicy(self, LoadBalancePolicy):
+        self._LoadBalancePolicy = LoadBalancePolicy
+
+
+    def _deserialize(self, params):
+        self._DBInstanceId = params.get("DBInstanceId")
+        self._VpcId = params.get("VpcId")
+        self._SubnetId = params.get("SubnetId")
+        self._ProxyGroupId = params.get("ProxyGroupId")
+        self._SecurityGroup = params.get("SecurityGroup")
+        self._Description = params.get("Description")
+        self._ConnectionPool = params.get("ConnectionPool")
+        self._WeightMode = params.get("WeightMode")
+        if params.get("ProxyAllocation") is not None:
+            self._ProxyAllocation = []
+            for item in params.get("ProxyAllocation"):
+                obj = ProxyRoute()
+                obj._deserialize(item)
+                self._ProxyAllocation.append(obj)
+        self._RoAutoAdd = params.get("RoAutoAdd")
+        self._LatencyRemove = params.get("LatencyRemove")
+        self._LatencyRemoveTime = params.get("LatencyRemoveTime")
+        self._MinRouteNum = params.get("MinRouteNum")
+        self._LoadBalancePolicy = params.get("LoadBalancePolicy")
+        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 CreateDBProxyAddressResponse(AbstractModel):
+    r"""CreateDBProxyAddress返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _TaskId: <p>异步任务 ID。可通过 DescribeTasks 接口查询任务执行进度</p>
+        :type TaskId: int
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._TaskId = None
+        self._RequestId = None
+
+    @property
+    def TaskId(self):
+        r"""<p>异步任务 ID。可通过 DescribeTasks 接口查询任务执行进度</p>
+        :rtype: int
+        """
+        return self._TaskId
+
+    @TaskId.setter
+    def TaskId(self, TaskId):
+        self._TaskId = TaskId
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._TaskId = params.get("TaskId")
+        self._RequestId = params.get("RequestId")
+
+
 class CreateDBProxyRequest(AbstractModel):
     r"""CreateDBProxy请求参数结构体
 
@@ -6586,15 +7156,15 @@ class DatabaseObject(AbstractModel):
 
     def __init__(self):
         r"""
-        :param _ObjectType: 支持使用的数据库对象类型有：account,database,schema,sequence,procedure,type,function,table,view,matview,column。
+        :param _ObjectType: <p>支持使用的数据库对象类型有：account,database,schema,sequence,procedure,type,function,table,view,matview,column。</p>
         :type ObjectType: str
-        :param _ObjectName: 所描述的数据库对象名称
+        :param _ObjectName: <p>所描述的数据库对象名称，或者当ModifyType为grantRole / revokeRole时，必须等于顶层UserName</p>
         :type ObjectName: str
-        :param _DatabaseName: 所要描述的数据库对象，所属的数据库名称。当描述对象类型不为database时，此参数必选。
+        :param _DatabaseName: <p>所要描述的数据库对象，所属的数据库名称。当描述对象类型不为database时，此参数必选。</p>
         :type DatabaseName: str
-        :param _SchemaName: 所要描述的数据库对象，所属的模式名称。当描述对象不为database、schema时，此参数必选。
+        :param _SchemaName: <p>所要描述的数据库对象，所属的模式名称。当描述对象不为database、schema时，此参数必选。</p>
         :type SchemaName: str
-        :param _TableName: 所要描述的数据库对象，所属的表名称。当描述的对象类型为column时，此参数必填。
+        :param _TableName: <p>所要描述的数据库对象，所属的表名称。当描述的对象类型为column时，此参数必填。</p>
         :type TableName: str
         """
         self._ObjectType = None
@@ -6605,7 +7175,7 @@ class DatabaseObject(AbstractModel):
 
     @property
     def ObjectType(self):
-        r"""支持使用的数据库对象类型有：account,database,schema,sequence,procedure,type,function,table,view,matview,column。
+        r"""<p>支持使用的数据库对象类型有：account,database,schema,sequence,procedure,type,function,table,view,matview,column。</p>
         :rtype: str
         """
         return self._ObjectType
@@ -6616,7 +7186,7 @@ class DatabaseObject(AbstractModel):
 
     @property
     def ObjectName(self):
-        r"""所描述的数据库对象名称
+        r"""<p>所描述的数据库对象名称，或者当ModifyType为grantRole / revokeRole时，必须等于顶层UserName</p>
         :rtype: str
         """
         return self._ObjectName
@@ -6627,7 +7197,7 @@ class DatabaseObject(AbstractModel):
 
     @property
     def DatabaseName(self):
-        r"""所要描述的数据库对象，所属的数据库名称。当描述对象类型不为database时，此参数必选。
+        r"""<p>所要描述的数据库对象，所属的数据库名称。当描述对象类型不为database时，此参数必选。</p>
         :rtype: str
         """
         return self._DatabaseName
@@ -6638,7 +7208,7 @@ class DatabaseObject(AbstractModel):
 
     @property
     def SchemaName(self):
-        r"""所要描述的数据库对象，所属的模式名称。当描述对象不为database、schema时，此参数必选。
+        r"""<p>所要描述的数据库对象，所属的模式名称。当描述对象不为database、schema时，此参数必选。</p>
         :rtype: str
         """
         return self._SchemaName
@@ -6649,7 +7219,7 @@ class DatabaseObject(AbstractModel):
 
     @property
     def TableName(self):
-        r"""所要描述的数据库对象，所属的表名称。当描述的对象类型为column时，此参数必填。
+        r"""<p>所要描述的数据库对象，所属的表名称。当描述的对象类型为column时，此参数必填。</p>
         :rtype: str
         """
         return self._TableName
@@ -6682,10 +7252,10 @@ class DatabasePrivilege(AbstractModel):
 
     def __init__(self):
         r"""
-        :param _Object: 数据库对象，当ObjectType为database时，DatabaseName/SchemaName/TableName可为空；当ObjectType为schema时，SchemaName/TableName可为空；当ObjectType为column时，TableName不可为空，其余情况均可为空。
+        :param _Object: <p>数据库对象，当ObjectType为database时，DatabaseName/SchemaName/TableName可为空；当ObjectType为schema时，SchemaName/TableName可为空；当ObjectType为column时，TableName不可为空，其余情况均可为空。</p>
 注意：此字段可能返回 null，表示取不到有效值。
         :type Object: :class:`tencentcloud.postgres.v20170312.models.DatabaseObject`
-        :param _PrivilegeSet: 指定账号对数据库对象拥有的权限列表
+        :param _PrivilegeSet: <p>指定账号对数据库对象拥有的权限列表，或者角色权限修改</p>
 注意：此字段可能返回 null，表示取不到有效值。
         :type PrivilegeSet: list of str
         """
@@ -6694,7 +7264,7 @@ class DatabasePrivilege(AbstractModel):
 
     @property
     def Object(self):
-        r"""数据库对象，当ObjectType为database时，DatabaseName/SchemaName/TableName可为空；当ObjectType为schema时，SchemaName/TableName可为空；当ObjectType为column时，TableName不可为空，其余情况均可为空。
+        r"""<p>数据库对象，当ObjectType为database时，DatabaseName/SchemaName/TableName可为空；当ObjectType为schema时，SchemaName/TableName可为空；当ObjectType为column时，TableName不可为空，其余情况均可为空。</p>
 注意：此字段可能返回 null，表示取不到有效值。
         :rtype: :class:`tencentcloud.postgres.v20170312.models.DatabaseObject`
         """
@@ -6706,7 +7276,7 @@ class DatabasePrivilege(AbstractModel):
 
     @property
     def PrivilegeSet(self):
-        r"""指定账号对数据库对象拥有的权限列表
+        r"""<p>指定账号对数据库对象拥有的权限列表，或者角色权限修改</p>
 注意：此字段可能返回 null，表示取不到有效值。
         :rtype: list of str
         """
@@ -11272,21 +11842,27 @@ class DescribeDBProxyResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
-class DescribeDBProxySpecsRequest(AbstractModel):
-    r"""DescribeDBProxySpecs请求参数结构体
+class DescribeDBProxySSLConfigRequest(AbstractModel):
+    r"""DescribeDBProxySSLConfig请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _DBInstanceId: <p>实例ID。传入时返回该实例的 Proxy 支持情况和可用区</p>
+        :param _DBInstanceId: <p>实例 ID。</p>
         :type DBInstanceId: str
+        :param _ProxyGroupId: <p>代理组 ID。</p>
+        :type ProxyGroupId: str
+        :param _ProxyAddressId: <p>代理连接地址 ID。</p>
+        :type ProxyAddressId: str
         """
         self._DBInstanceId = None
+        self._ProxyGroupId = None
+        self._ProxyAddressId = None
 
     @property
     def DBInstanceId(self):
-        r"""<p>实例ID。传入时返回该实例的 Proxy 支持情况和可用区</p>
+        r"""<p>实例 ID。</p>
         :rtype: str
         """
         return self._DBInstanceId
@@ -11295,9 +11871,33 @@ class DescribeDBProxySpecsRequest(AbstractModel):
     def DBInstanceId(self, DBInstanceId):
         self._DBInstanceId = DBInstanceId
 
+    @property
+    def ProxyGroupId(self):
+        r"""<p>代理组 ID。</p>
+        :rtype: str
+        """
+        return self._ProxyGroupId
+
+    @ProxyGroupId.setter
+    def ProxyGroupId(self, ProxyGroupId):
+        self._ProxyGroupId = ProxyGroupId
+
+    @property
+    def ProxyAddressId(self):
+        r"""<p>代理连接地址 ID。</p>
+        :rtype: str
+        """
+        return self._ProxyAddressId
+
+    @ProxyAddressId.setter
+    def ProxyAddressId(self, ProxyAddressId):
+        self._ProxyAddressId = ProxyAddressId
+
 
     def _deserialize(self, params):
         self._DBInstanceId = params.get("DBInstanceId")
+        self._ProxyGroupId = params.get("ProxyGroupId")
+        self._ProxyAddressId = params.get("ProxyAddressId")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -11308,42 +11908,151 @@ class DescribeDBProxySpecsRequest(AbstractModel):
         
 
 
-class DescribeDBProxySpecsResponse(AbstractModel):
-    r"""DescribeDBProxySpecs返回参数结构体
+class DescribeDBProxySSLConfigResponse(AbstractModel):
+    r"""DescribeDBProxySSLConfig返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _SpecSet: <p>规格列表</p>
-        :type SpecSet: list of ProxySpecItem
-        :param _SupportProxy: <p>该实例是否支持开通 Proxy（仅传 DBInstanceId 时返回）</p>
-        :type SupportProxy: bool
-        :param _AvailableZones: <p>可部署可用区列表（仅传 DBInstanceId 时返回）</p>
-        :type AvailableZones: list of str
+        :param _SSLEnabled: <p>SSL 是否开启。true 表示已开启，false 表示未开启。</p>
+        :type SSLEnabled: bool
+        :param _ConnectAddress: <p>SSL 连接的地址（VIP 或域名）。</p>
+        :type ConnectAddress: str
+        :param _CAUrl: <p>CA 证书下载地址。仅在 SSL 开启时有值。</p>
+        :type CAUrl: str
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._SpecSet = None
-        self._SupportProxy = None
-        self._AvailableZones = None
+        self._SSLEnabled = None
+        self._ConnectAddress = None
+        self._CAUrl = None
         self._RequestId = None
 
     @property
-    def SpecSet(self):
-        r"""<p>规格列表</p>
-        :rtype: list of ProxySpecItem
+    def SSLEnabled(self):
+        r"""<p>SSL 是否开启。true 表示已开启，false 表示未开启。</p>
+        :rtype: bool
         """
-        return self._SpecSet
+        return self._SSLEnabled
 
-    @SpecSet.setter
-    def SpecSet(self, SpecSet):
-        self._SpecSet = SpecSet
+    @SSLEnabled.setter
+    def SSLEnabled(self, SSLEnabled):
+        self._SSLEnabled = SSLEnabled
 
     @property
-    def SupportProxy(self):
-        r"""<p>该实例是否支持开通 Proxy（仅传 DBInstanceId 时返回）</p>
-        :rtype: bool
+    def ConnectAddress(self):
+        r"""<p>SSL 连接的地址（VIP 或域名）。</p>
+        :rtype: str
+        """
+        return self._ConnectAddress
+
+    @ConnectAddress.setter
+    def ConnectAddress(self, ConnectAddress):
+        self._ConnectAddress = ConnectAddress
+
+    @property
+    def CAUrl(self):
+        r"""<p>CA 证书下载地址。仅在 SSL 开启时有值。</p>
+        :rtype: str
+        """
+        return self._CAUrl
+
+    @CAUrl.setter
+    def CAUrl(self, CAUrl):
+        self._CAUrl = CAUrl
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._SSLEnabled = params.get("SSLEnabled")
+        self._ConnectAddress = params.get("ConnectAddress")
+        self._CAUrl = params.get("CAUrl")
+        self._RequestId = params.get("RequestId")
+
+
+class DescribeDBProxySpecsRequest(AbstractModel):
+    r"""DescribeDBProxySpecs请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DBInstanceId: <p>实例ID。传入时返回该实例的 Proxy 支持情况和可用区</p>
+        :type DBInstanceId: str
+        """
+        self._DBInstanceId = None
+
+    @property
+    def DBInstanceId(self):
+        r"""<p>实例ID。传入时返回该实例的 Proxy 支持情况和可用区</p>
+        :rtype: str
+        """
+        return self._DBInstanceId
+
+    @DBInstanceId.setter
+    def DBInstanceId(self, DBInstanceId):
+        self._DBInstanceId = DBInstanceId
+
+
+    def _deserialize(self, params):
+        self._DBInstanceId = params.get("DBInstanceId")
+        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 DescribeDBProxySpecsResponse(AbstractModel):
+    r"""DescribeDBProxySpecs返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _SpecSet: <p>规格列表</p>
+        :type SpecSet: list of ProxySpecItem
+        :param _SupportProxy: <p>该实例是否支持开通 Proxy（仅传 DBInstanceId 时返回）</p>
+        :type SupportProxy: bool
+        :param _AvailableZones: <p>可部署可用区列表（仅传 DBInstanceId 时返回）</p>
+        :type AvailableZones: list of str
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._SpecSet = None
+        self._SupportProxy = None
+        self._AvailableZones = None
+        self._RequestId = None
+
+    @property
+    def SpecSet(self):
+        r"""<p>规格列表</p>
+        :rtype: list of ProxySpecItem
+        """
+        return self._SpecSet
+
+    @SpecSet.setter
+    def SpecSet(self, SpecSet):
+        self._SpecSet = SpecSet
+
+    @property
+    def SupportProxy(self):
+        r"""<p>该实例是否支持开通 Proxy（仅传 DBInstanceId 时返回）</p>
+        :rtype: bool
         """
         return self._SupportProxy
 
@@ -12598,6 +13307,255 @@ class DescribeMaintainTimeWindowResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class DescribeMem0ServiceRequest(AbstractModel):
+    r"""DescribeMem0Service请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DBInstanceId: <p>实例ID</p>
+        :type DBInstanceId: str
+        """
+        self._DBInstanceId = None
+
+    @property
+    def DBInstanceId(self):
+        r"""<p>实例ID</p>
+        :rtype: str
+        """
+        return self._DBInstanceId
+
+    @DBInstanceId.setter
+    def DBInstanceId(self, DBInstanceId):
+        self._DBInstanceId = DBInstanceId
+
+
+    def _deserialize(self, params):
+        self._DBInstanceId = params.get("DBInstanceId")
+        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 DescribeMem0ServiceResponse(AbstractModel):
+    r"""DescribeMem0Service返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Status: <p>mem0服务运行状态</p><p>枚举值：</p><ul><li>running： mem0服务正常运行</li><li>none： 未开通</li><li>creating： 正在开通</li><li>deleting： mem0服务关闭中</li></ul>
+        :type Status: str
+        :param _CreateTime: <p>Mem0服务创建时间</p>
+        :type CreateTime: str
+        :param _UpdateTime: <p>Mem0服务最后更新时间</p>
+        :type UpdateTime: str
+        :param _InnerAddress: <p>Mem0服务访问地址</p>
+        :type InnerAddress: str
+        :param _AgenticBaseId: <p>Mem0服务使用的AgenticBase</p>
+        :type AgenticBaseId: str
+        :param _LLMMode: <p>Mem0服务使用的LLM提供方</p><p>枚举值：</p><ul><li>tokenhub： 腾讯云大模型服务平台TokenHub</li></ul>
+        :type LLMMode: str
+        :param _LLMModel: <p>Mem0服务使用的LLM模型</p>
+        :type LLMModel: str
+        :param _EmbeddingModel: <p>Mem0服务当前使用的Embedding 模型</p>
+        :type EmbeddingModel: str
+        :param _EmbeddingDims: <p>Embedding 向量维度，目前固定1024</p>
+        :type EmbeddingDims: int
+        :param _PGDatabaseName: <p>Mem0服务使用的PG数据库</p>
+        :type PGDatabaseName: str
+        :param _PGUserName: <p>Mem0服务使用的PG用户名</p>
+        :type PGUserName: str
+        :param _NetworkAccessList: <p>Mem0的网络状态</p>
+        :type NetworkAccessList: list of DBInstanceNetInfo
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._Status = None
+        self._CreateTime = None
+        self._UpdateTime = None
+        self._InnerAddress = None
+        self._AgenticBaseId = None
+        self._LLMMode = None
+        self._LLMModel = None
+        self._EmbeddingModel = None
+        self._EmbeddingDims = None
+        self._PGDatabaseName = None
+        self._PGUserName = None
+        self._NetworkAccessList = None
+        self._RequestId = None
+
+    @property
+    def Status(self):
+        r"""<p>mem0服务运行状态</p><p>枚举值：</p><ul><li>running： mem0服务正常运行</li><li>none： 未开通</li><li>creating： 正在开通</li><li>deleting： mem0服务关闭中</li></ul>
+        :rtype: str
+        """
+        return self._Status
+
+    @Status.setter
+    def Status(self, Status):
+        self._Status = Status
+
+    @property
+    def CreateTime(self):
+        r"""<p>Mem0服务创建时间</p>
+        :rtype: str
+        """
+        return self._CreateTime
+
+    @CreateTime.setter
+    def CreateTime(self, CreateTime):
+        self._CreateTime = CreateTime
+
+    @property
+    def UpdateTime(self):
+        r"""<p>Mem0服务最后更新时间</p>
+        :rtype: str
+        """
+        return self._UpdateTime
+
+    @UpdateTime.setter
+    def UpdateTime(self, UpdateTime):
+        self._UpdateTime = UpdateTime
+
+    @property
+    def InnerAddress(self):
+        r"""<p>Mem0服务访问地址</p>
+        :rtype: str
+        """
+        return self._InnerAddress
+
+    @InnerAddress.setter
+    def InnerAddress(self, InnerAddress):
+        self._InnerAddress = InnerAddress
+
+    @property
+    def AgenticBaseId(self):
+        r"""<p>Mem0服务使用的AgenticBase</p>
+        :rtype: str
+        """
+        return self._AgenticBaseId
+
+    @AgenticBaseId.setter
+    def AgenticBaseId(self, AgenticBaseId):
+        self._AgenticBaseId = AgenticBaseId
+
+    @property
+    def LLMMode(self):
+        r"""<p>Mem0服务使用的LLM提供方</p><p>枚举值：</p><ul><li>tokenhub： 腾讯云大模型服务平台TokenHub</li></ul>
+        :rtype: str
+        """
+        return self._LLMMode
+
+    @LLMMode.setter
+    def LLMMode(self, LLMMode):
+        self._LLMMode = LLMMode
+
+    @property
+    def LLMModel(self):
+        r"""<p>Mem0服务使用的LLM模型</p>
+        :rtype: str
+        """
+        return self._LLMModel
+
+    @LLMModel.setter
+    def LLMModel(self, LLMModel):
+        self._LLMModel = LLMModel
+
+    @property
+    def EmbeddingModel(self):
+        r"""<p>Mem0服务当前使用的Embedding 模型</p>
+        :rtype: str
+        """
+        return self._EmbeddingModel
+
+    @EmbeddingModel.setter
+    def EmbeddingModel(self, EmbeddingModel):
+        self._EmbeddingModel = EmbeddingModel
+
+    @property
+    def EmbeddingDims(self):
+        r"""<p>Embedding 向量维度，目前固定1024</p>
+        :rtype: int
+        """
+        return self._EmbeddingDims
+
+    @EmbeddingDims.setter
+    def EmbeddingDims(self, EmbeddingDims):
+        self._EmbeddingDims = EmbeddingDims
+
+    @property
+    def PGDatabaseName(self):
+        r"""<p>Mem0服务使用的PG数据库</p>
+        :rtype: str
+        """
+        return self._PGDatabaseName
+
+    @PGDatabaseName.setter
+    def PGDatabaseName(self, PGDatabaseName):
+        self._PGDatabaseName = PGDatabaseName
+
+    @property
+    def PGUserName(self):
+        r"""<p>Mem0服务使用的PG用户名</p>
+        :rtype: str
+        """
+        return self._PGUserName
+
+    @PGUserName.setter
+    def PGUserName(self, PGUserName):
+        self._PGUserName = PGUserName
+
+    @property
+    def NetworkAccessList(self):
+        r"""<p>Mem0的网络状态</p>
+        :rtype: list of DBInstanceNetInfo
+        """
+        return self._NetworkAccessList
+
+    @NetworkAccessList.setter
+    def NetworkAccessList(self, NetworkAccessList):
+        self._NetworkAccessList = NetworkAccessList
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._Status = params.get("Status")
+        self._CreateTime = params.get("CreateTime")
+        self._UpdateTime = params.get("UpdateTime")
+        self._InnerAddress = params.get("InnerAddress")
+        self._AgenticBaseId = params.get("AgenticBaseId")
+        self._LLMMode = params.get("LLMMode")
+        self._LLMModel = params.get("LLMModel")
+        self._EmbeddingModel = params.get("EmbeddingModel")
+        self._EmbeddingDims = params.get("EmbeddingDims")
+        self._PGDatabaseName = params.get("PGDatabaseName")
+        self._PGUserName = params.get("PGUserName")
+        if params.get("NetworkAccessList") is not None:
+            self._NetworkAccessList = []
+            for item in params.get("NetworkAccessList"):
+                obj = DBInstanceNetInfo()
+                obj._deserialize(item)
+                self._NetworkAccessList.append(obj)
+        self._RequestId = params.get("RequestId")
+
+
 class DescribeOrdersRequest(AbstractModel):
     r"""DescribeOrders请求参数结构体
 
@@ -13028,30 +13986,129 @@ class DescribeParameterTemplatesResponse(AbstractModel):
 
     def _deserialize(self, params):
         self._TotalCount = params.get("TotalCount")
-        if params.get("ParameterTemplateSet") is not None:
-            self._ParameterTemplateSet = []
-            for item in params.get("ParameterTemplateSet"):
-                obj = ParameterTemplate()
+        if params.get("ParameterTemplateSet") is not None:
+            self._ParameterTemplateSet = []
+            for item in params.get("ParameterTemplateSet"):
+                obj = ParameterTemplate()
+                obj._deserialize(item)
+                self._ParameterTemplateSet.append(obj)
+        self._RequestId = params.get("RequestId")
+
+
+class DescribeParamsEventRequest(AbstractModel):
+    r"""DescribeParamsEvent请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DBInstanceId: 实例ID。可通过[DescribeDBInstances](https://cloud.tencent.com/document/api/409/16773)接口获取
+        :type DBInstanceId: str
+        """
+        self._DBInstanceId = None
+
+    @property
+    def DBInstanceId(self):
+        r"""实例ID。可通过[DescribeDBInstances](https://cloud.tencent.com/document/api/409/16773)接口获取
+        :rtype: str
+        """
+        return self._DBInstanceId
+
+    @DBInstanceId.setter
+    def DBInstanceId(self, DBInstanceId):
+        self._DBInstanceId = DBInstanceId
+
+
+    def _deserialize(self, params):
+        self._DBInstanceId = params.get("DBInstanceId")
+        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 DescribeParamsEventResponse(AbstractModel):
+    r"""DescribeParamsEvent返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _TotalCount: 参数修改事件总数，以参数为统计粒度
+        :type TotalCount: int
+        :param _EventItems: 实例参数修改事件详情
+        :type EventItems: list of EventItem
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._TotalCount = None
+        self._EventItems = None
+        self._RequestId = None
+
+    @property
+    def TotalCount(self):
+        r"""参数修改事件总数，以参数为统计粒度
+        :rtype: int
+        """
+        return self._TotalCount
+
+    @TotalCount.setter
+    def TotalCount(self, TotalCount):
+        self._TotalCount = TotalCount
+
+    @property
+    def EventItems(self):
+        r"""实例参数修改事件详情
+        :rtype: list of EventItem
+        """
+        return self._EventItems
+
+    @EventItems.setter
+    def EventItems(self, EventItems):
+        self._EventItems = EventItems
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 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("EventItems") is not None:
+            self._EventItems = []
+            for item in params.get("EventItems"):
+                obj = EventItem()
                 obj._deserialize(item)
-                self._ParameterTemplateSet.append(obj)
+                self._EventItems.append(obj)
         self._RequestId = params.get("RequestId")
 
 
-class DescribeParamsEventRequest(AbstractModel):
-    r"""DescribeParamsEvent请求参数结构体
+class DescribePostgRESTServiceRequest(AbstractModel):
+    r"""DescribePostgRESTService请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _DBInstanceId: 实例ID。可通过[DescribeDBInstances](https://cloud.tencent.com/document/api/409/16773)接口获取
+        :param _DBInstanceId: <p>实例ID</p><p>参数格式：postgres-19nmz2xb</p>
         :type DBInstanceId: str
         """
         self._DBInstanceId = None
 
     @property
     def DBInstanceId(self):
-        r"""实例ID。可通过[DescribeDBInstances](https://cloud.tencent.com/document/api/409/16773)接口获取
+        r"""<p>实例ID</p><p>参数格式：postgres-19nmz2xb</p>
         :rtype: str
         """
         return self._DBInstanceId
@@ -13073,45 +14130,77 @@ class DescribeParamsEventRequest(AbstractModel):
         
 
 
-class DescribeParamsEventResponse(AbstractModel):
-    r"""DescribeParamsEvent返回参数结构体
+class DescribePostgRESTServiceResponse(AbstractModel):
+    r"""DescribePostgRESTService返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _TotalCount: 参数修改事件总数，以参数为统计粒度
-        :type TotalCount: int
-        :param _EventItems: 实例参数修改事件详情
-        :type EventItems: list of EventItem
+        :param _Status: <p>PostgREST服务运行状态</p><p>枚举值：</p><ul><li>closed： 已关闭</li><li>creating： 创建中</li><li>running： 运行中</li></ul><p>默认值：closed</p>
+        :type Status: str
+        :param _CreateTime: <p>创建时间</p><p>参数格式：2026-05-10 10:00:00</p>
+        :type CreateTime: str
+        :param _NetworkAccessList: <p>PostgREST服务网络连接信息</p>
+注意：此字段可能返回 null，表示取不到有效值。
+        :type NetworkAccessList: list of DBInstanceNetInfo
+        :param _JWTSecret: <p>PostgREST服务JWT值</p>
+注意：此字段可能返回 null，表示取不到有效值。
+        :type JWTSecret: str
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._TotalCount = None
-        self._EventItems = None
+        self._Status = None
+        self._CreateTime = None
+        self._NetworkAccessList = None
+        self._JWTSecret = None
         self._RequestId = None
 
     @property
-    def TotalCount(self):
-        r"""参数修改事件总数，以参数为统计粒度
-        :rtype: int
+    def Status(self):
+        r"""<p>PostgREST服务运行状态</p><p>枚举值：</p><ul><li>closed： 已关闭</li><li>creating： 创建中</li><li>running： 运行中</li></ul><p>默认值：closed</p>
+        :rtype: str
         """
-        return self._TotalCount
+        return self._Status
 
-    @TotalCount.setter
-    def TotalCount(self, TotalCount):
-        self._TotalCount = TotalCount
+    @Status.setter
+    def Status(self, Status):
+        self._Status = Status
 
     @property
-    def EventItems(self):
-        r"""实例参数修改事件详情
-        :rtype: list of EventItem
+    def CreateTime(self):
+        r"""<p>创建时间</p><p>参数格式：2026-05-10 10:00:00</p>
+        :rtype: str
         """
-        return self._EventItems
+        return self._CreateTime
 
-    @EventItems.setter
-    def EventItems(self, EventItems):
-        self._EventItems = EventItems
+    @CreateTime.setter
+    def CreateTime(self, CreateTime):
+        self._CreateTime = CreateTime
+
+    @property
+    def NetworkAccessList(self):
+        r"""<p>PostgREST服务网络连接信息</p>
+注意：此字段可能返回 null，表示取不到有效值。
+        :rtype: list of DBInstanceNetInfo
+        """
+        return self._NetworkAccessList
+
+    @NetworkAccessList.setter
+    def NetworkAccessList(self, NetworkAccessList):
+        self._NetworkAccessList = NetworkAccessList
+
+    @property
+    def JWTSecret(self):
+        r"""<p>PostgREST服务JWT值</p>
+注意：此字段可能返回 null，表示取不到有效值。
+        :rtype: str
+        """
+        return self._JWTSecret
+
+    @JWTSecret.setter
+    def JWTSecret(self, JWTSecret):
+        self._JWTSecret = JWTSecret
 
     @property
     def RequestId(self):
@@ -13126,13 +14215,15 @@ class DescribeParamsEventResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._TotalCount = params.get("TotalCount")
-        if params.get("EventItems") is not None:
-            self._EventItems = []
-            for item in params.get("EventItems"):
-                obj = EventItem()
+        self._Status = params.get("Status")
+        self._CreateTime = params.get("CreateTime")
+        if params.get("NetworkAccessList") is not None:
+            self._NetworkAccessList = []
+            for item in params.get("NetworkAccessList"):
+                obj = DBInstanceNetInfo()
                 obj._deserialize(item)
-                self._EventItems.append(obj)
+                self._NetworkAccessList.append(obj)
+        self._JWTSecret = params.get("JWTSecret")
         self._RequestId = params.get("RequestId")
 
 
@@ -18416,12 +19507,33 @@ class ModifyDBProxyAddressRequest(AbstractModel):
         :type Description: str
         :param _ConnectionPool: <p>连接池开关</p><p>枚举值：</p><ul><li>true： 开启</li><li>false： 关闭</li></ul>
         :type ConnectionPool: bool
+        :param _WeightMode: <p>权重模式</p><p>枚举值：</p><ul><li>system： 系统自动分配权重</li><li>custom： 自定义权重，此模式下ProxyAllocation参数必传</li></ul><p>默认值：system</p>
+        :type WeightMode: str
+        :param _ProxyAllocation: <p>system</p><p>入参限制：路由权重列表。若 WeightMode 传的是system或不传 ，则传入的权重不生效，由系统分配默认权重。</p>
+        :type ProxyAllocation: list of ProxyRoute
+        :param _RoAutoAdd: <p>新增只读实例是否自动加入当前连接地址，仅后续新建实例生效</p>
+        :type RoAutoAdd: bool
+        :param _LatencyRemove: <p>延迟剔除开关</p>
+        :type LatencyRemove: bool
+        :param _LatencyRemoveTime: <p>延迟剔除阈值，仅在延迟剔除开关打开时有效</p><p>单位：秒</p>
+        :type LatencyRemoveTime: int
+        :param _MinRouteNum: <p>最小保留路由数。在延迟/故障剔除时，至少保留的路由数量，防止所有节点被剔除导致服务不可用。</p>
+        :type MinRouteNum: int
+        :param _LoadBalancePolicy: <p>负载均衡策略</p><p>枚举值：</p><ul><li>0： 按活跃连接数(默认)</li><li>1： 按请求数</li></ul>
+        :type LoadBalancePolicy: int
         """
         self._DBInstanceId = None
         self._AddressId = None
         self._ProxyGroupId = None
         self._Description = None
         self._ConnectionPool = None
+        self._WeightMode = None
+        self._ProxyAllocation = None
+        self._RoAutoAdd = None
+        self._LatencyRemove = None
+        self._LatencyRemoveTime = None
+        self._MinRouteNum = None
+        self._LoadBalancePolicy = None
 
     @property
     def DBInstanceId(self):
@@ -18478,6 +19590,83 @@ class ModifyDBProxyAddressRequest(AbstractModel):
     def ConnectionPool(self, ConnectionPool):
         self._ConnectionPool = ConnectionPool
 
+    @property
+    def WeightMode(self):
+        r"""<p>权重模式</p><p>枚举值：</p><ul><li>system： 系统自动分配权重</li><li>custom： 自定义权重，此模式下ProxyAllocation参数必传</li></ul><p>默认值：system</p>
+        :rtype: str
+        """
+        return self._WeightMode
+
+    @WeightMode.setter
+    def WeightMode(self, WeightMode):
+        self._WeightMode = WeightMode
+
+    @property
+    def ProxyAllocation(self):
+        r"""<p>system</p><p>入参限制：路由权重列表。若 WeightMode 传的是system或不传 ，则传入的权重不生效，由系统分配默认权重。</p>
+        :rtype: list of ProxyRoute
+        """
+        return self._ProxyAllocation
+
+    @ProxyAllocation.setter
+    def ProxyAllocation(self, ProxyAllocation):
+        self._ProxyAllocation = ProxyAllocation
+
+    @property
+    def RoAutoAdd(self):
+        r"""<p>新增只读实例是否自动加入当前连接地址，仅后续新建实例生效</p>
+        :rtype: bool
+        """
+        return self._RoAutoAdd
+
+    @RoAutoAdd.setter
+    def RoAutoAdd(self, RoAutoAdd):
+        self._RoAutoAdd = RoAutoAdd
+
+    @property
+    def LatencyRemove(self):
+        r"""<p>延迟剔除开关</p>
+        :rtype: bool
+        """
+        return self._LatencyRemove
+
+    @LatencyRemove.setter
+    def LatencyRemove(self, LatencyRemove):
+        self._LatencyRemove = LatencyRemove
+
+    @property
+    def LatencyRemoveTime(self):
+        r"""<p>延迟剔除阈值，仅在延迟剔除开关打开时有效</p><p>单位：秒</p>
+        :rtype: int
+        """
+        return self._LatencyRemoveTime
+
+    @LatencyRemoveTime.setter
+    def LatencyRemoveTime(self, LatencyRemoveTime):
+        self._LatencyRemoveTime = LatencyRemoveTime
+
+    @property
+    def MinRouteNum(self):
+        r"""<p>最小保留路由数。在延迟/故障剔除时，至少保留的路由数量，防止所有节点被剔除导致服务不可用。</p>
+        :rtype: int
+        """
+        return self._MinRouteNum
+
+    @MinRouteNum.setter
+    def MinRouteNum(self, MinRouteNum):
+        self._MinRouteNum = MinRouteNum
+
+    @property
+    def LoadBalancePolicy(self):
+        r"""<p>负载均衡策略</p><p>枚举值：</p><ul><li>0： 按活跃连接数(默认)</li><li>1： 按请求数</li></ul>
+        :rtype: int
+        """
+        return self._LoadBalancePolicy
+
+    @LoadBalancePolicy.setter
+    def LoadBalancePolicy(self, LoadBalancePolicy):
+        self._LoadBalancePolicy = LoadBalancePolicy
+
 
     def _deserialize(self, params):
         self._DBInstanceId = params.get("DBInstanceId")
@@ -18485,6 +19674,18 @@ class ModifyDBProxyAddressRequest(AbstractModel):
         self._ProxyGroupId = params.get("ProxyGroupId")
         self._Description = params.get("Description")
         self._ConnectionPool = params.get("ConnectionPool")
+        self._WeightMode = params.get("WeightMode")
+        if params.get("ProxyAllocation") is not None:
+            self._ProxyAllocation = []
+            for item in params.get("ProxyAllocation"):
+                obj = ProxyRoute()
+                obj._deserialize(item)
+                self._ProxyAllocation.append(obj)
+        self._RoAutoAdd = params.get("RoAutoAdd")
+        self._LatencyRemove = params.get("LatencyRemove")
+        self._LatencyRemoveTime = params.get("LatencyRemoveTime")
+        self._MinRouteNum = params.get("MinRouteNum")
+        self._LoadBalancePolicy = params.get("LoadBalancePolicy")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -18502,11 +19703,25 @@ class ModifyDBProxyAddressResponse(AbstractModel):
 
     def __init__(self):
         r"""
+        :param _TaskId: <p>异步任务 ID，用于 DescribeTasks 查询进度</p>
+        :type TaskId: int
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
+        self._TaskId = None
         self._RequestId = None
 
+    @property
+    def TaskId(self):
+        r"""<p>异步任务 ID，用于 DescribeTasks 查询进度</p>
+        :rtype: int
+        """
+        return self._TaskId
+
+    @TaskId.setter
+    def TaskId(self, TaskId):
+        self._TaskId = TaskId
+
     @property
     def RequestId(self):
         r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
@@ -18520,6 +19735,7 @@ class ModifyDBProxyAddressResponse(AbstractModel):
 
 
     def _deserialize(self, params):
+        self._TaskId = params.get("TaskId")
         self._RequestId = params.get("RequestId")
 
 
@@ -18681,19 +19897,158 @@ class ModifyDBProxyResponse(AbstractModel):
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._DealName = None
+        self._DealName = None
+        self._RequestId = None
+
+    @property
+    def DealName(self):
+        r"""<p>订单号，仅变配（节点规格/数量变更）下单成功时返回；仅修改 Description 时不下单，本字段为空。</p>
+        :rtype: str
+        """
+        return self._DealName
+
+    @DealName.setter
+    def DealName(self, DealName):
+        self._DealName = DealName
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._DealName = params.get("DealName")
+        self._RequestId = params.get("RequestId")
+
+
+class ModifyDBProxySSLConfigRequest(AbstractModel):
+    r"""ModifyDBProxySSLConfig请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DBInstanceId: 实例 ID，指定要修改 SSL 配置的数据库代理所属的目标实例
+        :type DBInstanceId: str
+        :param _ProxyGroupId: 代理组 ID，指定要修改 SSL 配置的代理组
+        :type ProxyGroupId: str
+        :param _ProxyAddressId: 代理地址 ID，指定要修改 SSL 配置的代理连接地址
+        :type ProxyAddressId: str
+        :param _SSLEnabled: SSL 开关。true：开启 SSL；false：关闭 SSL
+        :type SSLEnabled: bool
+        :param _ConnectAddress: 连接地址。SSLEnabled 为 true 时必填，需与代理地址的 Vip 保持一致，用于 SSL 证书校验
+        :type ConnectAddress: str
+        """
+        self._DBInstanceId = None
+        self._ProxyGroupId = None
+        self._ProxyAddressId = None
+        self._SSLEnabled = None
+        self._ConnectAddress = None
+
+    @property
+    def DBInstanceId(self):
+        r"""实例 ID，指定要修改 SSL 配置的数据库代理所属的目标实例
+        :rtype: str
+        """
+        return self._DBInstanceId
+
+    @DBInstanceId.setter
+    def DBInstanceId(self, DBInstanceId):
+        self._DBInstanceId = DBInstanceId
+
+    @property
+    def ProxyGroupId(self):
+        r"""代理组 ID，指定要修改 SSL 配置的代理组
+        :rtype: str
+        """
+        return self._ProxyGroupId
+
+    @ProxyGroupId.setter
+    def ProxyGroupId(self, ProxyGroupId):
+        self._ProxyGroupId = ProxyGroupId
+
+    @property
+    def ProxyAddressId(self):
+        r"""代理地址 ID，指定要修改 SSL 配置的代理连接地址
+        :rtype: str
+        """
+        return self._ProxyAddressId
+
+    @ProxyAddressId.setter
+    def ProxyAddressId(self, ProxyAddressId):
+        self._ProxyAddressId = ProxyAddressId
+
+    @property
+    def SSLEnabled(self):
+        r"""SSL 开关。true：开启 SSL；false：关闭 SSL
+        :rtype: bool
+        """
+        return self._SSLEnabled
+
+    @SSLEnabled.setter
+    def SSLEnabled(self, SSLEnabled):
+        self._SSLEnabled = SSLEnabled
+
+    @property
+    def ConnectAddress(self):
+        r"""连接地址。SSLEnabled 为 true 时必填，需与代理地址的 Vip 保持一致，用于 SSL 证书校验
+        :rtype: str
+        """
+        return self._ConnectAddress
+
+    @ConnectAddress.setter
+    def ConnectAddress(self, ConnectAddress):
+        self._ConnectAddress = ConnectAddress
+
+
+    def _deserialize(self, params):
+        self._DBInstanceId = params.get("DBInstanceId")
+        self._ProxyGroupId = params.get("ProxyGroupId")
+        self._ProxyAddressId = params.get("ProxyAddressId")
+        self._SSLEnabled = params.get("SSLEnabled")
+        self._ConnectAddress = params.get("ConnectAddress")
+        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 ModifyDBProxySSLConfigResponse(AbstractModel):
+    r"""ModifyDBProxySSLConfig返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _TaskId: 异步任务 ID。可通过 DescribeTasks 接口查询任务执行进度。当 SSL 状态无变更时返回 0，无需等待任务
+        :type TaskId: int
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._TaskId = None
         self._RequestId = None
 
     @property
-    def DealName(self):
-        r"""<p>订单号，仅变配（节点规格/数量变更）下单成功时返回；仅修改 Description 时不下单，本字段为空。</p>
-        :rtype: str
+    def TaskId(self):
+        r"""异步任务 ID。可通过 DescribeTasks 接口查询任务执行进度。当 SSL 状态无变更时返回 0，无需等待任务
+        :rtype: int
         """
-        return self._DealName
+        return self._TaskId
 
-    @DealName.setter
-    def DealName(self, DealName):
-        self._DealName = DealName
+    @TaskId.setter
+    def TaskId(self, TaskId):
+        self._TaskId = TaskId
 
     @property
     def RequestId(self):
@@ -18708,7 +20063,7 @@ class ModifyDBProxyResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._DealName = params.get("DealName")
+        self._TaskId = params.get("TaskId")
         self._RequestId = params.get("RequestId")
 
 
@@ -19051,11 +20406,11 @@ class ModifyPrivilege(AbstractModel):
 
     def __init__(self):
         r"""
-        :param _DatabasePrivilege: 要修改的数据库对象及权限列表
+        :param _DatabasePrivilege: <p>要修改的数据库对象及权限列表</p>
         :type DatabasePrivilege: :class:`tencentcloud.postgres.v20170312.models.DatabasePrivilege`
-        :param _ModifyType: 修改的方式，当前仅支持grantObject、revokeObject、alterRole。grantObject代表授权、revokeObject代表收回权、alterRole代表修改账号类型。
+        :param _ModifyType: <p>修改的方式，当前仅支持grantObject、revokeObject、alterRole、grantRole、revoke，当前仅支持grantObject、revokeObject、alterRole、grantRole、revokeRole。gRole。grantObject代表授权、revokeObject代表收回权、alterRole代表修改账号类型、grantRole代表加入对应角色、revokeRole 代表移出对应角色。</p>
         :type ModifyType: str
-        :param _IsCascade: 当ModifyType为revokeObject才需要此参数，参数为true时，撤销权限会级联撤销。默认为false。
+        :param _IsCascade: <p>当ModifyType为revokeObject才需要此参数，参数为true时，撤销权限会级联撤销。默认为false。</p>
         :type IsCascade: bool
         """
         self._DatabasePrivilege = None
@@ -19064,7 +20419,7 @@ class ModifyPrivilege(AbstractModel):
 
     @property
     def DatabasePrivilege(self):
-        r"""要修改的数据库对象及权限列表
+        r"""<p>要修改的数据库对象及权限列表</p>
         :rtype: :class:`tencentcloud.postgres.v20170312.models.DatabasePrivilege`
         """
         return self._DatabasePrivilege
@@ -19075,7 +20430,7 @@ class ModifyPrivilege(AbstractModel):
 
     @property
     def ModifyType(self):
-        r"""修改的方式，当前仅支持grantObject、revokeObject、alterRole。grantObject代表授权、revokeObject代表收回权、alterRole代表修改账号类型。
+        r"""<p>修改的方式，当前仅支持grantObject、revokeObject、alterRole、grantRole、revoke，当前仅支持grantObject、revokeObject、alterRole、grantRole、revokeRole。gRole。grantObject代表授权、revokeObject代表收回权、alterRole代表修改账号类型、grantRole代表加入对应角色、revokeRole 代表移出对应角色。</p>
         :rtype: str
         """
         return self._ModifyType
@@ -19086,7 +20441,7 @@ class ModifyPrivilege(AbstractModel):
 
     @property
     def IsCascade(self):
-        r"""当ModifyType为revokeObject才需要此参数，参数为true时，撤销权限会级联撤销。默认为false。
+        r"""<p>当ModifyType为revokeObject才需要此参数，参数为true时，撤销权限会级联撤销。默认为false。</p>
         :rtype: bool
         """
         return self._IsCascade
@@ -19909,6 +21264,274 @@ class OpenDBExtranetAccessResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class OpenMem0ServiceRequest(AbstractModel):
+    r"""OpenMem0Service请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DBInstanceId: <p>实例ID</p>
+        :type DBInstanceId: str
+        :param _AgenticBaseId: <p>AgenticBaseID，开启Mem0服务前请先开通AgenticBase套餐</p>
+        :type AgenticBaseId: str
+        :param _LLMModel: <p>Mem0服务使用的LLM模型</p><p>枚举值：</p><ul><li>auto： 自动选择合适的模型</li><li>deepseek-v4-flash： deepseek-v4-flash</li><li>deepseek-v4-pro： deepseek-v4-pro</li><li>glm-5： glm-5</li><li>glm-5-turbo： glm-5-turbo</li><li>glm-5.1： glm-5.1</li><li>kimi-k2.5： kimi-k2.5</li><li>kimi-k2.6： kimi-k2.6</li><li>minimax-m2.5： minimax-m2.5</li><li>minimax-m2.7： minimax-m2.7</li></ul>
+        :type LLMModel: str
+        :param _EmbeddingApiKey: <p>请前往腾讯云Tokenhub开通服务将ApiKey填入</p>
+        :type EmbeddingApiKey: str
+        """
+        self._DBInstanceId = None
+        self._AgenticBaseId = None
+        self._LLMModel = None
+        self._EmbeddingApiKey = None
+
+    @property
+    def DBInstanceId(self):
+        r"""<p>实例ID</p>
+        :rtype: str
+        """
+        return self._DBInstanceId
+
+    @DBInstanceId.setter
+    def DBInstanceId(self, DBInstanceId):
+        self._DBInstanceId = DBInstanceId
+
+    @property
+    def AgenticBaseId(self):
+        r"""<p>AgenticBaseID，开启Mem0服务前请先开通AgenticBase套餐</p>
+        :rtype: str
+        """
+        return self._AgenticBaseId
+
+    @AgenticBaseId.setter
+    def AgenticBaseId(self, AgenticBaseId):
+        self._AgenticBaseId = AgenticBaseId
+
+    @property
+    def LLMModel(self):
+        r"""<p>Mem0服务使用的LLM模型</p><p>枚举值：</p><ul><li>auto： 自动选择合适的模型</li><li>deepseek-v4-flash： deepseek-v4-flash</li><li>deepseek-v4-pro： deepseek-v4-pro</li><li>glm-5： glm-5</li><li>glm-5-turbo： glm-5-turbo</li><li>glm-5.1： glm-5.1</li><li>kimi-k2.5： kimi-k2.5</li><li>kimi-k2.6： kimi-k2.6</li><li>minimax-m2.5： minimax-m2.5</li><li>minimax-m2.7： minimax-m2.7</li></ul>
+        :rtype: str
+        """
+        return self._LLMModel
+
+    @LLMModel.setter
+    def LLMModel(self, LLMModel):
+        self._LLMModel = LLMModel
+
+    @property
+    def EmbeddingApiKey(self):
+        r"""<p>请前往腾讯云Tokenhub开通服务将ApiKey填入</p>
+        :rtype: str
+        """
+        return self._EmbeddingApiKey
+
+    @EmbeddingApiKey.setter
+    def EmbeddingApiKey(self, EmbeddingApiKey):
+        self._EmbeddingApiKey = EmbeddingApiKey
+
+
+    def _deserialize(self, params):
+        self._DBInstanceId = params.get("DBInstanceId")
+        self._AgenticBaseId = params.get("AgenticBaseId")
+        self._LLMModel = params.get("LLMModel")
+        self._EmbeddingApiKey = params.get("EmbeddingApiKey")
+        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 OpenMem0ServiceResponse(AbstractModel):
+    r"""OpenMem0Service返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _TaskId: <p>开启Mem0服务任务ID</p>
+        :type TaskId: int
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._TaskId = None
+        self._RequestId = None
+
+    @property
+    def TaskId(self):
+        r"""<p>开启Mem0服务任务ID</p>
+        :rtype: int
+        """
+        return self._TaskId
+
+    @TaskId.setter
+    def TaskId(self, TaskId):
+        self._TaskId = TaskId
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._TaskId = params.get("TaskId")
+        self._RequestId = params.get("RequestId")
+
+
+class OpenPostgRESTServiceRequest(AbstractModel):
+    r"""OpenPostgRESTService请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DBInstanceId: <p>实例ID</p>
+        :type DBInstanceId: str
+        :param _EnableWanNet: <p>是否开启外网</p>
+        :type EnableWanNet: bool
+        :param _RestConfig: <p>PostgREST服务参数</p>
+        :type RestConfig: list of ParamEntry
+        :param _VpcId: <p>VPC</p><p>参数格式：私有网络ID，形如vpc-e6w23k31。非必选，不传默认使用实例的vpc</p>
+        :type VpcId: str
+        :param _SubnetId: <p>私有网络子网ID，形如subnet-51lcif9y。非必选，不传则使用实例的子网</p>
+        :type SubnetId: str
+        """
+        self._DBInstanceId = None
+        self._EnableWanNet = None
+        self._RestConfig = None
+        self._VpcId = None
+        self._SubnetId = None
+
+    @property
+    def DBInstanceId(self):
+        r"""<p>实例ID</p>
+        :rtype: str
+        """
+        return self._DBInstanceId
+
+    @DBInstanceId.setter
+    def DBInstanceId(self, DBInstanceId):
+        self._DBInstanceId = DBInstanceId
+
+    @property
+    def EnableWanNet(self):
+        r"""<p>是否开启外网</p>
+        :rtype: bool
+        """
+        return self._EnableWanNet
+
+    @EnableWanNet.setter
+    def EnableWanNet(self, EnableWanNet):
+        self._EnableWanNet = EnableWanNet
+
+    @property
+    def RestConfig(self):
+        r"""<p>PostgREST服务参数</p>
+        :rtype: list of ParamEntry
+        """
+        return self._RestConfig
+
+    @RestConfig.setter
+    def RestConfig(self, RestConfig):
+        self._RestConfig = RestConfig
+
+    @property
+    def VpcId(self):
+        r"""<p>VPC</p><p>参数格式：私有网络ID，形如vpc-e6w23k31。非必选，不传默认使用实例的vpc</p>
+        :rtype: str
+        """
+        return self._VpcId
+
+    @VpcId.setter
+    def VpcId(self, VpcId):
+        self._VpcId = VpcId
+
+    @property
+    def SubnetId(self):
+        r"""<p>私有网络子网ID，形如subnet-51lcif9y。非必选，不传则使用实例的子网</p>
+        :rtype: str
+        """
+        return self._SubnetId
+
+    @SubnetId.setter
+    def SubnetId(self, SubnetId):
+        self._SubnetId = SubnetId
+
+
+    def _deserialize(self, params):
+        self._DBInstanceId = params.get("DBInstanceId")
+        self._EnableWanNet = params.get("EnableWanNet")
+        if params.get("RestConfig") is not None:
+            self._RestConfig = []
+            for item in params.get("RestConfig"):
+                obj = ParamEntry()
+                obj._deserialize(item)
+                self._RestConfig.append(obj)
+        self._VpcId = params.get("VpcId")
+        self._SubnetId = params.get("SubnetId")
+        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 OpenPostgRESTServiceResponse(AbstractModel):
+    r"""OpenPostgRESTService返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _TaskId: <p>开启PostgREST服务任务ID</p>
+        :type TaskId: int
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._TaskId = None
+        self._RequestId = None
+
+    @property
+    def TaskId(self):
+        r"""<p>开启PostgREST服务任务ID</p>
+        :rtype: int
+        """
+        return self._TaskId
+
+    @TaskId.setter
+    def TaskId(self, TaskId):
+        self._TaskId = TaskId
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._TaskId = params.get("TaskId")
+        self._RequestId = params.get("RequestId")
+
+
 class ParamEntry(AbstractModel):
     r"""批量修改参数
 
@@ -20887,6 +22510,22 @@ class ProxyAddress(AbstractModel):
         :type Routes: list of ProxyRoute
         :param _ConnectionPoolLimit: <p>连接池大小</p>
         :type ConnectionPoolLimit: int
+        :param _RwSplitEnable: <p>读写分离开关。启用后 proxy 将读请求分发到只读节点，写请求仍走主节点。</p>
+        :type RwSplitEnable: bool
+        :param _WeightMode: <p>权重模式</p><p>枚举值：</p><ul><li>system： 系统自动分配</li><li>custom： 用户自定义权重</li></ul>
+        :type WeightMode: str
+        :param _RoAutoAdd: <p>新增只读是否自动加入读写分离</p>
+        :type RoAutoAdd: bool
+        :param _LatencyRemove: <p>延迟剔除开关</p>
+        :type LatencyRemove: bool
+        :param _LatencyRemoveTime: <p>延迟剔除阈值</p><p>单位：秒</p>
+        :type LatencyRemoveTime: int
+        :param _MinRouteNum: <p>最小保留路由数。在延迟/故障剔除时，至少保留的路由数量，防止所有节点被剔除导致服务不可用。</p>
+        :type MinRouteNum: int
+        :param _FailOver: <p>只读全部异常时是否回切到主</p>
+        :type FailOver: bool
+        :param _LoadBalancePolicy: <p>负载均衡策略</p><p>枚举值：</p><ul><li>0： 按活跃连接数(默认)</li><li>1： 按请求数</li></ul>
+        :type LoadBalancePolicy: int
         """
         self._AddressId = None
         self._Vip = None
@@ -20897,6 +22536,14 @@ class ProxyAddress(AbstractModel):
         self._ConnectionPool = None
         self._Routes = None
         self._ConnectionPoolLimit = None
+        self._RwSplitEnable = None
+        self._WeightMode = None
+        self._RoAutoAdd = None
+        self._LatencyRemove = None
+        self._LatencyRemoveTime = None
+        self._MinRouteNum = None
+        self._FailOver = None
+        self._LoadBalancePolicy = None
 
     @property
     def AddressId(self):
@@ -20997,6 +22644,94 @@ class ProxyAddress(AbstractModel):
     def ConnectionPoolLimit(self, ConnectionPoolLimit):
         self._ConnectionPoolLimit = ConnectionPoolLimit
 
+    @property
+    def RwSplitEnable(self):
+        r"""<p>读写分离开关。启用后 proxy 将读请求分发到只读节点，写请求仍走主节点。</p>
+        :rtype: bool
+        """
+        return self._RwSplitEnable
+
+    @RwSplitEnable.setter
+    def RwSplitEnable(self, RwSplitEnable):
+        self._RwSplitEnable = RwSplitEnable
+
+    @property
+    def WeightMode(self):
+        r"""<p>权重模式</p><p>枚举值：</p><ul><li>system： 系统自动分配</li><li>custom： 用户自定义权重</li></ul>
+        :rtype: str
+        """
+        return self._WeightMode
+
+    @WeightMode.setter
+    def WeightMode(self, WeightMode):
+        self._WeightMode = WeightMode
+
+    @property
+    def RoAutoAdd(self):
+        r"""<p>新增只读是否自动加入读写分离</p>
+        :rtype: bool
+        """
+        return self._RoAutoAdd
+
+    @RoAutoAdd.setter
+    def RoAutoAdd(self, RoAutoAdd):
+        self._RoAutoAdd = RoAutoAdd
+
+    @property
+    def LatencyRemove(self):
+        r"""<p>延迟剔除开关</p>
+        :rtype: bool
+        """
+        return self._LatencyRemove
+
+    @LatencyRemove.setter
+    def LatencyRemove(self, LatencyRemove):
+        self._LatencyRemove = LatencyRemove
+
+    @property
+    def LatencyRemoveTime(self):
+        r"""<p>延迟剔除阈值</p><p>单位：秒</p>
+        :rtype: int
+        """
+        return self._LatencyRemoveTime
+
+    @LatencyRemoveTime.setter
+    def LatencyRemoveTime(self, LatencyRemoveTime):
+        self._LatencyRemoveTime = LatencyRemoveTime
+
+    @property
+    def MinRouteNum(self):
+        r"""<p>最小保留路由数。在延迟/故障剔除时，至少保留的路由数量，防止所有节点被剔除导致服务不可用。</p>
+        :rtype: int
+        """
+        return self._MinRouteNum
+
+    @MinRouteNum.setter
+    def MinRouteNum(self, MinRouteNum):
+        self._MinRouteNum = MinRouteNum
+
+    @property
+    def FailOver(self):
+        r"""<p>只读全部异常时是否回切到主</p>
+        :rtype: bool
+        """
+        return self._FailOver
+
+    @FailOver.setter
+    def FailOver(self, FailOver):
+        self._FailOver = FailOver
+
+    @property
+    def LoadBalancePolicy(self):
+        r"""<p>负载均衡策略</p><p>枚举值：</p><ul><li>0： 按活跃连接数(默认)</li><li>1： 按请求数</li></ul>
+        :rtype: int
+        """
+        return self._LoadBalancePolicy
+
+    @LoadBalancePolicy.setter
+    def LoadBalancePolicy(self, LoadBalancePolicy):
+        self._LoadBalancePolicy = LoadBalancePolicy
+
 
     def _deserialize(self, params):
         self._AddressId = params.get("AddressId")
@@ -21013,6 +22748,14 @@ class ProxyAddress(AbstractModel):
                 obj._deserialize(item)
                 self._Routes.append(obj)
         self._ConnectionPoolLimit = params.get("ConnectionPoolLimit")
+        self._RwSplitEnable = params.get("RwSplitEnable")
+        self._WeightMode = params.get("WeightMode")
+        self._RoAutoAdd = params.get("RoAutoAdd")
+        self._LatencyRemove = params.get("LatencyRemove")
+        self._LatencyRemoveTime = params.get("LatencyRemoveTime")
+        self._MinRouteNum = params.get("MinRouteNum")
+        self._FailOver = params.get("FailOver")
+        self._LoadBalancePolicy = params.get("LoadBalancePolicy")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -21394,7 +23137,7 @@ class ProxyRoute(AbstractModel):
         :type Role: str
         :param _Weight: <p>路由权重，取值范围 [0, 100]</p>
         :type Weight: int
-        :param _Status: <p>路由状态：available/unavailable</p>
+        :param _Status: <p>路由状态：online/offline</p><p>枚举值：</p><ul><li>online： 节点处于在线状态</li><li>offline： 节点处于下线状态</li></ul>
         :type Status: str
         """
         self._NodeId = None
@@ -21437,7 +23180,7 @@ class ProxyRoute(AbstractModel):
 
     @property
     def Status(self):
-        r"""<p>路由状态：available/unavailable</p>
+        r"""<p>路由状态：online/offline</p><p>枚举值：</p><ul><li>online： 节点处于在线状态</li><li>offline： 节点处于下线状态</li></ul>
         :rtype: str
         """
         return self._Status