alibabacloud-emr-serverless-spark20230808 1.10.3__py3-none-any.whl → 1.12.0__py3-none-any.whl

alibabacloud_emr_serverless_spark20230808/client.py

@@ -269,6 +269,306 @@ class Client(OpenApiClient):
         headers = {}
         return await self.cancel_job_run_with_options_async(workspace_id, job_run_id, request, headers, runtime)
 
+    def create_livy_compute_with_options(
+        self,
+        workspace_biz_id: str,
+        request: emr_serverless_spark_20230808_models.CreateLivyComputeRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.CreateLivyComputeResponse:
+        """
+        @summary 创建Livy compute
+        
+        @param request: CreateLivyComputeRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: CreateLivyComputeResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        body = {}
+        if not UtilClient.is_unset(request.auth_type):
+            body['authType'] = request.auth_type
+        if not UtilClient.is_unset(request.auto_start_configuration):
+            body['autoStartConfiguration'] = request.auto_start_configuration
+        if not UtilClient.is_unset(request.auto_stop_configuration):
+            body['autoStopConfiguration'] = request.auto_stop_configuration
+        if not UtilClient.is_unset(request.cpu_limit):
+            body['cpuLimit'] = request.cpu_limit
+        if not UtilClient.is_unset(request.display_release_version):
+            body['displayReleaseVersion'] = request.display_release_version
+        if not UtilClient.is_unset(request.enable_public):
+            body['enablePublic'] = request.enable_public
+        if not UtilClient.is_unset(request.environment_id):
+            body['environmentId'] = request.environment_id
+        if not UtilClient.is_unset(request.fusion):
+            body['fusion'] = request.fusion
+        if not UtilClient.is_unset(request.livy_server_conf):
+            body['livyServerConf'] = request.livy_server_conf
+        if not UtilClient.is_unset(request.livy_version):
+            body['livyVersion'] = request.livy_version
+        if not UtilClient.is_unset(request.memory_limit):
+            body['memoryLimit'] = request.memory_limit
+        if not UtilClient.is_unset(request.name):
+            body['name'] = request.name
+        if not UtilClient.is_unset(request.network_name):
+            body['networkName'] = request.network_name
+        if not UtilClient.is_unset(request.queue_name):
+            body['queueName'] = request.queue_name
+        if not UtilClient.is_unset(request.release_version):
+            body['releaseVersion'] = request.release_version
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='CreateLivyCompute',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute',
+            method='PUT',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.CreateLivyComputeResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def create_livy_compute_with_options_async(
+        self,
+        workspace_biz_id: str,
+        request: emr_serverless_spark_20230808_models.CreateLivyComputeRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.CreateLivyComputeResponse:
+        """
+        @summary 创建Livy compute
+        
+        @param request: CreateLivyComputeRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: CreateLivyComputeResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        body = {}
+        if not UtilClient.is_unset(request.auth_type):
+            body['authType'] = request.auth_type
+        if not UtilClient.is_unset(request.auto_start_configuration):
+            body['autoStartConfiguration'] = request.auto_start_configuration
+        if not UtilClient.is_unset(request.auto_stop_configuration):
+            body['autoStopConfiguration'] = request.auto_stop_configuration
+        if not UtilClient.is_unset(request.cpu_limit):
+            body['cpuLimit'] = request.cpu_limit
+        if not UtilClient.is_unset(request.display_release_version):
+            body['displayReleaseVersion'] = request.display_release_version
+        if not UtilClient.is_unset(request.enable_public):
+            body['enablePublic'] = request.enable_public
+        if not UtilClient.is_unset(request.environment_id):
+            body['environmentId'] = request.environment_id
+        if not UtilClient.is_unset(request.fusion):
+            body['fusion'] = request.fusion
+        if not UtilClient.is_unset(request.livy_server_conf):
+            body['livyServerConf'] = request.livy_server_conf
+        if not UtilClient.is_unset(request.livy_version):
+            body['livyVersion'] = request.livy_version
+        if not UtilClient.is_unset(request.memory_limit):
+            body['memoryLimit'] = request.memory_limit
+        if not UtilClient.is_unset(request.name):
+            body['name'] = request.name
+        if not UtilClient.is_unset(request.network_name):
+            body['networkName'] = request.network_name
+        if not UtilClient.is_unset(request.queue_name):
+            body['queueName'] = request.queue_name
+        if not UtilClient.is_unset(request.release_version):
+            body['releaseVersion'] = request.release_version
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='CreateLivyCompute',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute',
+            method='PUT',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.CreateLivyComputeResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def create_livy_compute(
+        self,
+        workspace_biz_id: str,
+        request: emr_serverless_spark_20230808_models.CreateLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.CreateLivyComputeResponse:
+        """
+        @summary 创建Livy compute
+        
+        @param request: CreateLivyComputeRequest
+        @return: CreateLivyComputeResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.create_livy_compute_with_options(workspace_biz_id, request, headers, runtime)
+
+    async def create_livy_compute_async(
+        self,
+        workspace_biz_id: str,
+        request: emr_serverless_spark_20230808_models.CreateLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.CreateLivyComputeResponse:
+        """
+        @summary 创建Livy compute
+        
+        @param request: CreateLivyComputeRequest
+        @return: CreateLivyComputeResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.create_livy_compute_with_options_async(workspace_biz_id, request, headers, runtime)
+
+    def create_livy_compute_token_with_options(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.CreateLivyComputeTokenRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.CreateLivyComputeTokenResponse:
+        """
+        @summary 创建Livy Compute的token
+        
+        @param request: CreateLivyComputeTokenRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: CreateLivyComputeTokenResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        body = {}
+        if not UtilClient.is_unset(request.auto_expire_configuration):
+            body['autoExpireConfiguration'] = request.auto_expire_configuration
+        if not UtilClient.is_unset(request.name):
+            body['name'] = request.name
+        if not UtilClient.is_unset(request.token):
+            body['token'] = request.token
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='CreateLivyComputeToken',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/token',
+            method='PUT',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.CreateLivyComputeTokenResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def create_livy_compute_token_with_options_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.CreateLivyComputeTokenRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.CreateLivyComputeTokenResponse:
+        """
+        @summary 创建Livy Compute的token
+        
+        @param request: CreateLivyComputeTokenRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: CreateLivyComputeTokenResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        body = {}
+        if not UtilClient.is_unset(request.auto_expire_configuration):
+            body['autoExpireConfiguration'] = request.auto_expire_configuration
+        if not UtilClient.is_unset(request.name):
+            body['name'] = request.name
+        if not UtilClient.is_unset(request.token):
+            body['token'] = request.token
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='CreateLivyComputeToken',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/token',
+            method='PUT',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.CreateLivyComputeTokenResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def create_livy_compute_token(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.CreateLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.CreateLivyComputeTokenResponse:
+        """
+        @summary 创建Livy Compute的token
+        
+        @param request: CreateLivyComputeTokenRequest
+        @return: CreateLivyComputeTokenResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.create_livy_compute_token_with_options(workspace_biz_id, livy_compute_id, request, headers, runtime)
+
+    async def create_livy_compute_token_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.CreateLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.CreateLivyComputeTokenResponse:
+        """
+        @summary 创建Livy Compute的token
+        
+        @param request: CreateLivyComputeTokenRequest
+        @return: CreateLivyComputeTokenResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.create_livy_compute_token_with_options_async(workspace_biz_id, livy_compute_id, request, headers, runtime)
+
     def create_process_definition_with_schedule_with_options(
         self,
         biz_id: str,
@@ -925,129 +1225,357 @@ class Client(OpenApiClient):
         headers = {}
         return await self.create_workspace_with_options_async(request, headers, runtime)
 
-    def edit_workspace_queue_with_options(
+    def delete_livy_compute_with_options(
         self,
-        request: emr_serverless_spark_20230808_models.EditWorkspaceQueueRequest,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.DeleteLivyComputeRequest,
         headers: Dict[str, str],
         runtime: util_models.RuntimeOptions,
-    ) -> emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse:
+    ) -> emr_serverless_spark_20230808_models.DeleteLivyComputeResponse:
         """
-        @summary Modifies the queue of a workspace.
+        @summary 删除livy compute
         
-        @param request: EditWorkspaceQueueRequest
+        @param request: DeleteLivyComputeRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: EditWorkspaceQueueResponse
+        @return: DeleteLivyComputeResponse
         """
         UtilClient.validate_model(request)
         query = {}
         if not UtilClient.is_unset(request.region_id):
             query['regionId'] = request.region_id
-        body = {}
-        if not UtilClient.is_unset(request.environments):
-            body['environments'] = request.environments
-        if not UtilClient.is_unset(request.resource_spec):
-            body['resourceSpec'] = request.resource_spec
-        if not UtilClient.is_unset(request.workspace_id):
-            body['workspaceId'] = request.workspace_id
-        if not UtilClient.is_unset(request.workspace_queue_name):
-            body['workspaceQueueName'] = request.workspace_queue_name
         req = open_api_models.OpenApiRequest(
             headers=headers,
-            query=OpenApiUtilClient.query(query),
-            body=OpenApiUtilClient.parse_to_map(body)
+            query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='EditWorkspaceQueue',
+            action='DeleteLivyCompute',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/v1/workspaces/queues/action/edit',
-            method='POST',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}',
+            method='DELETE',
             auth_type='AK',
             style='ROA',
             req_body_type='json',
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse(),
+            emr_serverless_spark_20230808_models.DeleteLivyComputeResponse(),
             self.call_api(params, req, runtime)
         )
 
-    async def edit_workspace_queue_with_options_async(
+    async def delete_livy_compute_with_options_async(
         self,
-        request: emr_serverless_spark_20230808_models.EditWorkspaceQueueRequest,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.DeleteLivyComputeRequest,
         headers: Dict[str, str],
         runtime: util_models.RuntimeOptions,
-    ) -> emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse:
+    ) -> emr_serverless_spark_20230808_models.DeleteLivyComputeResponse:
         """
-        @summary Modifies the queue of a workspace.
+        @summary 删除livy compute
         
-        @param request: EditWorkspaceQueueRequest
+        @param request: DeleteLivyComputeRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: EditWorkspaceQueueResponse
+        @return: DeleteLivyComputeResponse
         """
         UtilClient.validate_model(request)
         query = {}
         if not UtilClient.is_unset(request.region_id):
             query['regionId'] = request.region_id
-        body = {}
-        if not UtilClient.is_unset(request.environments):
-            body['environments'] = request.environments
-        if not UtilClient.is_unset(request.resource_spec):
-            body['resourceSpec'] = request.resource_spec
-        if not UtilClient.is_unset(request.workspace_id):
-            body['workspaceId'] = request.workspace_id
-        if not UtilClient.is_unset(request.workspace_queue_name):
-            body['workspaceQueueName'] = request.workspace_queue_name
         req = open_api_models.OpenApiRequest(
             headers=headers,
-            query=OpenApiUtilClient.query(query),
-            body=OpenApiUtilClient.parse_to_map(body)
+            query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='EditWorkspaceQueue',
+            action='DeleteLivyCompute',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/v1/workspaces/queues/action/edit',
-            method='POST',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}',
+            method='DELETE',
             auth_type='AK',
             style='ROA',
             req_body_type='json',
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse(),
+            emr_serverless_spark_20230808_models.DeleteLivyComputeResponse(),
             await self.call_api_async(params, req, runtime)
         )
 
-    def edit_workspace_queue(
+    def delete_livy_compute(
         self,
-        request: emr_serverless_spark_20230808_models.EditWorkspaceQueueRequest,
-    ) -> emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.DeleteLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.DeleteLivyComputeResponse:
         """
-        @summary Modifies the queue of a workspace.
+        @summary 删除livy compute
         
-        @param request: EditWorkspaceQueueRequest
-        @return: EditWorkspaceQueueResponse
+        @param request: DeleteLivyComputeRequest
+        @return: DeleteLivyComputeResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return self.edit_workspace_queue_with_options(request, headers, runtime)
+        return self.delete_livy_compute_with_options(workspace_biz_id, livy_compute_id, request, headers, runtime)
 
-    async def edit_workspace_queue_async(
+    async def delete_livy_compute_async(
         self,
-        request: emr_serverless_spark_20230808_models.EditWorkspaceQueueRequest,
-    ) -> emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.DeleteLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.DeleteLivyComputeResponse:
         """
-        @summary Modifies the queue of a workspace.
+        @summary 删除livy compute
         
-        @param request: EditWorkspaceQueueRequest
-        @return: EditWorkspaceQueueResponse
+        @param request: DeleteLivyComputeRequest
+        @return: DeleteLivyComputeResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return await self.edit_workspace_queue_with_options_async(request, headers, runtime)
+        return await self.delete_livy_compute_with_options_async(workspace_biz_id, livy_compute_id, request, headers, runtime)
+
+    def delete_livy_compute_token_with_options(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.DeleteLivyComputeTokenRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.DeleteLivyComputeTokenResponse:
+        """
+        @summary 删除Livy Compute的token
+        
+        @param request: DeleteLivyComputeTokenRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: DeleteLivyComputeTokenResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='DeleteLivyComputeToken',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/token/{OpenApiUtilClient.get_encode_param(token_id)}',
+            method='DELETE',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.DeleteLivyComputeTokenResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def delete_livy_compute_token_with_options_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.DeleteLivyComputeTokenRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.DeleteLivyComputeTokenResponse:
+        """
+        @summary 删除Livy Compute的token
+        
+        @param request: DeleteLivyComputeTokenRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: DeleteLivyComputeTokenResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='DeleteLivyComputeToken',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/token/{OpenApiUtilClient.get_encode_param(token_id)}',
+            method='DELETE',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.DeleteLivyComputeTokenResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def delete_livy_compute_token(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.DeleteLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.DeleteLivyComputeTokenResponse:
+        """
+        @summary 删除Livy Compute的token
+        
+        @param request: DeleteLivyComputeTokenRequest
+        @return: DeleteLivyComputeTokenResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.delete_livy_compute_token_with_options(workspace_biz_id, livy_compute_id, token_id, request, headers, runtime)
+
+    async def delete_livy_compute_token_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.DeleteLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.DeleteLivyComputeTokenResponse:
+        """
+        @summary 删除Livy Compute的token
+        
+        @param request: DeleteLivyComputeTokenRequest
+        @return: DeleteLivyComputeTokenResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.delete_livy_compute_token_with_options_async(workspace_biz_id, livy_compute_id, token_id, request, headers, runtime)
+
+    def edit_workspace_queue_with_options(
+        self,
+        request: emr_serverless_spark_20230808_models.EditWorkspaceQueueRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse:
+        """
+        @summary Modifies the queue of a workspace.
+        
+        @param request: EditWorkspaceQueueRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: EditWorkspaceQueueResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        body = {}
+        if not UtilClient.is_unset(request.environments):
+            body['environments'] = request.environments
+        if not UtilClient.is_unset(request.resource_spec):
+            body['resourceSpec'] = request.resource_spec
+        if not UtilClient.is_unset(request.workspace_id):
+            body['workspaceId'] = request.workspace_id
+        if not UtilClient.is_unset(request.workspace_queue_name):
+            body['workspaceQueueName'] = request.workspace_queue_name
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='EditWorkspaceQueue',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/workspaces/queues/action/edit',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def edit_workspace_queue_with_options_async(
+        self,
+        request: emr_serverless_spark_20230808_models.EditWorkspaceQueueRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse:
+        """
+        @summary Modifies the queue of a workspace.
+        
+        @param request: EditWorkspaceQueueRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: EditWorkspaceQueueResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        body = {}
+        if not UtilClient.is_unset(request.environments):
+            body['environments'] = request.environments
+        if not UtilClient.is_unset(request.resource_spec):
+            body['resourceSpec'] = request.resource_spec
+        if not UtilClient.is_unset(request.workspace_id):
+            body['workspaceId'] = request.workspace_id
+        if not UtilClient.is_unset(request.workspace_queue_name):
+            body['workspaceQueueName'] = request.workspace_queue_name
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='EditWorkspaceQueue',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/workspaces/queues/action/edit',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def edit_workspace_queue(
+        self,
+        request: emr_serverless_spark_20230808_models.EditWorkspaceQueueRequest,
+    ) -> emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse:
+        """
+        @summary Modifies the queue of a workspace.
+        
+        @param request: EditWorkspaceQueueRequest
+        @return: EditWorkspaceQueueResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.edit_workspace_queue_with_options(request, headers, runtime)
+
+    async def edit_workspace_queue_async(
+        self,
+        request: emr_serverless_spark_20230808_models.EditWorkspaceQueueRequest,
+    ) -> emr_serverless_spark_20230808_models.EditWorkspaceQueueResponse:
+        """
+        @summary Modifies the queue of a workspace.
+        
+        @param request: EditWorkspaceQueueRequest
+        @return: EditWorkspaceQueueResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.edit_workspace_queue_with_options_async(request, headers, runtime)
 
     def get_cu_hours_with_options(
         self,
@@ -1397,21 +1925,21 @@ class Client(OpenApiClient):
         headers = {}
         return await self.get_job_run_with_options_async(workspace_id, job_run_id, request, headers, runtime)
 
-    def get_session_cluster_with_options(
+    def get_livy_compute_with_options(
         self,
-        workspace_id: str,
-        session_cluster_id: str,
-        request: emr_serverless_spark_20230808_models.GetSessionClusterRequest,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.GetLivyComputeRequest,
         headers: Dict[str, str],
         runtime: util_models.RuntimeOptions,
-    ) -> emr_serverless_spark_20230808_models.GetSessionClusterResponse:
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeResponse:
         """
-        @summary Queries the information about a session.
+        @summary 获取livy compute
         
-        @param request: GetSessionClusterRequest
+        @param request: GetLivyComputeRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: GetSessionClusterResponse
+        @return: GetLivyComputeResponse
         """
         UtilClient.validate_model(request)
         query = {}
@@ -1422,10 +1950,10 @@ class Client(OpenApiClient):
             query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='GetSessionCluster',
+            action='GetLivyCompute',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/sessionClusters/{OpenApiUtilClient.get_encode_param(session_cluster_id)}',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}',
             method='GET',
             auth_type='AK',
             style='ROA',
@@ -1433,25 +1961,25 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.GetSessionClusterResponse(),
+            emr_serverless_spark_20230808_models.GetLivyComputeResponse(),
             self.call_api(params, req, runtime)
         )
 
-    async def get_session_cluster_with_options_async(
+    async def get_livy_compute_with_options_async(
         self,
-        workspace_id: str,
-        session_cluster_id: str,
-        request: emr_serverless_spark_20230808_models.GetSessionClusterRequest,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.GetLivyComputeRequest,
         headers: Dict[str, str],
         runtime: util_models.RuntimeOptions,
-    ) -> emr_serverless_spark_20230808_models.GetSessionClusterResponse:
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeResponse:
         """
-        @summary Queries the information about a session.
+        @summary 获取livy compute
         
-        @param request: GetSessionClusterRequest
+        @param request: GetLivyComputeRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: GetSessionClusterResponse
+        @return: GetLivyComputeResponse
         """
         UtilClient.validate_model(request)
         query = {}
@@ -1462,10 +1990,10 @@ class Client(OpenApiClient):
             query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='GetSessionCluster',
+            action='GetLivyCompute',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/sessionClusters/{OpenApiUtilClient.get_encode_param(session_cluster_id)}',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}',
             method='GET',
             auth_type='AK',
             style='ROA',
@@ -1473,57 +2001,58 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.GetSessionClusterResponse(),
+            emr_serverless_spark_20230808_models.GetLivyComputeResponse(),
             await self.call_api_async(params, req, runtime)
         )
 
-    def get_session_cluster(
+    def get_livy_compute(
         self,
-        workspace_id: str,
-        session_cluster_id: str,
-        request: emr_serverless_spark_20230808_models.GetSessionClusterRequest,
-    ) -> emr_serverless_spark_20230808_models.GetSessionClusterResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.GetLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeResponse:
         """
-        @summary Queries the information about a session.
+        @summary 获取livy compute
         
-        @param request: GetSessionClusterRequest
-        @return: GetSessionClusterResponse
+        @param request: GetLivyComputeRequest
+        @return: GetLivyComputeResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return self.get_session_cluster_with_options(workspace_id, session_cluster_id, request, headers, runtime)
+        return self.get_livy_compute_with_options(workspace_biz_id, livy_compute_id, request, headers, runtime)
 
-    async def get_session_cluster_async(
+    async def get_livy_compute_async(
         self,
-        workspace_id: str,
-        session_cluster_id: str,
-        request: emr_serverless_spark_20230808_models.GetSessionClusterRequest,
-    ) -> emr_serverless_spark_20230808_models.GetSessionClusterResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.GetLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeResponse:
         """
-        @summary Queries the information about a session.
+        @summary 获取livy compute
         
-        @param request: GetSessionClusterRequest
-        @return: GetSessionClusterResponse
+        @param request: GetLivyComputeRequest
+        @return: GetLivyComputeResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return await self.get_session_cluster_with_options_async(workspace_id, session_cluster_id, request, headers, runtime)
+        return await self.get_livy_compute_with_options_async(workspace_biz_id, livy_compute_id, request, headers, runtime)
 
-    def get_sql_statement_with_options(
+    def get_livy_compute_token_with_options(
         self,
-        workspace_id: str,
-        statement_id: str,
-        request: emr_serverless_spark_20230808_models.GetSqlStatementRequest,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.GetLivyComputeTokenRequest,
         headers: Dict[str, str],
         runtime: util_models.RuntimeOptions,
-    ) -> emr_serverless_spark_20230808_models.GetSqlStatementResponse:
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeTokenResponse:
         """
-        @summary Queries the status of an SQL query task.
+        @summary 获取livy compute token
         
-        @param request: GetSqlStatementRequest
+        @param request: GetLivyComputeTokenRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: GetSqlStatementResponse
+        @return: GetLivyComputeTokenResponse
         """
         UtilClient.validate_model(request)
         query = {}
@@ -1534,10 +2063,10 @@ class Client(OpenApiClient):
             query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='GetSqlStatement',
+            action='GetLivyComputeToken',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_id)}/statement/{OpenApiUtilClient.get_encode_param(statement_id)}',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/token/{OpenApiUtilClient.get_encode_param(token_id)}',
             method='GET',
             auth_type='AK',
             style='ROA',
@@ -1545,7 +2074,234 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.GetSqlStatementResponse(),
+            emr_serverless_spark_20230808_models.GetLivyComputeTokenResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def get_livy_compute_token_with_options_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.GetLivyComputeTokenRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeTokenResponse:
+        """
+        @summary 获取livy compute token
+        
+        @param request: GetLivyComputeTokenRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetLivyComputeTokenResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='GetLivyComputeToken',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/token/{OpenApiUtilClient.get_encode_param(token_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.GetLivyComputeTokenResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def get_livy_compute_token(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.GetLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeTokenResponse:
+        """
+        @summary 获取livy compute token
+        
+        @param request: GetLivyComputeTokenRequest
+        @return: GetLivyComputeTokenResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.get_livy_compute_token_with_options(workspace_biz_id, livy_compute_id, token_id, request, headers, runtime)
+
+    async def get_livy_compute_token_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.GetLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeTokenResponse:
+        """
+        @summary 获取livy compute token
+        
+        @param request: GetLivyComputeTokenRequest
+        @return: GetLivyComputeTokenResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.get_livy_compute_token_with_options_async(workspace_biz_id, livy_compute_id, token_id, request, headers, runtime)
+
+    def get_session_cluster_with_options(
+        self,
+        workspace_id: str,
+        session_cluster_id: str,
+        request: emr_serverless_spark_20230808_models.GetSessionClusterRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.GetSessionClusterResponse:
+        """
+        @summary Queries the information about a session.
+        
+        @param request: GetSessionClusterRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetSessionClusterResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='GetSessionCluster',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/sessionClusters/{OpenApiUtilClient.get_encode_param(session_cluster_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.GetSessionClusterResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def get_session_cluster_with_options_async(
+        self,
+        workspace_id: str,
+        session_cluster_id: str,
+        request: emr_serverless_spark_20230808_models.GetSessionClusterRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.GetSessionClusterResponse:
+        """
+        @summary Queries the information about a session.
+        
+        @param request: GetSessionClusterRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetSessionClusterResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='GetSessionCluster',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/sessionClusters/{OpenApiUtilClient.get_encode_param(session_cluster_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.GetSessionClusterResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def get_session_cluster(
+        self,
+        workspace_id: str,
+        session_cluster_id: str,
+        request: emr_serverless_spark_20230808_models.GetSessionClusterRequest,
+    ) -> emr_serverless_spark_20230808_models.GetSessionClusterResponse:
+        """
+        @summary Queries the information about a session.
+        
+        @param request: GetSessionClusterRequest
+        @return: GetSessionClusterResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.get_session_cluster_with_options(workspace_id, session_cluster_id, request, headers, runtime)
+
+    async def get_session_cluster_async(
+        self,
+        workspace_id: str,
+        session_cluster_id: str,
+        request: emr_serverless_spark_20230808_models.GetSessionClusterRequest,
+    ) -> emr_serverless_spark_20230808_models.GetSessionClusterResponse:
+        """
+        @summary Queries the information about a session.
+        
+        @param request: GetSessionClusterRequest
+        @return: GetSessionClusterResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.get_session_cluster_with_options_async(workspace_id, session_cluster_id, request, headers, runtime)
+
+    def get_sql_statement_with_options(
+        self,
+        workspace_id: str,
+        statement_id: str,
+        request: emr_serverless_spark_20230808_models.GetSqlStatementRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.GetSqlStatementResponse:
+        """
+        @summary Queries the status of an SQL query task.
+        
+        @param request: GetSqlStatementRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetSqlStatementResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='GetSqlStatement',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_id)}/statement/{OpenApiUtilClient.get_encode_param(statement_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.GetSqlStatementResponse(),
             self.call_api(params, req, runtime)
         )
 
@@ -1884,6 +2640,8 @@ class Client(OpenApiClient):
             query['creator'] = request.creator
         if not UtilClient.is_unset(request.end_time_shrink):
             query['endTime'] = request.end_time_shrink
+        if not UtilClient.is_unset(request.is_workflow):
+            query['isWorkflow'] = request.is_workflow
         if not UtilClient.is_unset(request.job_run_deployment_id):
             query['jobRunDeploymentId'] = request.job_run_deployment_id
         if not UtilClient.is_unset(request.job_run_id):
@@ -1957,6 +2715,8 @@ class Client(OpenApiClient):
             query['creator'] = request.creator
         if not UtilClient.is_unset(request.end_time_shrink):
             query['endTime'] = request.end_time_shrink
+        if not UtilClient.is_unset(request.is_workflow):
+            query['isWorkflow'] = request.is_workflow
         if not UtilClient.is_unset(request.job_run_deployment_id):
             query['jobRunDeploymentId'] = request.job_run_deployment_id
         if not UtilClient.is_unset(request.job_run_id):
@@ -2029,47 +2789,505 @@ class Client(OpenApiClient):
         headers = {}
         return await self.list_job_runs_with_options_async(workspace_id, request, headers, runtime)
 
-    def list_kyuubi_spark_applications_with_options(
+    def list_kyuubi_services_with_options(
         self,
         workspace_id: str,
-        kyuubi_service_id: str,
-        tmp_req: emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsRequest,
         headers: Dict[str, str],
         runtime: util_models.RuntimeOptions,
-    ) -> emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse:
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiServicesResponse:
         """
-        @summary Queries the applications that are submitted by using a Kyuubi gateway.
+        @summary ListKyuubiServices
         
-        @param tmp_req: ListKyuubiSparkApplicationsRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: ListKyuubiSparkApplicationsResponse
+        @return: ListKyuubiServicesResponse
         """
-        UtilClient.validate_model(tmp_req)
-        request = emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsShrinkRequest()
-        OpenApiUtilClient.convert(tmp_req, request)
-        if not UtilClient.is_unset(tmp_req.start_time):
-            request.start_time_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.start_time, 'startTime', 'json')
-        query = {}
-        if not UtilClient.is_unset(request.application_id):
-            query['applicationId'] = request.application_id
-        if not UtilClient.is_unset(request.application_name):
-            query['applicationName'] = request.application_name
-        if not UtilClient.is_unset(request.max_results):
-            query['maxResults'] = request.max_results
-        if not UtilClient.is_unset(request.next_token):
-            query['nextToken'] = request.next_token
-        if not UtilClient.is_unset(request.start_time_shrink):
-            query['startTime'] = request.start_time_shrink
         req = open_api_models.OpenApiRequest(
-            headers=headers,
-            query=OpenApiUtilClient.query(query)
+            headers=headers
         )
         params = open_api_models.Params(
-            action='ListKyuubiSparkApplications',
+            action='ListKyuubiServices',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/kyuubi/{OpenApiUtilClient.get_encode_param(workspace_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.ListKyuubiServicesResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def list_kyuubi_services_with_options_async(
+        self,
+        workspace_id: str,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiServicesResponse:
+        """
+        @summary ListKyuubiServices
+        
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListKyuubiServicesResponse
+        """
+        req = open_api_models.OpenApiRequest(
+            headers=headers
+        )
+        params = open_api_models.Params(
+            action='ListKyuubiServices',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/kyuubi/{OpenApiUtilClient.get_encode_param(workspace_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.ListKyuubiServicesResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def list_kyuubi_services(
+        self,
+        workspace_id: str,
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiServicesResponse:
+        """
+        @summary ListKyuubiServices
+        
+        @return: ListKyuubiServicesResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.list_kyuubi_services_with_options(workspace_id, headers, runtime)
+
+    async def list_kyuubi_services_async(
+        self,
+        workspace_id: str,
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiServicesResponse:
+        """
+        @summary ListKyuubiServices
+        
+        @return: ListKyuubiServicesResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.list_kyuubi_services_with_options_async(workspace_id, headers, runtime)
+
+    def list_kyuubi_spark_applications_with_options(
+        self,
+        workspace_id: str,
+        kyuubi_service_id: str,
+        tmp_req: emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse:
+        """
+        @summary Queries the applications that are submitted by using a Kyuubi gateway.
+        
+        @param tmp_req: ListKyuubiSparkApplicationsRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListKyuubiSparkApplicationsResponse
+        """
+        UtilClient.validate_model(tmp_req)
+        request = emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsShrinkRequest()
+        OpenApiUtilClient.convert(tmp_req, request)
+        if not UtilClient.is_unset(tmp_req.order_by):
+            request.order_by_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.order_by, 'orderBy', 'json')
+        if not UtilClient.is_unset(tmp_req.start_time):
+            request.start_time_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.start_time, 'startTime', 'json')
+        query = {}
+        if not UtilClient.is_unset(request.application_id):
+            query['applicationId'] = request.application_id
+        if not UtilClient.is_unset(request.application_name):
+            query['applicationName'] = request.application_name
+        if not UtilClient.is_unset(request.max_results):
+            query['maxResults'] = request.max_results
+        if not UtilClient.is_unset(request.min_duration):
+            query['minDuration'] = request.min_duration
+        if not UtilClient.is_unset(request.next_token):
+            query['nextToken'] = request.next_token
+        if not UtilClient.is_unset(request.order_by_shrink):
+            query['orderBy'] = request.order_by_shrink
+        if not UtilClient.is_unset(request.resource_queue_id):
+            query['resourceQueueId'] = request.resource_queue_id
+        if not UtilClient.is_unset(request.sort):
+            query['sort'] = request.sort
+        if not UtilClient.is_unset(request.start_time_shrink):
+            query['startTime'] = request.start_time_shrink
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListKyuubiSparkApplications',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/kyuubi/{OpenApiUtilClient.get_encode_param(workspace_id)}/{OpenApiUtilClient.get_encode_param(kyuubi_service_id)}/applications',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def list_kyuubi_spark_applications_with_options_async(
+        self,
+        workspace_id: str,
+        kyuubi_service_id: str,
+        tmp_req: emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse:
+        """
+        @summary Queries the applications that are submitted by using a Kyuubi gateway.
+        
+        @param tmp_req: ListKyuubiSparkApplicationsRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListKyuubiSparkApplicationsResponse
+        """
+        UtilClient.validate_model(tmp_req)
+        request = emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsShrinkRequest()
+        OpenApiUtilClient.convert(tmp_req, request)
+        if not UtilClient.is_unset(tmp_req.order_by):
+            request.order_by_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.order_by, 'orderBy', 'json')
+        if not UtilClient.is_unset(tmp_req.start_time):
+            request.start_time_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.start_time, 'startTime', 'json')
+        query = {}
+        if not UtilClient.is_unset(request.application_id):
+            query['applicationId'] = request.application_id
+        if not UtilClient.is_unset(request.application_name):
+            query['applicationName'] = request.application_name
+        if not UtilClient.is_unset(request.max_results):
+            query['maxResults'] = request.max_results
+        if not UtilClient.is_unset(request.min_duration):
+            query['minDuration'] = request.min_duration
+        if not UtilClient.is_unset(request.next_token):
+            query['nextToken'] = request.next_token
+        if not UtilClient.is_unset(request.order_by_shrink):
+            query['orderBy'] = request.order_by_shrink
+        if not UtilClient.is_unset(request.resource_queue_id):
+            query['resourceQueueId'] = request.resource_queue_id
+        if not UtilClient.is_unset(request.sort):
+            query['sort'] = request.sort
+        if not UtilClient.is_unset(request.start_time_shrink):
+            query['startTime'] = request.start_time_shrink
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListKyuubiSparkApplications',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/kyuubi/{OpenApiUtilClient.get_encode_param(workspace_id)}/{OpenApiUtilClient.get_encode_param(kyuubi_service_id)}/applications',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def list_kyuubi_spark_applications(
+        self,
+        workspace_id: str,
+        kyuubi_service_id: str,
+        request: emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsRequest,
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse:
+        """
+        @summary Queries the applications that are submitted by using a Kyuubi gateway.
+        
+        @param request: ListKyuubiSparkApplicationsRequest
+        @return: ListKyuubiSparkApplicationsResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.list_kyuubi_spark_applications_with_options(workspace_id, kyuubi_service_id, request, headers, runtime)
+
+    async def list_kyuubi_spark_applications_async(
+        self,
+        workspace_id: str,
+        kyuubi_service_id: str,
+        request: emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsRequest,
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse:
+        """
+        @summary Queries the applications that are submitted by using a Kyuubi gateway.
+        
+        @param request: ListKyuubiSparkApplicationsRequest
+        @return: ListKyuubiSparkApplicationsResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.list_kyuubi_spark_applications_with_options_async(workspace_id, kyuubi_service_id, request, headers, runtime)
+
+    def list_kyuubi_token_with_options(
+        self,
+        workspace_id: str,
+        kyuubi_service_id: str,
+        request: emr_serverless_spark_20230808_models.ListKyuubiTokenRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiTokenResponse:
+        """
+        @summary 列出compute的token
+        
+        @param request: ListKyuubiTokenRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListKyuubiTokenResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListKyuubiToken',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/kyuubiService/{OpenApiUtilClient.get_encode_param(kyuubi_service_id)}/token',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.ListKyuubiTokenResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def list_kyuubi_token_with_options_async(
+        self,
+        workspace_id: str,
+        kyuubi_service_id: str,
+        request: emr_serverless_spark_20230808_models.ListKyuubiTokenRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiTokenResponse:
+        """
+        @summary 列出compute的token
+        
+        @param request: ListKyuubiTokenRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListKyuubiTokenResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListKyuubiToken',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/kyuubiService/{OpenApiUtilClient.get_encode_param(kyuubi_service_id)}/token',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.ListKyuubiTokenResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def list_kyuubi_token(
+        self,
+        workspace_id: str,
+        kyuubi_service_id: str,
+        request: emr_serverless_spark_20230808_models.ListKyuubiTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiTokenResponse:
+        """
+        @summary 列出compute的token
+        
+        @param request: ListKyuubiTokenRequest
+        @return: ListKyuubiTokenResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.list_kyuubi_token_with_options(workspace_id, kyuubi_service_id, request, headers, runtime)
+
+    async def list_kyuubi_token_async(
+        self,
+        workspace_id: str,
+        kyuubi_service_id: str,
+        request: emr_serverless_spark_20230808_models.ListKyuubiTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.ListKyuubiTokenResponse:
+        """
+        @summary 列出compute的token
+        
+        @param request: ListKyuubiTokenRequest
+        @return: ListKyuubiTokenResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.list_kyuubi_token_with_options_async(workspace_id, kyuubi_service_id, request, headers, runtime)
+
+    def list_livy_compute_with_options(
+        self,
+        workspace_biz_id: str,
+        request: emr_serverless_spark_20230808_models.ListLivyComputeRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeResponse:
+        """
+        @summary 列出livy compute
+        
+        @param request: ListLivyComputeRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListLivyComputeResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.environment_id):
+            query['environmentId'] = request.environment_id
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListLivyCompute',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.ListLivyComputeResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def list_livy_compute_with_options_async(
+        self,
+        workspace_biz_id: str,
+        request: emr_serverless_spark_20230808_models.ListLivyComputeRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeResponse:
+        """
+        @summary 列出livy compute
+        
+        @param request: ListLivyComputeRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListLivyComputeResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.environment_id):
+            query['environmentId'] = request.environment_id
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListLivyCompute',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.ListLivyComputeResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def list_livy_compute(
+        self,
+        workspace_biz_id: str,
+        request: emr_serverless_spark_20230808_models.ListLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeResponse:
+        """
+        @summary 列出livy compute
+        
+        @param request: ListLivyComputeRequest
+        @return: ListLivyComputeResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.list_livy_compute_with_options(workspace_biz_id, request, headers, runtime)
+
+    async def list_livy_compute_async(
+        self,
+        workspace_biz_id: str,
+        request: emr_serverless_spark_20230808_models.ListLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeResponse:
+        """
+        @summary 列出livy compute
+        
+        @param request: ListLivyComputeRequest
+        @return: ListLivyComputeResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.list_livy_compute_with_options_async(workspace_biz_id, request, headers, runtime)
+
+    def list_livy_compute_token_with_options(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.ListLivyComputeTokenRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse:
+        """
+        @summary 列出livy compute token
+        
+        @param request: ListLivyComputeTokenRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListLivyComputeTokenResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListLivyComputeToken',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/v1/kyuubi/{OpenApiUtilClient.get_encode_param(workspace_id)}/{OpenApiUtilClient.get_encode_param(kyuubi_service_id)}/applications',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/token',
             method='GET',
             auth_type='AK',
             style='ROA',
@@ -2077,51 +3295,39 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse(),
+            emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse(),
             self.call_api(params, req, runtime)
         )
 
-    async def list_kyuubi_spark_applications_with_options_async(
+    async def list_livy_compute_token_with_options_async(
         self,
-        workspace_id: str,
-        kyuubi_service_id: str,
-        tmp_req: emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsRequest,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.ListLivyComputeTokenRequest,
         headers: Dict[str, str],
         runtime: util_models.RuntimeOptions,
-    ) -> emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse:
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse:
         """
-        @summary Queries the applications that are submitted by using a Kyuubi gateway.
+        @summary 列出livy compute token
         
-        @param tmp_req: ListKyuubiSparkApplicationsRequest
+        @param request: ListLivyComputeTokenRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: ListKyuubiSparkApplicationsResponse
+        @return: ListLivyComputeTokenResponse
         """
-        UtilClient.validate_model(tmp_req)
-        request = emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsShrinkRequest()
-        OpenApiUtilClient.convert(tmp_req, request)
-        if not UtilClient.is_unset(tmp_req.start_time):
-            request.start_time_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.start_time, 'startTime', 'json')
+        UtilClient.validate_model(request)
         query = {}
-        if not UtilClient.is_unset(request.application_id):
-            query['applicationId'] = request.application_id
-        if not UtilClient.is_unset(request.application_name):
-            query['applicationName'] = request.application_name
-        if not UtilClient.is_unset(request.max_results):
-            query['maxResults'] = request.max_results
-        if not UtilClient.is_unset(request.next_token):
-            query['nextToken'] = request.next_token
-        if not UtilClient.is_unset(request.start_time_shrink):
-            query['startTime'] = request.start_time_shrink
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
         req = open_api_models.OpenApiRequest(
             headers=headers,
             query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='ListKyuubiSparkApplications',
+            action='ListLivyComputeToken',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/v1/kyuubi/{OpenApiUtilClient.get_encode_param(workspace_id)}/{OpenApiUtilClient.get_encode_param(kyuubi_service_id)}/applications',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/token',
             method='GET',
             auth_type='AK',
             style='ROA',
@@ -2129,41 +3335,41 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse(),
+            emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse(),
             await self.call_api_async(params, req, runtime)
         )
 
-    def list_kyuubi_spark_applications(
+    def list_livy_compute_token(
         self,
-        workspace_id: str,
-        kyuubi_service_id: str,
-        request: emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsRequest,
-    ) -> emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.ListLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse:
         """
-        @summary Queries the applications that are submitted by using a Kyuubi gateway.
+        @summary 列出livy compute token
         
-        @param request: ListKyuubiSparkApplicationsRequest
-        @return: ListKyuubiSparkApplicationsResponse
+        @param request: ListLivyComputeTokenRequest
+        @return: ListLivyComputeTokenResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return self.list_kyuubi_spark_applications_with_options(workspace_id, kyuubi_service_id, request, headers, runtime)
+        return self.list_livy_compute_token_with_options(workspace_biz_id, livy_compute_id, request, headers, runtime)
 
-    async def list_kyuubi_spark_applications_async(
+    async def list_livy_compute_token_async(
         self,
-        workspace_id: str,
-        kyuubi_service_id: str,
-        request: emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsRequest,
-    ) -> emr_serverless_spark_20230808_models.ListKyuubiSparkApplicationsResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.ListLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse:
         """
-        @summary Queries the applications that are submitted by using a Kyuubi gateway.
+        @summary 列出livy compute token
         
-        @param request: ListKyuubiSparkApplicationsRequest
-        @return: ListKyuubiSparkApplicationsResponse
+        @param request: ListLivyComputeTokenRequest
+        @return: ListLivyComputeTokenResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return await self.list_kyuubi_spark_applications_with_options_async(workspace_id, kyuubi_service_id, request, headers, runtime)
+        return await self.list_livy_compute_token_with_options_async(workspace_biz_id, livy_compute_id, request, headers, runtime)
 
     def list_log_contents_with_options(
         self,
@@ -2781,6 +3987,138 @@ class Client(OpenApiClient):
         headers = {}
         return await self.list_workspaces_with_options_async(request, headers, runtime)
 
+    def refresh_livy_compute_token_with_options(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.RefreshLivyComputeTokenRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.RefreshLivyComputeTokenResponse:
+        """
+        @summary 更新Livy Compute的token
+        
+        @param request: RefreshLivyComputeTokenRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: RefreshLivyComputeTokenResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        body = {}
+        if not UtilClient.is_unset(request.auto_expire_configuration):
+            body['autoExpireConfiguration'] = request.auto_expire_configuration
+        if not UtilClient.is_unset(request.name):
+            body['name'] = request.name
+        if not UtilClient.is_unset(request.token):
+            body['token'] = request.token
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='RefreshLivyComputeToken',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/token/{OpenApiUtilClient.get_encode_param(token_id)}',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.RefreshLivyComputeTokenResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def refresh_livy_compute_token_with_options_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.RefreshLivyComputeTokenRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.RefreshLivyComputeTokenResponse:
+        """
+        @summary 更新Livy Compute的token
+        
+        @param request: RefreshLivyComputeTokenRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: RefreshLivyComputeTokenResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        body = {}
+        if not UtilClient.is_unset(request.auto_expire_configuration):
+            body['autoExpireConfiguration'] = request.auto_expire_configuration
+        if not UtilClient.is_unset(request.name):
+            body['name'] = request.name
+        if not UtilClient.is_unset(request.token):
+            body['token'] = request.token
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='RefreshLivyComputeToken',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/token/{OpenApiUtilClient.get_encode_param(token_id)}',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.RefreshLivyComputeTokenResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def refresh_livy_compute_token(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.RefreshLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.RefreshLivyComputeTokenResponse:
+        """
+        @summary 更新Livy Compute的token
+        
+        @param request: RefreshLivyComputeTokenRequest
+        @return: RefreshLivyComputeTokenResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.refresh_livy_compute_token_with_options(workspace_biz_id, livy_compute_id, token_id, request, headers, runtime)
+
+    async def refresh_livy_compute_token_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        token_id: str,
+        request: emr_serverless_spark_20230808_models.RefreshLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.RefreshLivyComputeTokenResponse:
+        """
+        @summary 更新Livy Compute的token
+        
+        @param request: RefreshLivyComputeTokenRequest
+        @return: RefreshLivyComputeTokenResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.refresh_livy_compute_token_with_options_async(workspace_biz_id, livy_compute_id, token_id, request, headers, runtime)
+
     def start_job_run_with_options(
         self,
         workspace_id: str,
@@ -2827,14 +4165,149 @@ class Client(OpenApiClient):
             body['tags'] = request.tags
         req = open_api_models.OpenApiRequest(
             headers=headers,
-            query=OpenApiUtilClient.query(query),
-            body=OpenApiUtilClient.parse_to_map(body)
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='StartJobRun',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/jobRuns',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.StartJobRunResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def start_job_run_with_options_async(
+        self,
+        workspace_id: str,
+        request: emr_serverless_spark_20230808_models.StartJobRunRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.StartJobRunResponse:
+        """
+        @summary Starts a Spark job.
+        
+        @param request: StartJobRunRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: StartJobRunResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        body = {}
+        if not UtilClient.is_unset(request.client_token):
+            body['clientToken'] = request.client_token
+        if not UtilClient.is_unset(request.code_type):
+            body['codeType'] = request.code_type
+        if not UtilClient.is_unset(request.configuration_overrides):
+            body['configurationOverrides'] = request.configuration_overrides
+        if not UtilClient.is_unset(request.display_release_version):
+            body['displayReleaseVersion'] = request.display_release_version
+        if not UtilClient.is_unset(request.execution_timeout_seconds):
+            body['executionTimeoutSeconds'] = request.execution_timeout_seconds
+        if not UtilClient.is_unset(request.fusion):
+            body['fusion'] = request.fusion
+        if not UtilClient.is_unset(request.job_driver):
+            body['jobDriver'] = request.job_driver
+        if not UtilClient.is_unset(request.job_id):
+            body['jobId'] = request.job_id
+        if not UtilClient.is_unset(request.name):
+            body['name'] = request.name
+        if not UtilClient.is_unset(request.release_version):
+            body['releaseVersion'] = request.release_version
+        if not UtilClient.is_unset(request.resource_queue_id):
+            body['resourceQueueId'] = request.resource_queue_id
+        if not UtilClient.is_unset(request.tags):
+            body['tags'] = request.tags
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='StartJobRun',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/jobRuns',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.StartJobRunResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def start_job_run(
+        self,
+        workspace_id: str,
+        request: emr_serverless_spark_20230808_models.StartJobRunRequest,
+    ) -> emr_serverless_spark_20230808_models.StartJobRunResponse:
+        """
+        @summary Starts a Spark job.
+        
+        @param request: StartJobRunRequest
+        @return: StartJobRunResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.start_job_run_with_options(workspace_id, request, headers, runtime)
+
+    async def start_job_run_async(
+        self,
+        workspace_id: str,
+        request: emr_serverless_spark_20230808_models.StartJobRunRequest,
+    ) -> emr_serverless_spark_20230808_models.StartJobRunResponse:
+        """
+        @summary Starts a Spark job.
+        
+        @param request: StartJobRunRequest
+        @return: StartJobRunResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.start_job_run_with_options_async(workspace_id, request, headers, runtime)
+
+    def start_livy_compute_with_options(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.StartLivyComputeRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.StartLivyComputeResponse:
+        """
+        @summary 启动livy compute
+        
+        @param request: StartLivyComputeRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: StartLivyComputeResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='StartJobRun',
+            action='StartLivyCompute',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/jobRuns',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/start',
             method='POST',
             auth_type='AK',
             style='ROA',
@@ -2842,64 +4315,39 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.StartJobRunResponse(),
+            emr_serverless_spark_20230808_models.StartLivyComputeResponse(),
             self.call_api(params, req, runtime)
         )
 
-    async def start_job_run_with_options_async(
+    async def start_livy_compute_with_options_async(
         self,
-        workspace_id: str,
-        request: emr_serverless_spark_20230808_models.StartJobRunRequest,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.StartLivyComputeRequest,
         headers: Dict[str, str],
         runtime: util_models.RuntimeOptions,
-    ) -> emr_serverless_spark_20230808_models.StartJobRunResponse:
+    ) -> emr_serverless_spark_20230808_models.StartLivyComputeResponse:
         """
-        @summary Starts a Spark job.
+        @summary 启动livy compute
         
-        @param request: StartJobRunRequest
+        @param request: StartLivyComputeRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: StartJobRunResponse
+        @return: StartLivyComputeResponse
         """
         UtilClient.validate_model(request)
         query = {}
         if not UtilClient.is_unset(request.region_id):
             query['regionId'] = request.region_id
-        body = {}
-        if not UtilClient.is_unset(request.client_token):
-            body['clientToken'] = request.client_token
-        if not UtilClient.is_unset(request.code_type):
-            body['codeType'] = request.code_type
-        if not UtilClient.is_unset(request.configuration_overrides):
-            body['configurationOverrides'] = request.configuration_overrides
-        if not UtilClient.is_unset(request.display_release_version):
-            body['displayReleaseVersion'] = request.display_release_version
-        if not UtilClient.is_unset(request.execution_timeout_seconds):
-            body['executionTimeoutSeconds'] = request.execution_timeout_seconds
-        if not UtilClient.is_unset(request.fusion):
-            body['fusion'] = request.fusion
-        if not UtilClient.is_unset(request.job_driver):
-            body['jobDriver'] = request.job_driver
-        if not UtilClient.is_unset(request.job_id):
-            body['jobId'] = request.job_id
-        if not UtilClient.is_unset(request.name):
-            body['name'] = request.name
-        if not UtilClient.is_unset(request.release_version):
-            body['releaseVersion'] = request.release_version
-        if not UtilClient.is_unset(request.resource_queue_id):
-            body['resourceQueueId'] = request.resource_queue_id
-        if not UtilClient.is_unset(request.tags):
-            body['tags'] = request.tags
         req = open_api_models.OpenApiRequest(
             headers=headers,
-            query=OpenApiUtilClient.query(query),
-            body=OpenApiUtilClient.parse_to_map(body)
+            query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='StartJobRun',
+            action='StartLivyCompute',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/jobRuns',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/start',
             method='POST',
             auth_type='AK',
             style='ROA',
@@ -2907,39 +4355,41 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.StartJobRunResponse(),
+            emr_serverless_spark_20230808_models.StartLivyComputeResponse(),
             await self.call_api_async(params, req, runtime)
         )
 
-    def start_job_run(
+    def start_livy_compute(
         self,
-        workspace_id: str,
-        request: emr_serverless_spark_20230808_models.StartJobRunRequest,
-    ) -> emr_serverless_spark_20230808_models.StartJobRunResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.StartLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.StartLivyComputeResponse:
         """
-        @summary Starts a Spark job.
+        @summary 启动livy compute
         
-        @param request: StartJobRunRequest
-        @return: StartJobRunResponse
+        @param request: StartLivyComputeRequest
+        @return: StartLivyComputeResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return self.start_job_run_with_options(workspace_id, request, headers, runtime)
+        return self.start_livy_compute_with_options(workspace_biz_id, livy_compute_id, request, headers, runtime)
 
-    async def start_job_run_async(
+    async def start_livy_compute_async(
         self,
-        workspace_id: str,
-        request: emr_serverless_spark_20230808_models.StartJobRunRequest,
-    ) -> emr_serverless_spark_20230808_models.StartJobRunResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.StartLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.StartLivyComputeResponse:
         """
-        @summary Starts a Spark job.
+        @summary 启动livy compute
         
-        @param request: StartJobRunRequest
-        @return: StartJobRunResponse
+        @param request: StartLivyComputeRequest
+        @return: StartLivyComputeResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return await self.start_job_run_with_options_async(workspace_id, request, headers, runtime)
+        return await self.start_livy_compute_with_options_async(workspace_biz_id, livy_compute_id, request, headers, runtime)
 
     def start_process_instance_with_options(
         self,
@@ -3209,6 +4659,118 @@ class Client(OpenApiClient):
         headers = {}
         return await self.start_session_cluster_with_options_async(workspace_id, request, headers, runtime)
 
+    def stop_livy_compute_with_options(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.StopLivyComputeRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.StopLivyComputeResponse:
+        """
+        @summary 停止livy compute
+        
+        @param request: StopLivyComputeRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: StopLivyComputeResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='StopLivyCompute',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/stop',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.StopLivyComputeResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def stop_livy_compute_with_options_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.StopLivyComputeRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.StopLivyComputeResponse:
+        """
+        @summary 停止livy compute
+        
+        @param request: StopLivyComputeRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: StopLivyComputeResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='StopLivyCompute',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}/stop',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.StopLivyComputeResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def stop_livy_compute(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.StopLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.StopLivyComputeResponse:
+        """
+        @summary 停止livy compute
+        
+        @param request: StopLivyComputeRequest
+        @return: StopLivyComputeResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.stop_livy_compute_with_options(workspace_biz_id, livy_compute_id, request, headers, runtime)
+
+    async def stop_livy_compute_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.StopLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.StopLivyComputeResponse:
+        """
+        @summary 停止livy compute
+        
+        @param request: StopLivyComputeRequest
+        @return: StopLivyComputeResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.stop_livy_compute_with_options_async(workspace_biz_id, livy_compute_id, request, headers, runtime)
+
     def stop_session_cluster_with_options(
         self,
         workspace_id: str,
@@ -3441,6 +5003,182 @@ class Client(OpenApiClient):
         headers = {}
         return await self.terminate_sql_statement_with_options_async(workspace_id, statement_id, request, headers, runtime)
 
+    def update_livy_compute_with_options(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.UpdateLivyComputeRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.UpdateLivyComputeResponse:
+        """
+        @summary 更新livy compute
+        
+        @param request: UpdateLivyComputeRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: UpdateLivyComputeResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        body = {}
+        if not UtilClient.is_unset(request.auth_type):
+            body['authType'] = request.auth_type
+        if not UtilClient.is_unset(request.auto_start_configuration):
+            body['autoStartConfiguration'] = request.auto_start_configuration
+        if not UtilClient.is_unset(request.auto_stop_configuration):
+            body['autoStopConfiguration'] = request.auto_stop_configuration
+        if not UtilClient.is_unset(request.cpu_limit):
+            body['cpuLimit'] = request.cpu_limit
+        if not UtilClient.is_unset(request.display_release_version):
+            body['displayReleaseVersion'] = request.display_release_version
+        if not UtilClient.is_unset(request.enable_public):
+            body['enablePublic'] = request.enable_public
+        if not UtilClient.is_unset(request.environment_id):
+            body['environmentId'] = request.environment_id
+        if not UtilClient.is_unset(request.fusion):
+            body['fusion'] = request.fusion
+        if not UtilClient.is_unset(request.livy_server_conf):
+            body['livyServerConf'] = request.livy_server_conf
+        if not UtilClient.is_unset(request.livy_version):
+            body['livyVersion'] = request.livy_version
+        if not UtilClient.is_unset(request.memory_limit):
+            body['memoryLimit'] = request.memory_limit
+        if not UtilClient.is_unset(request.name):
+            body['name'] = request.name
+        if not UtilClient.is_unset(request.network_name):
+            body['networkName'] = request.network_name
+        if not UtilClient.is_unset(request.queue_name):
+            body['queueName'] = request.queue_name
+        if not UtilClient.is_unset(request.release_version):
+            body['releaseVersion'] = request.release_version
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='UpdateLivyCompute',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.UpdateLivyComputeResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def update_livy_compute_with_options_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.UpdateLivyComputeRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.UpdateLivyComputeResponse:
+        """
+        @summary 更新livy compute
+        
+        @param request: UpdateLivyComputeRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: UpdateLivyComputeResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.region_id):
+            query['regionId'] = request.region_id
+        body = {}
+        if not UtilClient.is_unset(request.auth_type):
+            body['authType'] = request.auth_type
+        if not UtilClient.is_unset(request.auto_start_configuration):
+            body['autoStartConfiguration'] = request.auto_start_configuration
+        if not UtilClient.is_unset(request.auto_stop_configuration):
+            body['autoStopConfiguration'] = request.auto_stop_configuration
+        if not UtilClient.is_unset(request.cpu_limit):
+            body['cpuLimit'] = request.cpu_limit
+        if not UtilClient.is_unset(request.display_release_version):
+            body['displayReleaseVersion'] = request.display_release_version
+        if not UtilClient.is_unset(request.enable_public):
+            body['enablePublic'] = request.enable_public
+        if not UtilClient.is_unset(request.environment_id):
+            body['environmentId'] = request.environment_id
+        if not UtilClient.is_unset(request.fusion):
+            body['fusion'] = request.fusion
+        if not UtilClient.is_unset(request.livy_server_conf):
+            body['livyServerConf'] = request.livy_server_conf
+        if not UtilClient.is_unset(request.livy_version):
+            body['livyVersion'] = request.livy_version
+        if not UtilClient.is_unset(request.memory_limit):
+            body['memoryLimit'] = request.memory_limit
+        if not UtilClient.is_unset(request.name):
+            body['name'] = request.name
+        if not UtilClient.is_unset(request.network_name):
+            body['networkName'] = request.network_name
+        if not UtilClient.is_unset(request.queue_name):
+            body['queueName'] = request.queue_name
+        if not UtilClient.is_unset(request.release_version):
+            body['releaseVersion'] = request.release_version
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(body)
+        )
+        params = open_api_models.Params(
+            action='UpdateLivyCompute',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/interactive/v1/workspace/{OpenApiUtilClient.get_encode_param(workspace_biz_id)}/livycompute/{OpenApiUtilClient.get_encode_param(livy_compute_id)}',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.UpdateLivyComputeResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def update_livy_compute(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.UpdateLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.UpdateLivyComputeResponse:
+        """
+        @summary 更新livy compute
+        
+        @param request: UpdateLivyComputeRequest
+        @return: UpdateLivyComputeResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.update_livy_compute_with_options(workspace_biz_id, livy_compute_id, request, headers, runtime)
+
+    async def update_livy_compute_async(
+        self,
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.UpdateLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.UpdateLivyComputeResponse:
+        """
+        @summary 更新livy compute
+        
+        @param request: UpdateLivyComputeRequest
+        @return: UpdateLivyComputeResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.update_livy_compute_with_options_async(workspace_biz_id, livy_compute_id, request, headers, runtime)
+
     def update_process_definition_with_schedule_with_options(
         self,
         biz_id: str,