tencentcloud-sdk-python 3.0.1491__py2.py3-none-any.whl → 3.1.6__py2.py3-none-any.whl

tencentcloud/ckafka/v20190819/models.py

@@ -6888,6 +6888,8 @@ class CreateTopicRequest(AbstractModel):
         :type RetentionBytes: int
         :param _Tags: 标签列表
         :type Tags: list of Tag
+        :param _LogMsgTimestampType: 消息保存的时间类型:CreateTime/LogAppendTime
+        :type LogMsgTimestampType: str
         """
         self._InstanceId = None
         self._TopicName = None
@@ -6906,6 +6908,7 @@ class CreateTopicRequest(AbstractModel):
         self._AclRuleName = None
         self._RetentionBytes = None
         self._Tags = None
+        self._LogMsgTimestampType = None
 
     @property
     def InstanceId(self):
@@ -7094,6 +7097,17 @@ class CreateTopicRequest(AbstractModel):
     def Tags(self, Tags):
         self._Tags = Tags
 
+    @property
+    def LogMsgTimestampType(self):
+        r"""消息保存的时间类型:CreateTime/LogAppendTime
+        :rtype: str
+        """
+        return self._LogMsgTimestampType
+
+    @LogMsgTimestampType.setter
+    def LogMsgTimestampType(self, LogMsgTimestampType):
+        self._LogMsgTimestampType = LogMsgTimestampType
+
 
     def _deserialize(self, params):
         self._InstanceId = params.get("InstanceId")
@@ -7118,6 +7132,7 @@ class CreateTopicRequest(AbstractModel):
                 obj = Tag()
                 obj._deserialize(item)
                 self._Tags.append(obj)
+        self._LogMsgTimestampType = params.get("LogMsgTimestampType")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -9230,6 +9245,117 @@ class DeleteGroupResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class DeleteGroupSubscribeTopicRequest(AbstractModel):
+    r"""DeleteGroupSubscribeTopic请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _InstanceId: ckafka集群实例Id
+        :type InstanceId: str
+        :param _Group: 消费分组名称
+        :type Group: str
+        :param _Topic: 主题名
+        :type Topic: str
+        """
+        self._InstanceId = None
+        self._Group = None
+        self._Topic = None
+
+    @property
+    def InstanceId(self):
+        r"""ckafka集群实例Id
+        :rtype: str
+        """
+        return self._InstanceId
+
+    @InstanceId.setter
+    def InstanceId(self, InstanceId):
+        self._InstanceId = InstanceId
+
+    @property
+    def Group(self):
+        r"""消费分组名称
+        :rtype: str
+        """
+        return self._Group
+
+    @Group.setter
+    def Group(self, Group):
+        self._Group = Group
+
+    @property
+    def Topic(self):
+        r"""主题名
+        :rtype: str
+        """
+        return self._Topic
+
+    @Topic.setter
+    def Topic(self, Topic):
+        self._Topic = Topic
+
+
+    def _deserialize(self, params):
+        self._InstanceId = params.get("InstanceId")
+        self._Group = params.get("Group")
+        self._Topic = params.get("Topic")
+        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 DeleteGroupSubscribeTopicResponse(AbstractModel):
+    r"""DeleteGroupSubscribeTopic返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Result: 返回结果
+        :type Result: :class:`tencentcloud.ckafka.v20190819.models.JgwOperateResponse`
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._Result = None
+        self._RequestId = None
+
+    @property
+    def Result(self):
+        r"""返回结果
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.JgwOperateResponse`
+        """
+        return self._Result
+
+    @Result.setter
+    def Result(self, Result):
+        self._Result = Result
+
+    @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):
+        if params.get("Result") is not None:
+            self._Result = JgwOperateResponse()
+            self._Result._deserialize(params.get("Result"))
+        self._RequestId = params.get("RequestId")
+
+
 class DeleteInstancePostRequest(AbstractModel):
     r"""DeleteInstancePost请求参数结构体
 
@@ -9900,6 +10026,108 @@ class DeleteUserResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class DescModifyType(AbstractModel):
+    r"""变配类型查询出参
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _ModifyType: 变配类型
+        :type ModifyType: int
+        :param _MigrateFlag: 是否迁移标志
+        :type MigrateFlag: bool
+        :param _MigrateCostTime: 迁移预计耗时(稳定模式)秒
+注意：此字段可能返回 null，表示取不到有效值。
+        :type MigrateCostTime: int
+        :param _UpgradeStrategy: 升配模式(1:稳定模式，2:高速模式)
+注意：此字段可能返回 null，表示取不到有效值。
+        :type UpgradeStrategy: int
+        :param _MigrateCostTimeHighSpeed: 迁移预计耗时(高速模式)秒
+注意：此字段可能返回 null，表示取不到有效值。
+        :type MigrateCostTimeHighSpeed: int
+        """
+        self._ModifyType = None
+        self._MigrateFlag = None
+        self._MigrateCostTime = None
+        self._UpgradeStrategy = None
+        self._MigrateCostTimeHighSpeed = None
+
+    @property
+    def ModifyType(self):
+        r"""变配类型
+        :rtype: int
+        """
+        return self._ModifyType
+
+    @ModifyType.setter
+    def ModifyType(self, ModifyType):
+        self._ModifyType = ModifyType
+
+    @property
+    def MigrateFlag(self):
+        r"""是否迁移标志
+        :rtype: bool
+        """
+        return self._MigrateFlag
+
+    @MigrateFlag.setter
+    def MigrateFlag(self, MigrateFlag):
+        self._MigrateFlag = MigrateFlag
+
+    @property
+    def MigrateCostTime(self):
+        r"""迁移预计耗时(稳定模式)秒
+注意：此字段可能返回 null，表示取不到有效值。
+        :rtype: int
+        """
+        return self._MigrateCostTime
+
+    @MigrateCostTime.setter
+    def MigrateCostTime(self, MigrateCostTime):
+        self._MigrateCostTime = MigrateCostTime
+
+    @property
+    def UpgradeStrategy(self):
+        r"""升配模式(1:稳定模式，2:高速模式)
+注意：此字段可能返回 null，表示取不到有效值。
+        :rtype: int
+        """
+        return self._UpgradeStrategy
+
+    @UpgradeStrategy.setter
+    def UpgradeStrategy(self, UpgradeStrategy):
+        self._UpgradeStrategy = UpgradeStrategy
+
+    @property
+    def MigrateCostTimeHighSpeed(self):
+        r"""迁移预计耗时(高速模式)秒
+注意：此字段可能返回 null，表示取不到有效值。
+        :rtype: int
+        """
+        return self._MigrateCostTimeHighSpeed
+
+    @MigrateCostTimeHighSpeed.setter
+    def MigrateCostTimeHighSpeed(self, MigrateCostTimeHighSpeed):
+        self._MigrateCostTimeHighSpeed = MigrateCostTimeHighSpeed
+
+
+    def _deserialize(self, params):
+        self._ModifyType = params.get("ModifyType")
+        self._MigrateFlag = params.get("MigrateFlag")
+        self._MigrateCostTime = params.get("MigrateCostTime")
+        self._UpgradeStrategy = params.get("UpgradeStrategy")
+        self._MigrateCostTimeHighSpeed = params.get("MigrateCostTimeHighSpeed")
+        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 DescribeACLRequest(AbstractModel):
     r"""DescribeACL请求参数结构体
 
@@ -10182,6 +10410,70 @@ class DescribeAclRuleResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class DescribeCkafkaVersionRequest(AbstractModel):
+    r"""DescribeCkafkaVersion请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _InstanceId: ckafka集群实例Id
+        :type InstanceId: str
+        """
+        self._InstanceId = None
+
+    @property
+    def InstanceId(self):
+        r"""ckafka集群实例Id
+        :rtype: str
+        """
+        return self._InstanceId
+
+    @InstanceId.setter
+    def InstanceId(self, InstanceId):
+        self._InstanceId = InstanceId
+
+
+    def _deserialize(self, params):
+        self._InstanceId = params.get("InstanceId")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class DescribeCkafkaVersionResponse(AbstractModel):
+    r"""DescribeCkafkaVersion返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._RequestId = None
+
+    @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._RequestId = params.get("RequestId")
+
+
 class DescribeCkafkaZoneRequest(AbstractModel):
     r"""DescribeCkafkaZone请求参数结构体
 
@@ -13630,16 +13922,194 @@ class DescribeInstancesRequest(AbstractModel):
         :type VpcId: str
         """
         self._InstanceId = None
-        self._SearchWord = None
-        self._Status = None
-        self._Offset = None
-        self._Limit = None
-        self._TagKey = None
-        self._VpcId = None
+        self._SearchWord = None
+        self._Status = None
+        self._Offset = None
+        self._Limit = None
+        self._TagKey = None
+        self._VpcId = None
+
+    @property
+    def InstanceId(self):
+        r"""（查询条件）按照ckafka集群实例Id过滤
+        :rtype: str
+        """
+        return self._InstanceId
+
+    @InstanceId.setter
+    def InstanceId(self, InstanceId):
+        self._InstanceId = InstanceId
+
+    @property
+    def SearchWord(self):
+        r"""搜索词   ex:（查询条件）按照实例名称过滤，支持模糊查询
+        :rtype: str
+        """
+        return self._SearchWord
+
+    @SearchWord.setter
+    def SearchWord(self, SearchWord):
+        self._SearchWord = SearchWord
+
+    @property
+    def Status(self):
+        r"""（查询条件）实例的状态  0：创建中，1：运行中，2：删除中，5: 隔离中,  7:升级中 不填默认返回全部
+        :rtype: list of int
+        """
+        return self._Status
+
+    @Status.setter
+    def Status(self, Status):
+        self._Status = Status
+
+    @property
+    def Offset(self):
+        r"""偏移量，不填默认为0
+        :rtype: int
+        """
+        return self._Offset
+
+    @Offset.setter
+    def Offset(self, Offset):
+        self._Offset = Offset
+
+    @property
+    def Limit(self):
+        r"""返回数量，不填则默认10，最大值100
+        :rtype: int
+        """
+        return self._Limit
+
+    @Limit.setter
+    def Limit(self, Limit):
+        self._Limit = Limit
+
+    @property
+    def TagKey(self):
+        warnings.warn("parameter `TagKey` is deprecated", DeprecationWarning) 
+
+        r"""已废弃。匹配标签key值。
+        :rtype: str
+        """
+        return self._TagKey
+
+    @TagKey.setter
+    def TagKey(self, TagKey):
+        warnings.warn("parameter `TagKey` is deprecated", DeprecationWarning) 
+
+        self._TagKey = TagKey
+
+    @property
+    def VpcId(self):
+        r"""（查询条件）私有网络Id
+        :rtype: str
+        """
+        return self._VpcId
+
+    @VpcId.setter
+    def VpcId(self, VpcId):
+        self._VpcId = VpcId
+
+
+    def _deserialize(self, params):
+        self._InstanceId = params.get("InstanceId")
+        self._SearchWord = params.get("SearchWord")
+        self._Status = params.get("Status")
+        self._Offset = params.get("Offset")
+        self._Limit = params.get("Limit")
+        self._TagKey = params.get("TagKey")
+        self._VpcId = params.get("VpcId")
+        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 DescribeInstancesResponse(AbstractModel):
+    r"""DescribeInstances返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Result: 返回的结果
+        :type Result: :class:`tencentcloud.ckafka.v20190819.models.InstanceResponse`
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._Result = None
+        self._RequestId = None
+
+    @property
+    def Result(self):
+        r"""返回的结果
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.InstanceResponse`
+        """
+        return self._Result
+
+    @Result.setter
+    def Result(self, Result):
+        self._Result = Result
+
+    @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):
+        if params.get("Result") is not None:
+            self._Result = InstanceResponse()
+            self._Result._deserialize(params.get("Result"))
+        self._RequestId = params.get("RequestId")
+
+
+class DescribeModifyTypeRequest(AbstractModel):
+    r"""DescribeModifyType请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _InstanceId: ckafka集群实例Id
+        :type InstanceId: str
+        :param _BandWidth: 升配后的带宽，单位mb
+        :type BandWidth: int
+        :param _DiskSize: 升配后的磁盘，单位G
+        :type DiskSize: int
+        :param _DiskType: 磁盘类型，例如 CLOUD_PREMIUM
+        :type DiskType: str
+        :param _Partition: 分区数量
+        :type Partition: int
+        :param _Topic: topic数量
+        :type Topic: int
+        :param _Type: 实例类型例如 sp_ckafka_profession
+        :type Type: str
+        :param _ModifyEntry: 变配入口
+        :type ModifyEntry: str
+        """
+        self._InstanceId = None
+        self._BandWidth = None
+        self._DiskSize = None
+        self._DiskType = None
+        self._Partition = None
+        self._Topic = None
+        self._Type = None
+        self._ModifyEntry = None
 
     @property
     def InstanceId(self):
-        r"""（查询条件）按照ckafka集群实例Id过滤
+        r"""ckafka集群实例Id
         :rtype: str
         """
         return self._InstanceId
@@ -13649,84 +14119,92 @@ class DescribeInstancesRequest(AbstractModel):
         self._InstanceId = InstanceId
 
     @property
-    def SearchWord(self):
-        r"""搜索词   ex:（查询条件）按照实例名称过滤，支持模糊查询
-        :rtype: str
+    def BandWidth(self):
+        r"""升配后的带宽，单位mb
+        :rtype: int
         """
-        return self._SearchWord
+        return self._BandWidth
 
-    @SearchWord.setter
-    def SearchWord(self, SearchWord):
-        self._SearchWord = SearchWord
+    @BandWidth.setter
+    def BandWidth(self, BandWidth):
+        self._BandWidth = BandWidth
 
     @property
-    def Status(self):
-        r"""（查询条件）实例的状态  0：创建中，1：运行中，2：删除中，5: 隔离中,  7:升级中 不填默认返回全部
-        :rtype: list of int
+    def DiskSize(self):
+        r"""升配后的磁盘，单位G
+        :rtype: int
         """
-        return self._Status
+        return self._DiskSize
 
-    @Status.setter
-    def Status(self, Status):
-        self._Status = Status
+    @DiskSize.setter
+    def DiskSize(self, DiskSize):
+        self._DiskSize = DiskSize
 
     @property
-    def Offset(self):
-        r"""偏移量，不填默认为0
-        :rtype: int
+    def DiskType(self):
+        r"""磁盘类型，例如 CLOUD_PREMIUM
+        :rtype: str
         """
-        return self._Offset
+        return self._DiskType
 
-    @Offset.setter
-    def Offset(self, Offset):
-        self._Offset = Offset
+    @DiskType.setter
+    def DiskType(self, DiskType):
+        self._DiskType = DiskType
 
     @property
-    def Limit(self):
-        r"""返回数量，不填则默认10，最大值100
+    def Partition(self):
+        r"""分区数量
         :rtype: int
         """
-        return self._Limit
+        return self._Partition
 
-    @Limit.setter
-    def Limit(self, Limit):
-        self._Limit = Limit
+    @Partition.setter
+    def Partition(self, Partition):
+        self._Partition = Partition
 
     @property
-    def TagKey(self):
-        warnings.warn("parameter `TagKey` is deprecated", DeprecationWarning) 
+    def Topic(self):
+        r"""topic数量
+        :rtype: int
+        """
+        return self._Topic
 
-        r"""已废弃。匹配标签key值。
+    @Topic.setter
+    def Topic(self, Topic):
+        self._Topic = Topic
+
+    @property
+    def Type(self):
+        r"""实例类型例如 sp_ckafka_profession
         :rtype: str
         """
-        return self._TagKey
-
-    @TagKey.setter
-    def TagKey(self, TagKey):
-        warnings.warn("parameter `TagKey` is deprecated", DeprecationWarning) 
+        return self._Type
 
-        self._TagKey = TagKey
+    @Type.setter
+    def Type(self, Type):
+        self._Type = Type
 
     @property
-    def VpcId(self):
-        r"""（查询条件）私有网络Id
+    def ModifyEntry(self):
+        r"""变配入口
         :rtype: str
         """
-        return self._VpcId
+        return self._ModifyEntry
 
-    @VpcId.setter
-    def VpcId(self, VpcId):
-        self._VpcId = VpcId
+    @ModifyEntry.setter
+    def ModifyEntry(self, ModifyEntry):
+        self._ModifyEntry = ModifyEntry
 
 
     def _deserialize(self, params):
         self._InstanceId = params.get("InstanceId")
-        self._SearchWord = params.get("SearchWord")
-        self._Status = params.get("Status")
-        self._Offset = params.get("Offset")
-        self._Limit = params.get("Limit")
-        self._TagKey = params.get("TagKey")
-        self._VpcId = params.get("VpcId")
+        self._BandWidth = params.get("BandWidth")
+        self._DiskSize = params.get("DiskSize")
+        self._DiskType = params.get("DiskType")
+        self._Partition = params.get("Partition")
+        self._Topic = params.get("Topic")
+        self._Type = params.get("Type")
+        self._ModifyEntry = params.get("ModifyEntry")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -13737,15 +14215,15 @@ class DescribeInstancesRequest(AbstractModel):
         
 
 
-class DescribeInstancesResponse(AbstractModel):
-    r"""DescribeInstances返回参数结构体
+class DescribeModifyTypeResponse(AbstractModel):
+    r"""DescribeModifyType返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _Result: 返回的结果
-        :type Result: :class:`tencentcloud.ckafka.v20190819.models.InstanceResponse`
+        :param _Result: 返回的变配类型结构
+        :type Result: :class:`tencentcloud.ckafka.v20190819.models.DescModifyType`
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
@@ -13754,8 +14232,8 @@ class DescribeInstancesResponse(AbstractModel):
 
     @property
     def Result(self):
-        r"""返回的结果
-        :rtype: :class:`tencentcloud.ckafka.v20190819.models.InstanceResponse`
+        r"""返回的变配类型结构
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.DescModifyType`
         """
         return self._Result
 
@@ -13777,7 +14255,7 @@ class DescribeInstancesResponse(AbstractModel):
 
     def _deserialize(self, params):
         if params.get("Result") is not None:
-            self._Result = InstanceResponse()
+            self._Result = DescModifyType()
             self._Result._deserialize(params.get("Result"))
         self._RequestId = params.get("RequestId")
 
@@ -14006,9 +14484,12 @@ class DescribeRouteRequest(AbstractModel):
         :type InstanceId: str
         :param _RouteId: 路由Id
         :type RouteId: int
+        :param _MainRouteFlag: 是否显示主路由，true时会在返回原路由列表的基础上,再额外展示实例创建时的主路由信息(且不被InternalFlag/UsedFor等参数过滤影响)	
+        :type MainRouteFlag: bool
         """
         self._InstanceId = None
         self._RouteId = None
+        self._MainRouteFlag = None
 
     @property
     def InstanceId(self):
@@ -14032,10 +14513,22 @@ class DescribeRouteRequest(AbstractModel):
     def RouteId(self, RouteId):
         self._RouteId = RouteId
 
+    @property
+    def MainRouteFlag(self):
+        r"""是否显示主路由，true时会在返回原路由列表的基础上,再额外展示实例创建时的主路由信息(且不被InternalFlag/UsedFor等参数过滤影响)	
+        :rtype: bool
+        """
+        return self._MainRouteFlag
+
+    @MainRouteFlag.setter
+    def MainRouteFlag(self, MainRouteFlag):
+        self._MainRouteFlag = MainRouteFlag
+
 
     def _deserialize(self, params):
         self._InstanceId = params.get("InstanceId")
         self._RouteId = params.get("RouteId")
+        self._MainRouteFlag = params.get("MainRouteFlag")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -20062,6 +20555,10 @@ serverless  :serverless版
         :type RemainingTopics: int
         :param _DynamicDiskConfig: 动态硬盘扩容策略
         :type DynamicDiskConfig: :class:`tencentcloud.ckafka.v20190819.models.DynamicDiskConfig`
+        :param _SystemMaintenanceTime: 系统维护时间
+        :type SystemMaintenanceTime: str
+        :param _MaxMessageByte: 实例级别消息最大大小
+        :type MaxMessageByte: int
         :param _InstanceChargeType: 实例计费类型  POSTPAID_BY_HOUR 按小时付费; PREPAID 包年包月
         :type InstanceChargeType: str
         :param _ElasticBandwidthSwitch: 是否开启弹性带宽白名单   
@@ -20131,6 +20628,8 @@ CLOUD_EKS_TSE EKS集群
         self._RemainingPartitions = None
         self._RemainingTopics = None
         self._DynamicDiskConfig = None
+        self._SystemMaintenanceTime = None
+        self._MaxMessageByte = None
         self._InstanceChargeType = None
         self._ElasticBandwidthSwitch = None
         self._ElasticBandwidthOpenStatus = None
@@ -20530,6 +21029,28 @@ serverless  :serverless版
     def DynamicDiskConfig(self, DynamicDiskConfig):
         self._DynamicDiskConfig = DynamicDiskConfig
 
+    @property
+    def SystemMaintenanceTime(self):
+        r"""系统维护时间
+        :rtype: str
+        """
+        return self._SystemMaintenanceTime
+
+    @SystemMaintenanceTime.setter
+    def SystemMaintenanceTime(self, SystemMaintenanceTime):
+        self._SystemMaintenanceTime = SystemMaintenanceTime
+
+    @property
+    def MaxMessageByte(self):
+        r"""实例级别消息最大大小
+        :rtype: int
+        """
+        return self._MaxMessageByte
+
+    @MaxMessageByte.setter
+    def MaxMessageByte(self, MaxMessageByte):
+        self._MaxMessageByte = MaxMessageByte
+
     @property
     def InstanceChargeType(self):
         r"""实例计费类型  POSTPAID_BY_HOUR 按小时付费; PREPAID 包年包月
@@ -20697,6 +21218,8 @@ CLOUD_EKS_TSE EKS集群
         if params.get("DynamicDiskConfig") is not None:
             self._DynamicDiskConfig = DynamicDiskConfig()
             self._DynamicDiskConfig._deserialize(params.get("DynamicDiskConfig"))
+        self._SystemMaintenanceTime = params.get("SystemMaintenanceTime")
+        self._MaxMessageByte = params.get("MaxMessageByte")
         self._InstanceChargeType = params.get("InstanceChargeType")
         self._ElasticBandwidthSwitch = params.get("ElasticBandwidthSwitch")
         self._ElasticBandwidthOpenStatus = params.get("ElasticBandwidthOpenStatus")
@@ -24746,6 +25269,8 @@ class ModifyTopicAttributesRequest(AbstractModel):
         :type QuotaConsumerByteRate: int
         :param _ReplicaNum: topic副本数  最小值 1,最大值 3
         :type ReplicaNum: int
+        :param _LogMsgTimestampType: 消息保存的时间类型：CreateTime/LogAppendTime
+        :type LogMsgTimestampType: str
         """
         self._InstanceId = None
         self._TopicName = None
@@ -24765,6 +25290,7 @@ class ModifyTopicAttributesRequest(AbstractModel):
         self._QuotaProducerByteRate = None
         self._QuotaConsumerByteRate = None
         self._ReplicaNum = None
+        self._LogMsgTimestampType = None
 
     @property
     def InstanceId(self):
@@ -24964,6 +25490,17 @@ class ModifyTopicAttributesRequest(AbstractModel):
     def ReplicaNum(self, ReplicaNum):
         self._ReplicaNum = ReplicaNum
 
+    @property
+    def LogMsgTimestampType(self):
+        r"""消息保存的时间类型：CreateTime/LogAppendTime
+        :rtype: str
+        """
+        return self._LogMsgTimestampType
+
+    @LogMsgTimestampType.setter
+    def LogMsgTimestampType(self, LogMsgTimestampType):
+        self._LogMsgTimestampType = LogMsgTimestampType
+
 
     def _deserialize(self, params):
         self._InstanceId = params.get("InstanceId")
@@ -24989,6 +25526,7 @@ class ModifyTopicAttributesRequest(AbstractModel):
         self._QuotaProducerByteRate = params.get("QuotaProducerByteRate")
         self._QuotaConsumerByteRate = params.get("QuotaConsumerByteRate")
         self._ReplicaNum = params.get("ReplicaNum")
+        self._LogMsgTimestampType = params.get("LogMsgTimestampType")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -32307,6 +32845,147 @@ class TransformsParam(AbstractModel):
         
 
 
+class UpgradeBrokerVersionRequest(AbstractModel):
+    r"""UpgradeBrokerVersion请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _InstanceId: ckafka集群实例Id
+        :type InstanceId: str
+        :param _Type: 1.平滑升配.2.垂直升配
+        :type Type: int
+        :param _SourceVersion: 版本号
+        :type SourceVersion: str
+        :param _TargetVersion: 版本号
+        :type TargetVersion: str
+        :param _DelayTimeStamp: 延迟时间
+        :type DelayTimeStamp: str
+        """
+        self._InstanceId = None
+        self._Type = None
+        self._SourceVersion = None
+        self._TargetVersion = None
+        self._DelayTimeStamp = None
+
+    @property
+    def InstanceId(self):
+        r"""ckafka集群实例Id
+        :rtype: str
+        """
+        return self._InstanceId
+
+    @InstanceId.setter
+    def InstanceId(self, InstanceId):
+        self._InstanceId = InstanceId
+
+    @property
+    def Type(self):
+        r"""1.平滑升配.2.垂直升配
+        :rtype: int
+        """
+        return self._Type
+
+    @Type.setter
+    def Type(self, Type):
+        self._Type = Type
+
+    @property
+    def SourceVersion(self):
+        r"""版本号
+        :rtype: str
+        """
+        return self._SourceVersion
+
+    @SourceVersion.setter
+    def SourceVersion(self, SourceVersion):
+        self._SourceVersion = SourceVersion
+
+    @property
+    def TargetVersion(self):
+        r"""版本号
+        :rtype: str
+        """
+        return self._TargetVersion
+
+    @TargetVersion.setter
+    def TargetVersion(self, TargetVersion):
+        self._TargetVersion = TargetVersion
+
+    @property
+    def DelayTimeStamp(self):
+        r"""延迟时间
+        :rtype: str
+        """
+        return self._DelayTimeStamp
+
+    @DelayTimeStamp.setter
+    def DelayTimeStamp(self, DelayTimeStamp):
+        self._DelayTimeStamp = DelayTimeStamp
+
+
+    def _deserialize(self, params):
+        self._InstanceId = params.get("InstanceId")
+        self._Type = params.get("Type")
+        self._SourceVersion = params.get("SourceVersion")
+        self._TargetVersion = params.get("TargetVersion")
+        self._DelayTimeStamp = params.get("DelayTimeStamp")
+        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 UpgradeBrokerVersionResponse(AbstractModel):
+    r"""UpgradeBrokerVersion返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Result: 升配结果
+        :type Result: :class:`tencentcloud.ckafka.v20190819.models.JgwOperateResponse`
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._Result = None
+        self._RequestId = None
+
+    @property
+    def Result(self):
+        r"""升配结果
+        :rtype: :class:`tencentcloud.ckafka.v20190819.models.JgwOperateResponse`
+        """
+        return self._Result
+
+    @Result.setter
+    def Result(self, Result):
+        self._Result = Result
+
+    @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):
+        if params.get("Result") is not None:
+            self._Result = JgwOperateResponse()
+            self._Result._deserialize(params.get("Result"))
+        self._RequestId = params.get("RequestId")
+
+
 class UrlDecodeParam(AbstractModel):
     r"""Url解析