alibabacloud-emr-serverless-spark20230808 1.14.0__py3-none-any.whl → 1.16.0__py3-none-any.whl

alibabacloud_emr_serverless_spark20230808/models.py

@@ -1756,6 +1756,196 @@ class CancelJobRunResponse(TeaModel):
         return self
 
 
+class CreateKyuubiTokenRequestAutoExpireConfiguration(TeaModel):
+    def __init__(
+        self,
+        enable: bool = None,
+        expire_days: int = None,
+    ):
+        self.enable = enable
+        self.expire_days = expire_days
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.enable is not None:
+            result['enable'] = self.enable
+        if self.expire_days is not None:
+            result['expireDays'] = self.expire_days
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('enable') is not None:
+            self.enable = m.get('enable')
+        if m.get('expireDays') is not None:
+            self.expire_days = m.get('expireDays')
+        return self
+
+
+class CreateKyuubiTokenRequest(TeaModel):
+    def __init__(
+        self,
+        auto_expire_configuration: CreateKyuubiTokenRequestAutoExpireConfiguration = None,
+        member_arns: List[str] = None,
+        name: str = None,
+        token: str = None,
+        region_id: str = None,
+    ):
+        self.auto_expire_configuration = auto_expire_configuration
+        self.member_arns = member_arns
+        self.name = name
+        self.token = token
+        self.region_id = region_id
+
+    def validate(self):
+        if self.auto_expire_configuration:
+            self.auto_expire_configuration.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.auto_expire_configuration is not None:
+            result['autoExpireConfiguration'] = self.auto_expire_configuration.to_map()
+        if self.member_arns is not None:
+            result['memberArns'] = self.member_arns
+        if self.name is not None:
+            result['name'] = self.name
+        if self.token is not None:
+            result['token'] = self.token
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('autoExpireConfiguration') is not None:
+            temp_model = CreateKyuubiTokenRequestAutoExpireConfiguration()
+            self.auto_expire_configuration = temp_model.from_map(m['autoExpireConfiguration'])
+        if m.get('memberArns') is not None:
+            self.member_arns = m.get('memberArns')
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('token') is not None:
+            self.token = m.get('token')
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
+        return self
+
+
+class CreateKyuubiTokenResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        token_id: str = None,
+    ):
+        # Token ID。
+        self.token_id = token_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.token_id is not None:
+            result['tokenId'] = self.token_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('tokenId') is not None:
+            self.token_id = m.get('tokenId')
+        return self
+
+
+class CreateKyuubiTokenResponseBody(TeaModel):
+    def __init__(
+        self,
+        data: CreateKyuubiTokenResponseBodyData = None,
+        request_id: str = None,
+    ):
+        self.data = data
+        self.request_id = request_id
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('data') is not None:
+            temp_model = CreateKyuubiTokenResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class CreateKyuubiTokenResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: CreateKyuubiTokenResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = CreateKyuubiTokenResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class CreateLivyComputeRequestAutoStartConfiguration(TeaModel):
     def __init__(
         self,
@@ -3556,6 +3746,7 @@ class CreateSqlStatementRequest(TeaModel):
         default_database: str = None,
         limit: int = None,
         sql_compute_id: str = None,
+        task_biz_id: str = None,
         region_id: str = None,
     ):
         # The SQL code. You can specify one or more SQL statements.
@@ -3568,6 +3759,7 @@ class CreateSqlStatementRequest(TeaModel):
         self.limit = limit
         # The SQL session ID. You can create an SQL session in the workspace created in EMR Serverless Spark.
         self.sql_compute_id = sql_compute_id
+        self.task_biz_id = task_biz_id
         # The region ID.
         self.region_id = region_id
 
@@ -3590,6 +3782,8 @@ class CreateSqlStatementRequest(TeaModel):
             result['limit'] = self.limit
         if self.sql_compute_id is not None:
             result['sqlComputeId'] = self.sql_compute_id
+        if self.task_biz_id is not None:
+            result['taskBizId'] = self.task_biz_id
         if self.region_id is not None:
             result['regionId'] = self.region_id
         return result
@@ -3606,6 +3800,8 @@ class CreateSqlStatementRequest(TeaModel):
             self.limit = m.get('limit')
         if m.get('sqlComputeId') is not None:
             self.sql_compute_id = m.get('sqlComputeId')
+        if m.get('taskBizId') is not None:
+            self.task_biz_id = m.get('taskBizId')
         if m.get('regionId') is not None:
             self.region_id = m.get('regionId')
         return self
@@ -4014,7 +4210,7 @@ class CreateWorkspaceResponse(TeaModel):
         return self
 
 
-class DeleteLivyComputeRequest(TeaModel):
+class DeleteKyuubiTokenRequest(TeaModel):
     def __init__(
         self,
         region_id: str = None,
@@ -4041,15 +4237,11 @@ class DeleteLivyComputeRequest(TeaModel):
         return self
 
 
-class DeleteLivyComputeResponseBody(TeaModel):
+class DeleteKyuubiTokenResponseBody(TeaModel):
     def __init__(
         self,
-        code: str = None,
-        message: str = None,
         request_id: str = None,
     ):
-        self.code = code
-        self.message = message
         self.request_id = request_id
 
     def validate(self):
@@ -4061,31 +4253,23 @@ class DeleteLivyComputeResponseBody(TeaModel):
             return _map
 
         result = dict()
-        if self.code is not None:
-            result['code'] = self.code
-        if self.message is not None:
-            result['message'] = self.message
         if self.request_id is not None:
             result['requestId'] = self.request_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('code') is not None:
-            self.code = m.get('code')
-        if m.get('message') is not None:
-            self.message = m.get('message')
         if m.get('requestId') is not None:
             self.request_id = m.get('requestId')
         return self
 
 
-class DeleteLivyComputeResponse(TeaModel):
+class DeleteKyuubiTokenResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: DeleteLivyComputeResponseBody = None,
+        body: DeleteKyuubiTokenResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -4116,12 +4300,12 @@ class DeleteLivyComputeResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = DeleteLivyComputeResponseBody()
+            temp_model = DeleteKyuubiTokenResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class DeleteLivyComputeTokenRequest(TeaModel):
+class DeleteLivyComputeRequest(TeaModel):
     def __init__(
         self,
         region_id: str = None,
@@ -4148,7 +4332,7 @@ class DeleteLivyComputeTokenRequest(TeaModel):
         return self
 
 
-class DeleteLivyComputeTokenResponseBody(TeaModel):
+class DeleteLivyComputeResponseBody(TeaModel):
     def __init__(
         self,
         code: str = None,
@@ -4187,12 +4371,12 @@ class DeleteLivyComputeTokenResponseBody(TeaModel):
         return self
 
 
-class DeleteLivyComputeTokenResponse(TeaModel):
+class DeleteLivyComputeResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: DeleteLivyComputeTokenResponseBody = None,
+        body: DeleteLivyComputeResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -4223,17 +4407,17 @@ class DeleteLivyComputeTokenResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = DeleteLivyComputeTokenResponseBody()
+            temp_model = DeleteLivyComputeResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class EditWorkspaceQueueRequestResourceSpec(TeaModel):
+class DeleteLivyComputeTokenRequest(TeaModel):
     def __init__(
         self,
-        cu: int = None,
+        region_id: str = None,
     ):
-        self.cu = cu
+        self.region_id = region_id
 
     def validate(self):
         pass
@@ -4244,35 +4428,30 @@ class EditWorkspaceQueueRequestResourceSpec(TeaModel):
             return _map
 
         result = dict()
-        if self.cu is not None:
-            result['cu'] = self.cu
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('cu') is not None:
-            self.cu = m.get('cu')
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
         return self
 
 
-class EditWorkspaceQueueRequest(TeaModel):
+class DeleteLivyComputeTokenResponseBody(TeaModel):
     def __init__(
         self,
-        environments: List[str] = None,
-        resource_spec: EditWorkspaceQueueRequestResourceSpec = None,
-        workspace_id: str = None,
-        workspace_queue_name: str = None,
-        region_id: str = None,
+        code: str = None,
+        message: str = None,
+        request_id: str = None,
     ):
-        self.environments = environments
-        self.resource_spec = resource_spec
-        self.workspace_id = workspace_id
-        self.workspace_queue_name = workspace_queue_name
-        self.region_id = region_id
+        self.code = code
+        self.message = message
+        self.request_id = request_id
 
     def validate(self):
-        if self.resource_spec:
-            self.resource_spec.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -4280,15 +4459,127 @@ class EditWorkspaceQueueRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.environments is not None:
-            result['environments'] = self.environments
-        if self.resource_spec is not None:
-            result['resourceSpec'] = self.resource_spec.to_map()
-        if self.workspace_id is not None:
-            result['workspaceId'] = self.workspace_id
-        if self.workspace_queue_name is not None:
-            result['workspaceQueueName'] = self.workspace_queue_name
-        if self.region_id is not None:
+        if self.code is not None:
+            result['code'] = self.code
+        if self.message is not None:
+            result['message'] = self.message
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('message') is not None:
+            self.message = m.get('message')
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class DeleteLivyComputeTokenResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: DeleteLivyComputeTokenResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = DeleteLivyComputeTokenResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class EditWorkspaceQueueRequestResourceSpec(TeaModel):
+    def __init__(
+        self,
+        cu: int = None,
+    ):
+        self.cu = cu
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.cu is not None:
+            result['cu'] = self.cu
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('cu') is not None:
+            self.cu = m.get('cu')
+        return self
+
+
+class EditWorkspaceQueueRequest(TeaModel):
+    def __init__(
+        self,
+        environments: List[str] = None,
+        resource_spec: EditWorkspaceQueueRequestResourceSpec = None,
+        workspace_id: str = None,
+        workspace_queue_name: str = None,
+        region_id: str = None,
+    ):
+        self.environments = environments
+        self.resource_spec = resource_spec
+        self.workspace_id = workspace_id
+        self.workspace_queue_name = workspace_queue_name
+        self.region_id = region_id
+
+    def validate(self):
+        if self.resource_spec:
+            self.resource_spec.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.environments is not None:
+            result['environments'] = self.environments
+        if self.resource_spec is not None:
+            result['resourceSpec'] = self.resource_spec.to_map()
+        if self.workspace_id is not None:
+            result['workspaceId'] = self.workspace_id
+        if self.workspace_queue_name is not None:
+            result['workspaceQueueName'] = self.workspace_queue_name
+        if self.region_id is not None:
             result['regionId'] = self.region_id
         return result
 
@@ -5025,7 +5316,7 @@ class GetJobRunResponse(TeaModel):
         return self
 
 
-class GetLivyComputeRequest(TeaModel):
+class GetKyuubiTokenRequest(TeaModel):
     def __init__(
         self,
         region_id: str = None,
@@ -5052,14 +5343,14 @@ class GetLivyComputeRequest(TeaModel):
         return self
 
 
-class GetLivyComputeResponseBodyDataAutoStopConfiguration(TeaModel):
+class GetKyuubiTokenResponseBodyDataAutoExpireConfiguration(TeaModel):
     def __init__(
         self,
         enable: bool = None,
-        idle_timeout_minutes: int = None,
+        expire_days: int = None,
     ):
         self.enable = enable
-        self.idle_timeout_minutes = idle_timeout_minutes
+        self.expire_days = expire_days
 
     def validate(self):
         pass
@@ -5072,71 +5363,46 @@ class GetLivyComputeResponseBodyDataAutoStopConfiguration(TeaModel):
         result = dict()
         if self.enable is not None:
             result['enable'] = self.enable
-        if self.idle_timeout_minutes is not None:
-            result['idleTimeoutMinutes'] = self.idle_timeout_minutes
+        if self.expire_days is not None:
+            result['expireDays'] = self.expire_days
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('enable') is not None:
             self.enable = m.get('enable')
-        if m.get('idleTimeoutMinutes') is not None:
-            self.idle_timeout_minutes = m.get('idleTimeoutMinutes')
+        if m.get('expireDays') is not None:
+            self.expire_days = m.get('expireDays')
         return self
 
 
-class GetLivyComputeResponseBodyData(TeaModel):
+class GetKyuubiTokenResponseBodyData(TeaModel):
     def __init__(
         self,
-        auth_type: str = None,
-        auto_stop_configuration: GetLivyComputeResponseBodyDataAutoStopConfiguration = None,
-        compute_id: str = None,
-        cpu_limit: str = None,
+        auto_expire_configuration: GetKyuubiTokenResponseBodyDataAutoExpireConfiguration = None,
+        create_time: int = None,
         created_by: str = None,
-        display_release_version: str = None,
-        enable_public: bool = None,
-        endpoint: str = None,
-        endpoint_inner: str = None,
-        environment_id: str = None,
-        fusion: bool = None,
-        gmt_create: int = None,
-        livy_server_conf: str = None,
-        livy_version: str = None,
-        memory_limit: str = None,
+        expire_time: int = None,
+        last_used_time: int = None,
+        member_arns: List[str] = None,
         name: str = None,
-        network_name: str = None,
-        queue_name: str = None,
-        ram_user_id: str = None,
-        release_version: str = None,
-        start_time: int = None,
-        status: str = None,
+        token: str = None,
+        token_id: str = None,
     ):
-        self.auth_type = auth_type
-        self.auto_stop_configuration = auto_stop_configuration
-        self.compute_id = compute_id
-        self.cpu_limit = cpu_limit
+        self.auto_expire_configuration = auto_expire_configuration
+        self.create_time = create_time
         self.created_by = created_by
-        self.display_release_version = display_release_version
-        self.enable_public = enable_public
-        self.endpoint = endpoint
-        self.endpoint_inner = endpoint_inner
-        self.environment_id = environment_id
-        self.fusion = fusion
-        self.gmt_create = gmt_create
-        self.livy_server_conf = livy_server_conf
-        self.livy_version = livy_version
-        self.memory_limit = memory_limit
+        self.expire_time = expire_time
+        self.last_used_time = last_used_time
+        self.member_arns = member_arns
         self.name = name
-        self.network_name = network_name
-        self.queue_name = queue_name
-        self.ram_user_id = ram_user_id
-        self.release_version = release_version
-        self.start_time = start_time
-        self.status = status
+        self.token = token
+        # Token ID。
+        self.token_id = token_id
 
     def validate(self):
-        if self.auto_stop_configuration:
-            self.auto_stop_configuration.validate()
+        if self.auto_expire_configuration:
+            self.auto_expire_configuration.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -5144,113 +5410,57 @@ class GetLivyComputeResponseBodyData(TeaModel):
             return _map
 
         result = dict()
-        if self.auth_type is not None:
-            result['authType'] = self.auth_type
-        if self.auto_stop_configuration is not None:
-            result['autoStopConfiguration'] = self.auto_stop_configuration.to_map()
-        if self.compute_id is not None:
-            result['computeId'] = self.compute_id
-        if self.cpu_limit is not None:
-            result['cpuLimit'] = self.cpu_limit
+        if self.auto_expire_configuration is not None:
+            result['autoExpireConfiguration'] = self.auto_expire_configuration.to_map()
+        if self.create_time is not None:
+            result['createTime'] = self.create_time
         if self.created_by is not None:
             result['createdBy'] = self.created_by
-        if self.display_release_version is not None:
-            result['displayReleaseVersion'] = self.display_release_version
-        if self.enable_public is not None:
-            result['enablePublic'] = self.enable_public
-        if self.endpoint is not None:
-            result['endpoint'] = self.endpoint
-        if self.endpoint_inner is not None:
-            result['endpointInner'] = self.endpoint_inner
-        if self.environment_id is not None:
-            result['environmentId'] = self.environment_id
-        if self.fusion is not None:
-            result['fusion'] = self.fusion
-        if self.gmt_create is not None:
-            result['gmtCreate'] = self.gmt_create
-        if self.livy_server_conf is not None:
-            result['livyServerConf'] = self.livy_server_conf
-        if self.livy_version is not None:
-            result['livyVersion'] = self.livy_version
-        if self.memory_limit is not None:
-            result['memoryLimit'] = self.memory_limit
+        if self.expire_time is not None:
+            result['expireTime'] = self.expire_time
+        if self.last_used_time is not None:
+            result['lastUsedTime'] = self.last_used_time
+        if self.member_arns is not None:
+            result['memberArns'] = self.member_arns
         if self.name is not None:
             result['name'] = self.name
-        if self.network_name is not None:
-            result['networkName'] = self.network_name
-        if self.queue_name is not None:
-            result['queueName'] = self.queue_name
-        if self.ram_user_id is not None:
-            result['ramUserId'] = self.ram_user_id
-        if self.release_version is not None:
-            result['releaseVersion'] = self.release_version
-        if self.start_time is not None:
-            result['startTime'] = self.start_time
-        if self.status is not None:
-            result['status'] = self.status
+        if self.token is not None:
+            result['token'] = self.token
+        if self.token_id is not None:
+            result['tokenId'] = self.token_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('authType') is not None:
-            self.auth_type = m.get('authType')
-        if m.get('autoStopConfiguration') is not None:
-            temp_model = GetLivyComputeResponseBodyDataAutoStopConfiguration()
-            self.auto_stop_configuration = temp_model.from_map(m['autoStopConfiguration'])
-        if m.get('computeId') is not None:
-            self.compute_id = m.get('computeId')
-        if m.get('cpuLimit') is not None:
-            self.cpu_limit = m.get('cpuLimit')
+        if m.get('autoExpireConfiguration') is not None:
+            temp_model = GetKyuubiTokenResponseBodyDataAutoExpireConfiguration()
+            self.auto_expire_configuration = temp_model.from_map(m['autoExpireConfiguration'])
+        if m.get('createTime') is not None:
+            self.create_time = m.get('createTime')
         if m.get('createdBy') is not None:
             self.created_by = m.get('createdBy')
-        if m.get('displayReleaseVersion') is not None:
-            self.display_release_version = m.get('displayReleaseVersion')
-        if m.get('enablePublic') is not None:
-            self.enable_public = m.get('enablePublic')
-        if m.get('endpoint') is not None:
-            self.endpoint = m.get('endpoint')
-        if m.get('endpointInner') is not None:
-            self.endpoint_inner = m.get('endpointInner')
-        if m.get('environmentId') is not None:
-            self.environment_id = m.get('environmentId')
-        if m.get('fusion') is not None:
-            self.fusion = m.get('fusion')
-        if m.get('gmtCreate') is not None:
-            self.gmt_create = m.get('gmtCreate')
-        if m.get('livyServerConf') is not None:
-            self.livy_server_conf = m.get('livyServerConf')
-        if m.get('livyVersion') is not None:
-            self.livy_version = m.get('livyVersion')
-        if m.get('memoryLimit') is not None:
-            self.memory_limit = m.get('memoryLimit')
+        if m.get('expireTime') is not None:
+            self.expire_time = m.get('expireTime')
+        if m.get('lastUsedTime') is not None:
+            self.last_used_time = m.get('lastUsedTime')
+        if m.get('memberArns') is not None:
+            self.member_arns = m.get('memberArns')
         if m.get('name') is not None:
             self.name = m.get('name')
-        if m.get('networkName') is not None:
-            self.network_name = m.get('networkName')
-        if m.get('queueName') is not None:
-            self.queue_name = m.get('queueName')
-        if m.get('ramUserId') is not None:
-            self.ram_user_id = m.get('ramUserId')
-        if m.get('releaseVersion') is not None:
-            self.release_version = m.get('releaseVersion')
-        if m.get('startTime') is not None:
-            self.start_time = m.get('startTime')
-        if m.get('status') is not None:
-            self.status = m.get('status')
+        if m.get('token') is not None:
+            self.token = m.get('token')
+        if m.get('tokenId') is not None:
+            self.token_id = m.get('tokenId')
         return self
 
 
-class GetLivyComputeResponseBody(TeaModel):
+class GetKyuubiTokenResponseBody(TeaModel):
     def __init__(
         self,
-        code: str = None,
-        data: GetLivyComputeResponseBodyData = None,
-        message: str = None,
+        data: GetKyuubiTokenResponseBodyData = None,
         request_id: str = None,
     ):
-        self.code = code
         self.data = data
-        self.message = message
         self.request_id = request_id
 
     def validate(self):
@@ -5263,36 +5473,28 @@ class GetLivyComputeResponseBody(TeaModel):
             return _map
 
         result = dict()
-        if self.code is not None:
-            result['code'] = self.code
         if self.data is not None:
             result['data'] = self.data.to_map()
-        if self.message is not None:
-            result['message'] = self.message
         if self.request_id is not None:
             result['requestId'] = self.request_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('code') is not None:
-            self.code = m.get('code')
         if m.get('data') is not None:
-            temp_model = GetLivyComputeResponseBodyData()
+            temp_model = GetKyuubiTokenResponseBodyData()
             self.data = temp_model.from_map(m['data'])
-        if m.get('message') is not None:
-            self.message = m.get('message')
         if m.get('requestId') is not None:
             self.request_id = m.get('requestId')
         return self
 
 
-class GetLivyComputeResponse(TeaModel):
+class GetKyuubiTokenResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: GetLivyComputeResponseBody = None,
+        body: GetKyuubiTokenResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -5323,12 +5525,12 @@ class GetLivyComputeResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = GetLivyComputeResponseBody()
+            temp_model = GetKyuubiTokenResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetLivyComputeTokenRequest(TeaModel):
+class GetLivyComputeRequest(TeaModel):
     def __init__(
         self,
         region_id: str = None,
@@ -5355,14 +5557,14 @@ class GetLivyComputeTokenRequest(TeaModel):
         return self
 
 
-class GetLivyComputeTokenResponseBodyDataAutoExpireConfiguration(TeaModel):
+class GetLivyComputeResponseBodyDataAutoStopConfiguration(TeaModel):
     def __init__(
         self,
         enable: bool = None,
-        expire_days: int = None,
+        idle_timeout_minutes: int = None,
     ):
         self.enable = enable
-        self.expire_days = expire_days
+        self.idle_timeout_minutes = idle_timeout_minutes
 
     def validate(self):
         pass
@@ -5375,44 +5577,71 @@ class GetLivyComputeTokenResponseBodyDataAutoExpireConfiguration(TeaModel):
         result = dict()
         if self.enable is not None:
             result['enable'] = self.enable
-        if self.expire_days is not None:
-            result['expireDays'] = self.expire_days
+        if self.idle_timeout_minutes is not None:
+            result['idleTimeoutMinutes'] = self.idle_timeout_minutes
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('enable') is not None:
             self.enable = m.get('enable')
-        if m.get('expireDays') is not None:
-            self.expire_days = m.get('expireDays')
+        if m.get('idleTimeoutMinutes') is not None:
+            self.idle_timeout_minutes = m.get('idleTimeoutMinutes')
         return self
 
 
-class GetLivyComputeTokenResponseBodyData(TeaModel):
+class GetLivyComputeResponseBodyData(TeaModel):
     def __init__(
         self,
-        auto_expire_configuration: GetLivyComputeTokenResponseBodyDataAutoExpireConfiguration = None,
-        create_time: int = None,
+        auth_type: str = None,
+        auto_stop_configuration: GetLivyComputeResponseBodyDataAutoStopConfiguration = None,
+        compute_id: str = None,
+        cpu_limit: str = None,
         created_by: str = None,
-        expire_time: int = None,
-        last_used_time: int = None,
+        display_release_version: str = None,
+        enable_public: bool = None,
+        endpoint: str = None,
+        endpoint_inner: str = None,
+        environment_id: str = None,
+        fusion: bool = None,
+        gmt_create: int = None,
+        livy_server_conf: str = None,
+        livy_version: str = None,
+        memory_limit: str = None,
         name: str = None,
-        token: str = None,
-        token_id: str = None,
+        network_name: str = None,
+        queue_name: str = None,
+        ram_user_id: str = None,
+        release_version: str = None,
+        start_time: int = None,
+        status: str = None,
     ):
-        self.auto_expire_configuration = auto_expire_configuration
-        self.create_time = create_time
+        self.auth_type = auth_type
+        self.auto_stop_configuration = auto_stop_configuration
+        self.compute_id = compute_id
+        self.cpu_limit = cpu_limit
         self.created_by = created_by
-        self.expire_time = expire_time
-        self.last_used_time = last_used_time
+        self.display_release_version = display_release_version
+        self.enable_public = enable_public
+        self.endpoint = endpoint
+        self.endpoint_inner = endpoint_inner
+        self.environment_id = environment_id
+        self.fusion = fusion
+        self.gmt_create = gmt_create
+        self.livy_server_conf = livy_server_conf
+        self.livy_version = livy_version
+        self.memory_limit = memory_limit
         self.name = name
-        self.token = token
-        # Token ID。
-        self.token_id = token_id
+        self.network_name = network_name
+        self.queue_name = queue_name
+        self.ram_user_id = ram_user_id
+        self.release_version = release_version
+        self.start_time = start_time
+        self.status = status
 
     def validate(self):
-        if self.auto_expire_configuration:
-            self.auto_expire_configuration.validate()
+        if self.auto_stop_configuration:
+            self.auto_stop_configuration.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -5420,51 +5649,107 @@ class GetLivyComputeTokenResponseBodyData(TeaModel):
             return _map
 
         result = dict()
-        if self.auto_expire_configuration is not None:
-            result['autoExpireConfiguration'] = self.auto_expire_configuration.to_map()
-        if self.create_time is not None:
-            result['createTime'] = self.create_time
+        if self.auth_type is not None:
+            result['authType'] = self.auth_type
+        if self.auto_stop_configuration is not None:
+            result['autoStopConfiguration'] = self.auto_stop_configuration.to_map()
+        if self.compute_id is not None:
+            result['computeId'] = self.compute_id
+        if self.cpu_limit is not None:
+            result['cpuLimit'] = self.cpu_limit
         if self.created_by is not None:
             result['createdBy'] = self.created_by
-        if self.expire_time is not None:
-            result['expireTime'] = self.expire_time
-        if self.last_used_time is not None:
-            result['lastUsedTime'] = self.last_used_time
+        if self.display_release_version is not None:
+            result['displayReleaseVersion'] = self.display_release_version
+        if self.enable_public is not None:
+            result['enablePublic'] = self.enable_public
+        if self.endpoint is not None:
+            result['endpoint'] = self.endpoint
+        if self.endpoint_inner is not None:
+            result['endpointInner'] = self.endpoint_inner
+        if self.environment_id is not None:
+            result['environmentId'] = self.environment_id
+        if self.fusion is not None:
+            result['fusion'] = self.fusion
+        if self.gmt_create is not None:
+            result['gmtCreate'] = self.gmt_create
+        if self.livy_server_conf is not None:
+            result['livyServerConf'] = self.livy_server_conf
+        if self.livy_version is not None:
+            result['livyVersion'] = self.livy_version
+        if self.memory_limit is not None:
+            result['memoryLimit'] = self.memory_limit
         if self.name is not None:
             result['name'] = self.name
-        if self.token is not None:
-            result['token'] = self.token
-        if self.token_id is not None:
-            result['tokenId'] = self.token_id
+        if self.network_name is not None:
+            result['networkName'] = self.network_name
+        if self.queue_name is not None:
+            result['queueName'] = self.queue_name
+        if self.ram_user_id is not None:
+            result['ramUserId'] = self.ram_user_id
+        if self.release_version is not None:
+            result['releaseVersion'] = self.release_version
+        if self.start_time is not None:
+            result['startTime'] = self.start_time
+        if self.status is not None:
+            result['status'] = self.status
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('autoExpireConfiguration') is not None:
-            temp_model = GetLivyComputeTokenResponseBodyDataAutoExpireConfiguration()
-            self.auto_expire_configuration = temp_model.from_map(m['autoExpireConfiguration'])
-        if m.get('createTime') is not None:
-            self.create_time = m.get('createTime')
+        if m.get('authType') is not None:
+            self.auth_type = m.get('authType')
+        if m.get('autoStopConfiguration') is not None:
+            temp_model = GetLivyComputeResponseBodyDataAutoStopConfiguration()
+            self.auto_stop_configuration = temp_model.from_map(m['autoStopConfiguration'])
+        if m.get('computeId') is not None:
+            self.compute_id = m.get('computeId')
+        if m.get('cpuLimit') is not None:
+            self.cpu_limit = m.get('cpuLimit')
         if m.get('createdBy') is not None:
             self.created_by = m.get('createdBy')
-        if m.get('expireTime') is not None:
-            self.expire_time = m.get('expireTime')
-        if m.get('lastUsedTime') is not None:
-            self.last_used_time = m.get('lastUsedTime')
+        if m.get('displayReleaseVersion') is not None:
+            self.display_release_version = m.get('displayReleaseVersion')
+        if m.get('enablePublic') is not None:
+            self.enable_public = m.get('enablePublic')
+        if m.get('endpoint') is not None:
+            self.endpoint = m.get('endpoint')
+        if m.get('endpointInner') is not None:
+            self.endpoint_inner = m.get('endpointInner')
+        if m.get('environmentId') is not None:
+            self.environment_id = m.get('environmentId')
+        if m.get('fusion') is not None:
+            self.fusion = m.get('fusion')
+        if m.get('gmtCreate') is not None:
+            self.gmt_create = m.get('gmtCreate')
+        if m.get('livyServerConf') is not None:
+            self.livy_server_conf = m.get('livyServerConf')
+        if m.get('livyVersion') is not None:
+            self.livy_version = m.get('livyVersion')
+        if m.get('memoryLimit') is not None:
+            self.memory_limit = m.get('memoryLimit')
         if m.get('name') is not None:
             self.name = m.get('name')
-        if m.get('token') is not None:
-            self.token = m.get('token')
-        if m.get('tokenId') is not None:
-            self.token_id = m.get('tokenId')
+        if m.get('networkName') is not None:
+            self.network_name = m.get('networkName')
+        if m.get('queueName') is not None:
+            self.queue_name = m.get('queueName')
+        if m.get('ramUserId') is not None:
+            self.ram_user_id = m.get('ramUserId')
+        if m.get('releaseVersion') is not None:
+            self.release_version = m.get('releaseVersion')
+        if m.get('startTime') is not None:
+            self.start_time = m.get('startTime')
+        if m.get('status') is not None:
+            self.status = m.get('status')
         return self
 
 
-class GetLivyComputeTokenResponseBody(TeaModel):
+class GetLivyComputeResponseBody(TeaModel):
     def __init__(
         self,
         code: str = None,
-        data: GetLivyComputeTokenResponseBodyData = None,
+        data: GetLivyComputeResponseBodyData = None,
         message: str = None,
         request_id: str = None,
     ):
@@ -5498,7 +5783,7 @@ class GetLivyComputeTokenResponseBody(TeaModel):
         if m.get('code') is not None:
             self.code = m.get('code')
         if m.get('data') is not None:
-            temp_model = GetLivyComputeTokenResponseBodyData()
+            temp_model = GetLivyComputeResponseBodyData()
             self.data = temp_model.from_map(m['data'])
         if m.get('message') is not None:
             self.message = m.get('message')
@@ -5507,12 +5792,232 @@ class GetLivyComputeTokenResponseBody(TeaModel):
         return self
 
 
-class GetLivyComputeTokenResponse(TeaModel):
+class GetLivyComputeResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: GetLivyComputeTokenResponseBody = None,
+        body: GetLivyComputeResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = GetLivyComputeResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetLivyComputeTokenRequest(TeaModel):
+    def __init__(
+        self,
+        region_id: str = None,
+    ):
+        self.region_id = region_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
+        return self
+
+
+class GetLivyComputeTokenResponseBodyDataAutoExpireConfiguration(TeaModel):
+    def __init__(
+        self,
+        enable: bool = None,
+        expire_days: int = None,
+    ):
+        self.enable = enable
+        self.expire_days = expire_days
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.enable is not None:
+            result['enable'] = self.enable
+        if self.expire_days is not None:
+            result['expireDays'] = self.expire_days
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('enable') is not None:
+            self.enable = m.get('enable')
+        if m.get('expireDays') is not None:
+            self.expire_days = m.get('expireDays')
+        return self
+
+
+class GetLivyComputeTokenResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        auto_expire_configuration: GetLivyComputeTokenResponseBodyDataAutoExpireConfiguration = None,
+        create_time: int = None,
+        created_by: str = None,
+        expire_time: int = None,
+        last_used_time: int = None,
+        name: str = None,
+        token: str = None,
+        token_id: str = None,
+    ):
+        self.auto_expire_configuration = auto_expire_configuration
+        self.create_time = create_time
+        self.created_by = created_by
+        self.expire_time = expire_time
+        self.last_used_time = last_used_time
+        self.name = name
+        self.token = token
+        # Token ID。
+        self.token_id = token_id
+
+    def validate(self):
+        if self.auto_expire_configuration:
+            self.auto_expire_configuration.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.auto_expire_configuration is not None:
+            result['autoExpireConfiguration'] = self.auto_expire_configuration.to_map()
+        if self.create_time is not None:
+            result['createTime'] = self.create_time
+        if self.created_by is not None:
+            result['createdBy'] = self.created_by
+        if self.expire_time is not None:
+            result['expireTime'] = self.expire_time
+        if self.last_used_time is not None:
+            result['lastUsedTime'] = self.last_used_time
+        if self.name is not None:
+            result['name'] = self.name
+        if self.token is not None:
+            result['token'] = self.token
+        if self.token_id is not None:
+            result['tokenId'] = self.token_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('autoExpireConfiguration') is not None:
+            temp_model = GetLivyComputeTokenResponseBodyDataAutoExpireConfiguration()
+            self.auto_expire_configuration = temp_model.from_map(m['autoExpireConfiguration'])
+        if m.get('createTime') is not None:
+            self.create_time = m.get('createTime')
+        if m.get('createdBy') is not None:
+            self.created_by = m.get('createdBy')
+        if m.get('expireTime') is not None:
+            self.expire_time = m.get('expireTime')
+        if m.get('lastUsedTime') is not None:
+            self.last_used_time = m.get('lastUsedTime')
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('token') is not None:
+            self.token = m.get('token')
+        if m.get('tokenId') is not None:
+            self.token_id = m.get('tokenId')
+        return self
+
+
+class GetLivyComputeTokenResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: GetLivyComputeTokenResponseBodyData = None,
+        message: str = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        self.data = data
+        self.message = message
+        self.request_id = request_id
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['code'] = self.code
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.message is not None:
+            result['message'] = self.message
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('data') is not None:
+            temp_model = GetLivyComputeTokenResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('message') is not None:
+            self.message = m.get('message')
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class GetLivyComputeTokenResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetLivyComputeTokenResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -6319,8 +6824,333 @@ class GetTemplateResponseBody(TeaModel):
         self.success = success
 
     def validate(self):
-        if self.data:
-            self.data.validate()
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.error_code is not None:
+            result['errorCode'] = self.error_code
+        if self.error_message is not None:
+            result['errorMessage'] = self.error_message
+        if self.http_status_code is not None:
+            result['httpStatusCode'] = self.http_status_code
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        if self.success is not None:
+            result['success'] = self.success
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('data') is not None:
+            temp_model = Template()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('errorCode') is not None:
+            self.error_code = m.get('errorCode')
+        if m.get('errorMessage') is not None:
+            self.error_message = m.get('errorMessage')
+        if m.get('httpStatusCode') is not None:
+            self.http_status_code = m.get('httpStatusCode')
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        if m.get('success') is not None:
+            self.success = m.get('success')
+        return self
+
+
+class GetTemplateResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetTemplateResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = GetTemplateResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GrantRoleToUsersRequest(TeaModel):
+    def __init__(
+        self,
+        role_arn: str = None,
+        user_arns: List[str] = None,
+        region_id: str = None,
+    ):
+        # The Alibaba Cloud Resource Name (ARN) of the RAM role.
+        self.role_arn = role_arn
+        # The user ARNs.
+        self.user_arns = user_arns
+        # The region ID.
+        self.region_id = region_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.role_arn is not None:
+            result['roleArn'] = self.role_arn
+        if self.user_arns is not None:
+            result['userArns'] = self.user_arns
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('roleArn') is not None:
+            self.role_arn = m.get('roleArn')
+        if m.get('userArns') is not None:
+            self.user_arns = m.get('userArns')
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
+        return self
+
+
+class GrantRoleToUsersResponseBody(TeaModel):
+    def __init__(
+        self,
+        request_id: str = None,
+    ):
+        # The request ID.
+        self.request_id = request_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class GrantRoleToUsersResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GrantRoleToUsersResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = GrantRoleToUsersResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListCatalogsRequest(TeaModel):
+    def __init__(
+        self,
+        environment: str = None,
+        region_id: str = None,
+    ):
+        self.environment = environment
+        self.region_id = region_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.environment is not None:
+            result['environment'] = self.environment
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('environment') is not None:
+            self.environment = m.get('environment')
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
+        return self
+
+
+class ListCatalogsResponseBodyCatalogs(TeaModel):
+    def __init__(
+        self,
+        catalog_id: str = None,
+        catalog_provider: str = None,
+        catalog_type: str = None,
+        environments: List[str] = None,
+        extras: Dict[str, str] = None,
+        gmt_create: int = None,
+        gmt_modified: int = None,
+        resource_owner_id: str = None,
+        workspace_id: str = None,
+    ):
+        # regionId。
+        self.catalog_id = catalog_id
+        self.catalog_provider = catalog_provider
+        self.catalog_type = catalog_type
+        self.environments = environments
+        self.extras = extras
+        self.gmt_create = gmt_create
+        self.gmt_modified = gmt_modified
+        self.resource_owner_id = resource_owner_id
+        # 工作空间id。
+        self.workspace_id = workspace_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.catalog_id is not None:
+            result['catalogId'] = self.catalog_id
+        if self.catalog_provider is not None:
+            result['catalogProvider'] = self.catalog_provider
+        if self.catalog_type is not None:
+            result['catalogType'] = self.catalog_type
+        if self.environments is not None:
+            result['environments'] = self.environments
+        if self.extras is not None:
+            result['extras'] = self.extras
+        if self.gmt_create is not None:
+            result['gmtCreate'] = self.gmt_create
+        if self.gmt_modified is not None:
+            result['gmtModified'] = self.gmt_modified
+        if self.resource_owner_id is not None:
+            result['resourceOwnerId'] = self.resource_owner_id
+        if self.workspace_id is not None:
+            result['workspaceId'] = self.workspace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('catalogId') is not None:
+            self.catalog_id = m.get('catalogId')
+        if m.get('catalogProvider') is not None:
+            self.catalog_provider = m.get('catalogProvider')
+        if m.get('catalogType') is not None:
+            self.catalog_type = m.get('catalogType')
+        if m.get('environments') is not None:
+            self.environments = m.get('environments')
+        if m.get('extras') is not None:
+            self.extras = m.get('extras')
+        if m.get('gmtCreate') is not None:
+            self.gmt_create = m.get('gmtCreate')
+        if m.get('gmtModified') is not None:
+            self.gmt_modified = m.get('gmtModified')
+        if m.get('resourceOwnerId') is not None:
+            self.resource_owner_id = m.get('resourceOwnerId')
+        if m.get('workspaceId') is not None:
+            self.workspace_id = m.get('workspaceId')
+        return self
+
+
+class ListCatalogsResponseBody(TeaModel):
+    def __init__(
+        self,
+        catalogs: List[ListCatalogsResponseBodyCatalogs] = None,
+        max_results: int = None,
+        next_token: str = None,
+        request_id: str = None,
+        total_count: int = None,
+    ):
+        self.catalogs = catalogs
+        # 一次获取的最大记录数。
+        self.max_results = max_results
+        # 下一页TOKEN。
+        self.next_token = next_token
+        # 请求ID。
+        self.request_id = request_id
+        # 记录总数。
+        self.total_count = total_count
+
+    def validate(self):
+        if self.catalogs:
+            for k in self.catalogs:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -6328,44 +7158,44 @@ class GetTemplateResponseBody(TeaModel):
             return _map
 
         result = dict()
-        if self.data is not None:
-            result['data'] = self.data.to_map()
-        if self.error_code is not None:
-            result['errorCode'] = self.error_code
-        if self.error_message is not None:
-            result['errorMessage'] = self.error_message
-        if self.http_status_code is not None:
-            result['httpStatusCode'] = self.http_status_code
+        result['catalogs'] = []
+        if self.catalogs is not None:
+            for k in self.catalogs:
+                result['catalogs'].append(k.to_map() if k else None)
+        if self.max_results is not None:
+            result['maxResults'] = self.max_results
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
         if self.request_id is not None:
             result['requestId'] = self.request_id
-        if self.success is not None:
-            result['success'] = self.success
+        if self.total_count is not None:
+            result['totalCount'] = self.total_count
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('data') is not None:
-            temp_model = Template()
-            self.data = temp_model.from_map(m['data'])
-        if m.get('errorCode') is not None:
-            self.error_code = m.get('errorCode')
-        if m.get('errorMessage') is not None:
-            self.error_message = m.get('errorMessage')
-        if m.get('httpStatusCode') is not None:
-            self.http_status_code = m.get('httpStatusCode')
+        self.catalogs = []
+        if m.get('catalogs') is not None:
+            for k in m.get('catalogs'):
+                temp_model = ListCatalogsResponseBodyCatalogs()
+                self.catalogs.append(temp_model.from_map(k))
+        if m.get('maxResults') is not None:
+            self.max_results = m.get('maxResults')
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
         if m.get('requestId') is not None:
             self.request_id = m.get('requestId')
-        if m.get('success') is not None:
-            self.success = m.get('success')
+        if m.get('totalCount') is not None:
+            self.total_count = m.get('totalCount')
         return self
 
 
-class GetTemplateResponse(TeaModel):
+class ListCatalogsResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: GetTemplateResponseBody = None,
+        body: ListCatalogsResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -6396,24 +7226,25 @@ class GetTemplateResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = GetTemplateResponseBody()
+            temp_model = ListCatalogsResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GrantRoleToUsersRequest(TeaModel):
+class ListJobExecutorsRequest(TeaModel):
     def __init__(
         self,
-        role_arn: str = None,
-        user_arns: List[str] = None,
+        executor_type: str = None,
+        max_results: int = None,
+        next_token: str = None,
         region_id: str = None,
+        status: str = None,
     ):
-        # The Alibaba Cloud Resource Name (ARN) of the RAM role.
-        self.role_arn = role_arn
-        # The user ARNs.
-        self.user_arns = user_arns
-        # The region ID.
+        self.executor_type = executor_type
+        self.max_results = max_results
+        self.next_token = next_token
         self.region_id = region_id
+        self.status = status
 
     def validate(self):
         pass
@@ -6424,35 +7255,201 @@ class GrantRoleToUsersRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.role_arn is not None:
-            result['roleArn'] = self.role_arn
-        if self.user_arns is not None:
-            result['userArns'] = self.user_arns
+        if self.executor_type is not None:
+            result['executorType'] = self.executor_type
+        if self.max_results is not None:
+            result['maxResults'] = self.max_results
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
         if self.region_id is not None:
             result['regionId'] = self.region_id
+        if self.status is not None:
+            result['status'] = self.status
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('roleArn') is not None:
-            self.role_arn = m.get('roleArn')
-        if m.get('userArns') is not None:
-            self.user_arns = m.get('userArns')
+        if m.get('executorType') is not None:
+            self.executor_type = m.get('executorType')
+        if m.get('maxResults') is not None:
+            self.max_results = m.get('maxResults')
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
         if m.get('regionId') is not None:
             self.region_id = m.get('regionId')
+        if m.get('status') is not None:
+            self.status = m.get('status')
         return self
 
 
-class GrantRoleToUsersResponseBody(TeaModel):
+class ListJobExecutorsResponseBodyExexutors(TeaModel):
+    def __init__(
+        self,
+        active_tasks: int = None,
+        add_time: int = None,
+        completed_tasks: int = None,
+        disk_used: int = None,
+        executor_id: str = None,
+        executor_type: str = None,
+        failed_tasks: int = None,
+        host_port: str = None,
+        job_run_id: str = None,
+        max_memory: int = None,
+        memory_used: int = None,
+        rdd_blocks: int = None,
+        status: str = None,
+        total_cores: int = None,
+        total_duration: int = None,
+        total_gctime: int = None,
+        total_input_bytes: int = None,
+        total_shuffle_read: int = None,
+        total_shuffle_write: int = None,
+        total_tasks: int = None,
+        workspace_id: str = None,
+    ):
+        self.active_tasks = active_tasks
+        self.add_time = add_time
+        self.completed_tasks = completed_tasks
+        self.disk_used = disk_used
+        self.executor_id = executor_id
+        self.executor_type = executor_type
+        self.failed_tasks = failed_tasks
+        self.host_port = host_port
+        self.job_run_id = job_run_id
+        self.max_memory = max_memory
+        self.memory_used = memory_used
+        self.rdd_blocks = rdd_blocks
+        self.status = status
+        self.total_cores = total_cores
+        self.total_duration = total_duration
+        self.total_gctime = total_gctime
+        self.total_input_bytes = total_input_bytes
+        self.total_shuffle_read = total_shuffle_read
+        self.total_shuffle_write = total_shuffle_write
+        self.total_tasks = total_tasks
+        self.workspace_id = workspace_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.active_tasks is not None:
+            result['activeTasks'] = self.active_tasks
+        if self.add_time is not None:
+            result['addTime'] = self.add_time
+        if self.completed_tasks is not None:
+            result['completedTasks'] = self.completed_tasks
+        if self.disk_used is not None:
+            result['diskUsed'] = self.disk_used
+        if self.executor_id is not None:
+            result['executorId'] = self.executor_id
+        if self.executor_type is not None:
+            result['executorType'] = self.executor_type
+        if self.failed_tasks is not None:
+            result['failedTasks'] = self.failed_tasks
+        if self.host_port is not None:
+            result['hostPort'] = self.host_port
+        if self.job_run_id is not None:
+            result['jobRunId'] = self.job_run_id
+        if self.max_memory is not None:
+            result['maxMemory'] = self.max_memory
+        if self.memory_used is not None:
+            result['memoryUsed'] = self.memory_used
+        if self.rdd_blocks is not None:
+            result['rddBlocks'] = self.rdd_blocks
+        if self.status is not None:
+            result['status'] = self.status
+        if self.total_cores is not None:
+            result['totalCores'] = self.total_cores
+        if self.total_duration is not None:
+            result['totalDuration'] = self.total_duration
+        if self.total_gctime is not None:
+            result['totalGCTime'] = self.total_gctime
+        if self.total_input_bytes is not None:
+            result['totalInputBytes'] = self.total_input_bytes
+        if self.total_shuffle_read is not None:
+            result['totalShuffleRead'] = self.total_shuffle_read
+        if self.total_shuffle_write is not None:
+            result['totalShuffleWrite'] = self.total_shuffle_write
+        if self.total_tasks is not None:
+            result['totalTasks'] = self.total_tasks
+        if self.workspace_id is not None:
+            result['workspaceId'] = self.workspace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('activeTasks') is not None:
+            self.active_tasks = m.get('activeTasks')
+        if m.get('addTime') is not None:
+            self.add_time = m.get('addTime')
+        if m.get('completedTasks') is not None:
+            self.completed_tasks = m.get('completedTasks')
+        if m.get('diskUsed') is not None:
+            self.disk_used = m.get('diskUsed')
+        if m.get('executorId') is not None:
+            self.executor_id = m.get('executorId')
+        if m.get('executorType') is not None:
+            self.executor_type = m.get('executorType')
+        if m.get('failedTasks') is not None:
+            self.failed_tasks = m.get('failedTasks')
+        if m.get('hostPort') is not None:
+            self.host_port = m.get('hostPort')
+        if m.get('jobRunId') is not None:
+            self.job_run_id = m.get('jobRunId')
+        if m.get('maxMemory') is not None:
+            self.max_memory = m.get('maxMemory')
+        if m.get('memoryUsed') is not None:
+            self.memory_used = m.get('memoryUsed')
+        if m.get('rddBlocks') is not None:
+            self.rdd_blocks = m.get('rddBlocks')
+        if m.get('status') is not None:
+            self.status = m.get('status')
+        if m.get('totalCores') is not None:
+            self.total_cores = m.get('totalCores')
+        if m.get('totalDuration') is not None:
+            self.total_duration = m.get('totalDuration')
+        if m.get('totalGCTime') is not None:
+            self.total_gctime = m.get('totalGCTime')
+        if m.get('totalInputBytes') is not None:
+            self.total_input_bytes = m.get('totalInputBytes')
+        if m.get('totalShuffleRead') is not None:
+            self.total_shuffle_read = m.get('totalShuffleRead')
+        if m.get('totalShuffleWrite') is not None:
+            self.total_shuffle_write = m.get('totalShuffleWrite')
+        if m.get('totalTasks') is not None:
+            self.total_tasks = m.get('totalTasks')
+        if m.get('workspaceId') is not None:
+            self.workspace_id = m.get('workspaceId')
+        return self
+
+
+class ListJobExecutorsResponseBody(TeaModel):
     def __init__(
         self,
+        exexutors: List[ListJobExecutorsResponseBodyExexutors] = None,
+        max_results: int = None,
+        next_token: str = None,
         request_id: str = None,
+        total_count: int = None,
     ):
-        # The request ID.
+        self.exexutors = exexutors
+        self.max_results = max_results
+        self.next_token = next_token
+        # Id of the request
         self.request_id = request_id
+        self.total_count = total_count
 
     def validate(self):
-        pass
+        if self.exexutors:
+            for k in self.exexutors:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -6460,23 +7457,44 @@ class GrantRoleToUsersResponseBody(TeaModel):
             return _map
 
         result = dict()
+        result['exexutors'] = []
+        if self.exexutors is not None:
+            for k in self.exexutors:
+                result['exexutors'].append(k.to_map() if k else None)
+        if self.max_results is not None:
+            result['maxResults'] = self.max_results
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
         if self.request_id is not None:
             result['requestId'] = self.request_id
+        if self.total_count is not None:
+            result['totalCount'] = self.total_count
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        self.exexutors = []
+        if m.get('exexutors') is not None:
+            for k in m.get('exexutors'):
+                temp_model = ListJobExecutorsResponseBodyExexutors()
+                self.exexutors.append(temp_model.from_map(k))
+        if m.get('maxResults') is not None:
+            self.max_results = m.get('maxResults')
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
         if m.get('requestId') is not None:
             self.request_id = m.get('requestId')
+        if m.get('totalCount') is not None:
+            self.total_count = m.get('totalCount')
         return self
 
 
-class GrantRoleToUsersResponse(TeaModel):
+class ListJobExecutorsResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: GrantRoleToUsersResponseBody = None,
+        body: ListJobExecutorsResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -6507,7 +7525,7 @@ class GrantRoleToUsersResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = GrantRoleToUsersResponseBody()
+            temp_model = ListJobExecutorsResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
@@ -9968,12 +10986,132 @@ class ListSqlStatementContentsRequest(TeaModel):
         max_results: int = None,
         next_token: str = None,
     ):
-        self.file_name = file_name
-        self.max_results = max_results
-        self.next_token = next_token
+        self.file_name = file_name
+        self.max_results = max_results
+        self.next_token = next_token
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.file_name is not None:
+            result['fileName'] = self.file_name
+        if self.max_results is not None:
+            result['maxResults'] = self.max_results
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('fileName') is not None:
+            self.file_name = m.get('fileName')
+        if m.get('maxResults') is not None:
+            self.max_results = m.get('maxResults')
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
+        return self
+
+
+class ListSqlStatementContentsResponseBodySqlStatementContents(TeaModel):
+    def __init__(
+        self,
+        contents: str = None,
+        max_results: int = None,
+        next_token: str = None,
+        total_count: int = None,
+    ):
+        self.contents = contents
+        self.max_results = max_results
+        self.next_token = next_token
+        self.total_count = total_count
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.contents is not None:
+            result['contents'] = self.contents
+        if self.max_results is not None:
+            result['maxResults'] = self.max_results
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
+        if self.total_count is not None:
+            result['totalCount'] = self.total_count
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('contents') is not None:
+            self.contents = m.get('contents')
+        if m.get('maxResults') is not None:
+            self.max_results = m.get('maxResults')
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
+        if m.get('totalCount') is not None:
+            self.total_count = m.get('totalCount')
+        return self
+
+
+class ListSqlStatementContentsResponseBody(TeaModel):
+    def __init__(
+        self,
+        request_id: str = None,
+        sql_statement_contents: ListSqlStatementContentsResponseBodySqlStatementContents = None,
+    ):
+        self.request_id = request_id
+        self.sql_statement_contents = sql_statement_contents
+
+    def validate(self):
+        if self.sql_statement_contents:
+            self.sql_statement_contents.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        if self.sql_statement_contents is not None:
+            result['sqlStatementContents'] = self.sql_statement_contents.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        if m.get('sqlStatementContents') is not None:
+            temp_model = ListSqlStatementContentsResponseBodySqlStatementContents()
+            self.sql_statement_contents = temp_model.from_map(m['sqlStatementContents'])
+        return self
+
+
+class ListSqlStatementContentsResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListSqlStatementContentsResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
 
     def validate(self):
-        pass
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -9981,37 +11119,32 @@ class ListSqlStatementContentsRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.file_name is not None:
-            result['fileName'] = self.file_name
-        if self.max_results is not None:
-            result['maxResults'] = self.max_results
-        if self.next_token is not None:
-            result['nextToken'] = self.next_token
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('fileName') is not None:
-            self.file_name = m.get('fileName')
-        if m.get('maxResults') is not None:
-            self.max_results = m.get('maxResults')
-        if m.get('nextToken') is not None:
-            self.next_token = m.get('nextToken')
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListSqlStatementContentsResponseBody()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListSqlStatementContentsResponseBodySqlStatementContents(TeaModel):
+class ListTemplateRequest(TeaModel):
     def __init__(
         self,
-        contents: str = None,
-        max_results: int = None,
-        next_token: str = None,
-        total_count: int = None,
+        region_id: str = None,
     ):
-        self.contents = contents
-        self.max_results = max_results
-        self.next_token = next_token
-        self.total_count = total_count
+        self.region_id = region_id
 
     def validate(self):
         pass
@@ -10022,41 +11155,39 @@ class ListSqlStatementContentsResponseBodySqlStatementContents(TeaModel):
             return _map
 
         result = dict()
-        if self.contents is not None:
-            result['contents'] = self.contents
-        if self.max_results is not None:
-            result['maxResults'] = self.max_results
-        if self.next_token is not None:
-            result['nextToken'] = self.next_token
-        if self.total_count is not None:
-            result['totalCount'] = self.total_count
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('contents') is not None:
-            self.contents = m.get('contents')
-        if m.get('maxResults') is not None:
-            self.max_results = m.get('maxResults')
-        if m.get('nextToken') is not None:
-            self.next_token = m.get('nextToken')
-        if m.get('totalCount') is not None:
-            self.total_count = m.get('totalCount')
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
         return self
 
 
-class ListSqlStatementContentsResponseBody(TeaModel):
+class ListTemplateResponseBody(TeaModel):
     def __init__(
         self,
+        data: List[Template] = None,
+        error_code: str = None,
+        error_message: str = None,
+        http_status_code: str = None,
         request_id: str = None,
-        sql_statement_contents: ListSqlStatementContentsResponseBodySqlStatementContents = None,
+        success: bool = None,
     ):
+        self.data = data
+        self.error_code = error_code
+        self.error_message = error_message
+        self.http_status_code = http_status_code
         self.request_id = request_id
-        self.sql_statement_contents = sql_statement_contents
+        self.success = success
 
     def validate(self):
-        if self.sql_statement_contents:
-            self.sql_statement_contents.validate()
+        if self.data:
+            for k in self.data:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -10064,28 +11195,48 @@ class ListSqlStatementContentsResponseBody(TeaModel):
             return _map
 
         result = dict()
+        result['data'] = []
+        if self.data is not None:
+            for k in self.data:
+                result['data'].append(k.to_map() if k else None)
+        if self.error_code is not None:
+            result['errorCode'] = self.error_code
+        if self.error_message is not None:
+            result['errorMessage'] = self.error_message
+        if self.http_status_code is not None:
+            result['httpStatusCode'] = self.http_status_code
         if self.request_id is not None:
             result['requestId'] = self.request_id
-        if self.sql_statement_contents is not None:
-            result['sqlStatementContents'] = self.sql_statement_contents.to_map()
+        if self.success is not None:
+            result['success'] = self.success
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        self.data = []
+        if m.get('data') is not None:
+            for k in m.get('data'):
+                temp_model = Template()
+                self.data.append(temp_model.from_map(k))
+        if m.get('errorCode') is not None:
+            self.error_code = m.get('errorCode')
+        if m.get('errorMessage') is not None:
+            self.error_message = m.get('errorMessage')
+        if m.get('httpStatusCode') is not None:
+            self.http_status_code = m.get('httpStatusCode')
         if m.get('requestId') is not None:
             self.request_id = m.get('requestId')
-        if m.get('sqlStatementContents') is not None:
-            temp_model = ListSqlStatementContentsResponseBodySqlStatementContents()
-            self.sql_statement_contents = temp_model.from_map(m['sqlStatementContents'])
+        if m.get('success') is not None:
+            self.success = m.get('success')
         return self
 
 
-class ListSqlStatementContentsResponse(TeaModel):
+class ListTemplateResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListSqlStatementContentsResponseBody = None,
+        body: ListTemplateResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -10116,7 +11267,7 @@ class ListSqlStatementContentsResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListSqlStatementContentsResponseBody()
+            temp_model = ListTemplateResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
@@ -12281,6 +13432,160 @@ class TerminateSqlStatementResponse(TeaModel):
         return self
 
 
+class UpdateKyuubiTokenRequestAutoExpireConfiguration(TeaModel):
+    def __init__(
+        self,
+        enable: bool = None,
+        expire_days: int = None,
+    ):
+        self.enable = enable
+        self.expire_days = expire_days
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.enable is not None:
+            result['enable'] = self.enable
+        if self.expire_days is not None:
+            result['expireDays'] = self.expire_days
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('enable') is not None:
+            self.enable = m.get('enable')
+        if m.get('expireDays') is not None:
+            self.expire_days = m.get('expireDays')
+        return self
+
+
+class UpdateKyuubiTokenRequest(TeaModel):
+    def __init__(
+        self,
+        auto_expire_configuration: UpdateKyuubiTokenRequestAutoExpireConfiguration = None,
+        member_arns: List[str] = None,
+        name: str = None,
+        token: str = None,
+        region_id: str = None,
+    ):
+        self.auto_expire_configuration = auto_expire_configuration
+        self.member_arns = member_arns
+        self.name = name
+        self.token = token
+        self.region_id = region_id
+
+    def validate(self):
+        if self.auto_expire_configuration:
+            self.auto_expire_configuration.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.auto_expire_configuration is not None:
+            result['autoExpireConfiguration'] = self.auto_expire_configuration.to_map()
+        if self.member_arns is not None:
+            result['memberArns'] = self.member_arns
+        if self.name is not None:
+            result['name'] = self.name
+        if self.token is not None:
+            result['token'] = self.token
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('autoExpireConfiguration') is not None:
+            temp_model = UpdateKyuubiTokenRequestAutoExpireConfiguration()
+            self.auto_expire_configuration = temp_model.from_map(m['autoExpireConfiguration'])
+        if m.get('memberArns') is not None:
+            self.member_arns = m.get('memberArns')
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('token') is not None:
+            self.token = m.get('token')
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
+        return self
+
+
+class UpdateKyuubiTokenResponseBody(TeaModel):
+    def __init__(
+        self,
+        request_id: str = None,
+    ):
+        self.request_id = request_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class UpdateKyuubiTokenResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: UpdateKyuubiTokenResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = UpdateKyuubiTokenResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class UpdateLivyComputeRequestAutoStartConfiguration(TeaModel):
     def __init__(
         self,