alibabacloud-emr-serverless-spark20230808 1.11.0__py3-none-any.whl → 1.12.1__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,
@@ -1238,10 +1766,234 @@ class Client(OpenApiClient):
             query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='GetDoctorApplication',
+            action='GetDoctorApplication',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/runs/{OpenApiUtilClient.get_encode_param(run_id)}/action/getDoctorApplication',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.GetDoctorApplicationResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def get_doctor_application(
+        self,
+        workspace_id: str,
+        run_id: str,
+        request: emr_serverless_spark_20230808_models.GetDoctorApplicationRequest,
+    ) -> emr_serverless_spark_20230808_models.GetDoctorApplicationResponse:
+        """
+        @summary Obtains job analysis information on E-MapReduce (EMR) Doctor.
+        
+        @param request: GetDoctorApplicationRequest
+        @return: GetDoctorApplicationResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.get_doctor_application_with_options(workspace_id, run_id, request, headers, runtime)
+
+    async def get_doctor_application_async(
+        self,
+        workspace_id: str,
+        run_id: str,
+        request: emr_serverless_spark_20230808_models.GetDoctorApplicationRequest,
+    ) -> emr_serverless_spark_20230808_models.GetDoctorApplicationResponse:
+        """
+        @summary Obtains job analysis information on E-MapReduce (EMR) Doctor.
+        
+        @param request: GetDoctorApplicationRequest
+        @return: GetDoctorApplicationResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.get_doctor_application_with_options_async(workspace_id, run_id, request, headers, runtime)
+
+    def get_job_run_with_options(
+        self,
+        workspace_id: str,
+        job_run_id: str,
+        request: emr_serverless_spark_20230808_models.GetJobRunRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.GetJobRunResponse:
+        """
+        @summary Obtain the job details.
+        
+        @param request: GetJobRunRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetJobRunResponse
+        """
+        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='GetJobRun',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/jobRuns/{OpenApiUtilClient.get_encode_param(job_run_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.GetJobRunResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def get_job_run_with_options_async(
+        self,
+        workspace_id: str,
+        job_run_id: str,
+        request: emr_serverless_spark_20230808_models.GetJobRunRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> emr_serverless_spark_20230808_models.GetJobRunResponse:
+        """
+        @summary Obtain the job details.
+        
+        @param request: GetJobRunRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetJobRunResponse
+        """
+        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='GetJobRun',
+            version='2023-08-08',
+            protocol='HTTPS',
+            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/jobRuns/{OpenApiUtilClient.get_encode_param(job_run_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.GetJobRunResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def get_job_run(
+        self,
+        workspace_id: str,
+        job_run_id: str,
+        request: emr_serverless_spark_20230808_models.GetJobRunRequest,
+    ) -> emr_serverless_spark_20230808_models.GetJobRunResponse:
+        """
+        @summary Obtain the job details.
+        
+        @param request: GetJobRunRequest
+        @return: GetJobRunResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.get_job_run_with_options(workspace_id, job_run_id, request, headers, runtime)
+
+    async def get_job_run_async(
+        self,
+        workspace_id: str,
+        job_run_id: str,
+        request: emr_serverless_spark_20230808_models.GetJobRunRequest,
+    ) -> emr_serverless_spark_20230808_models.GetJobRunResponse:
+        """
+        @summary Obtain the job details.
+        
+        @param request: GetJobRunRequest
+        @return: GetJobRunResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.get_job_run_with_options_async(workspace_id, job_run_id, request, headers, runtime)
+
+    def get_livy_compute_with_options(
+        self,
+        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.GetLivyComputeResponse:
+        """
+        @summary 获取livy compute
+        
+        @param request: GetLivyComputeRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetLivyComputeResponse
+        """
+        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='GetLivyCompute',
+            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='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            emr_serverless_spark_20230808_models.GetLivyComputeResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def get_livy_compute_with_options_async(
+        self,
+        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.GetLivyComputeResponse:
+        """
+        @summary 获取livy compute
+        
+        @param request: GetLivyComputeRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetLivyComputeResponse
+        """
+        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='GetLivyCompute',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/runs/{OpenApiUtilClient.get_encode_param(run_id)}/action/getDoctorApplication',
+            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',
@@ -1249,57 +2001,58 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.GetDoctorApplicationResponse(),
+            emr_serverless_spark_20230808_models.GetLivyComputeResponse(),
             await self.call_api_async(params, req, runtime)
         )
 
-    def get_doctor_application(
+    def get_livy_compute(
         self,
-        workspace_id: str,
-        run_id: str,
-        request: emr_serverless_spark_20230808_models.GetDoctorApplicationRequest,
-    ) -> emr_serverless_spark_20230808_models.GetDoctorApplicationResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.GetLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeResponse:
         """
-        @summary Obtains job analysis information on E-MapReduce (EMR) Doctor.
+        @summary 获取livy compute
         
-        @param request: GetDoctorApplicationRequest
-        @return: GetDoctorApplicationResponse
+        @param request: GetLivyComputeRequest
+        @return: GetLivyComputeResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return self.get_doctor_application_with_options(workspace_id, run_id, request, headers, runtime)
+        return self.get_livy_compute_with_options(workspace_biz_id, livy_compute_id, request, headers, runtime)
 
-    async def get_doctor_application_async(
+    async def get_livy_compute_async(
         self,
-        workspace_id: str,
-        run_id: str,
-        request: emr_serverless_spark_20230808_models.GetDoctorApplicationRequest,
-    ) -> emr_serverless_spark_20230808_models.GetDoctorApplicationResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.GetLivyComputeRequest,
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeResponse:
         """
-        @summary Obtains job analysis information on E-MapReduce (EMR) Doctor.
+        @summary 获取livy compute
         
-        @param request: GetDoctorApplicationRequest
-        @return: GetDoctorApplicationResponse
+        @param request: GetLivyComputeRequest
+        @return: GetLivyComputeResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return await self.get_doctor_application_with_options_async(workspace_id, run_id, request, headers, runtime)
+        return await self.get_livy_compute_with_options_async(workspace_biz_id, livy_compute_id, request, headers, runtime)
 
-    def get_job_run_with_options(
+    def get_livy_compute_token_with_options(
         self,
-        workspace_id: str,
-        job_run_id: str,
-        request: emr_serverless_spark_20230808_models.GetJobRunRequest,
+        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.GetJobRunResponse:
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeTokenResponse:
         """
-        @summary Obtain the job details.
+        @summary 获取livy compute token
         
-        @param request: GetJobRunRequest
+        @param request: GetLivyComputeTokenRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: GetJobRunResponse
+        @return: GetLivyComputeTokenResponse
         """
         UtilClient.validate_model(request)
         query = {}
@@ -1310,10 +2063,10 @@ class Client(OpenApiClient):
             query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='GetJobRun',
+            action='GetLivyComputeToken',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/jobRuns/{OpenApiUtilClient.get_encode_param(job_run_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',
@@ -1321,25 +2074,26 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.GetJobRunResponse(),
+            emr_serverless_spark_20230808_models.GetLivyComputeTokenResponse(),
             self.call_api(params, req, runtime)
         )
 
-    async def get_job_run_with_options_async(
+    async def get_livy_compute_token_with_options_async(
         self,
-        workspace_id: str,
-        job_run_id: str,
-        request: emr_serverless_spark_20230808_models.GetJobRunRequest,
+        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.GetJobRunResponse:
+    ) -> emr_serverless_spark_20230808_models.GetLivyComputeTokenResponse:
         """
-        @summary Obtain the job details.
+        @summary 获取livy compute token
         
-        @param request: GetJobRunRequest
+        @param request: GetLivyComputeTokenRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: GetJobRunResponse
+        @return: GetLivyComputeTokenResponse
         """
         UtilClient.validate_model(request)
         query = {}
@@ -1350,10 +2104,10 @@ class Client(OpenApiClient):
             query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='GetJobRun',
+            action='GetLivyComputeToken',
             version='2023-08-08',
             protocol='HTTPS',
-            pathname=f'/api/v1/workspaces/{OpenApiUtilClient.get_encode_param(workspace_id)}/jobRuns/{OpenApiUtilClient.get_encode_param(job_run_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',
@@ -1361,41 +2115,43 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.GetJobRunResponse(),
+            emr_serverless_spark_20230808_models.GetLivyComputeTokenResponse(),
             await self.call_api_async(params, req, runtime)
         )
 
-    def get_job_run(
+    def get_livy_compute_token(
         self,
-        workspace_id: str,
-        job_run_id: str,
-        request: emr_serverless_spark_20230808_models.GetJobRunRequest,
-    ) -> emr_serverless_spark_20230808_models.GetJobRunResponse:
+        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 Obtain the job details.
+        @summary 获取livy compute token
         
-        @param request: GetJobRunRequest
-        @return: GetJobRunResponse
+        @param request: GetLivyComputeTokenRequest
+        @return: GetLivyComputeTokenResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return self.get_job_run_with_options(workspace_id, job_run_id, request, headers, runtime)
+        return self.get_livy_compute_token_with_options(workspace_biz_id, livy_compute_id, token_id, request, headers, runtime)
 
-    async def get_job_run_async(
+    async def get_livy_compute_token_async(
         self,
-        workspace_id: str,
-        job_run_id: str,
-        request: emr_serverless_spark_20230808_models.GetJobRunRequest,
-    ) -> emr_serverless_spark_20230808_models.GetJobRunResponse:
+        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 Obtain the job details.
+        @summary 获取livy compute token
         
-        @param request: GetJobRunRequest
-        @return: GetJobRunResponse
+        @param request: GetLivyComputeTokenRequest
+        @return: GetLivyComputeTokenResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return await self.get_job_run_with_options_async(workspace_id, job_run_id, request, headers, runtime)
+        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,
@@ -2270,30 +3026,254 @@ class Client(OpenApiClient):
         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.
+        @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: ListKyuubiSparkApplicationsRequest
-        @return: ListKyuubiSparkApplicationsResponse
+        @param request: ListLivyComputeRequest
+        @return: ListLivyComputeResponse
         """
         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_with_options_async(workspace_biz_id, request, headers, runtime)
 
-    def list_kyuubi_token_with_options(
+    def list_livy_compute_token_with_options(
         self,
-        workspace_id: str,
-        kyuubi_service_id: str,
-        request: emr_serverless_spark_20230808_models.ListKyuubiTokenRequest,
+        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.ListKyuubiTokenResponse:
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse:
         """
-        @summary 列出compute的token
+        @summary 列出livy compute token
         
-        @param request: ListKyuubiTokenRequest
+        @param request: ListLivyComputeTokenRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: ListKyuubiTokenResponse
+        @return: ListLivyComputeTokenResponse
         """
         UtilClient.validate_model(request)
         query = {}
@@ -2304,10 +3284,10 @@ class Client(OpenApiClient):
             query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='ListKyuubiToken',
+            action='ListLivyComputeToken',
             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',
+            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',
@@ -2315,25 +3295,25 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.ListKyuubiTokenResponse(),
+            emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse(),
             self.call_api(params, req, runtime)
         )
 
-    async def list_kyuubi_token_with_options_async(
+    async def list_livy_compute_token_with_options_async(
         self,
-        workspace_id: str,
-        kyuubi_service_id: str,
-        request: emr_serverless_spark_20230808_models.ListKyuubiTokenRequest,
+        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.ListKyuubiTokenResponse:
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse:
         """
-        @summary 列出compute的token
+        @summary 列出livy compute token
         
-        @param request: ListKyuubiTokenRequest
+        @param request: ListLivyComputeTokenRequest
         @param headers: map
         @param runtime: runtime options for this request RuntimeOptions
-        @return: ListKyuubiTokenResponse
+        @return: ListLivyComputeTokenResponse
         """
         UtilClient.validate_model(request)
         query = {}
@@ -2344,10 +3324,10 @@ class Client(OpenApiClient):
             query=OpenApiUtilClient.query(query)
         )
         params = open_api_models.Params(
-            action='ListKyuubiToken',
+            action='ListLivyComputeToken',
             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',
+            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',
@@ -2355,41 +3335,41 @@ class Client(OpenApiClient):
             body_type='json'
         )
         return TeaCore.from_map(
-            emr_serverless_spark_20230808_models.ListKyuubiTokenResponse(),
+            emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse(),
             await self.call_api_async(params, req, runtime)
         )
 
-    def list_kyuubi_token(
+    def list_livy_compute_token(
         self,
-        workspace_id: str,
-        kyuubi_service_id: str,
-        request: emr_serverless_spark_20230808_models.ListKyuubiTokenRequest,
-    ) -> emr_serverless_spark_20230808_models.ListKyuubiTokenResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.ListLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse:
         """
-        @summary 列出compute的token
+        @summary 列出livy compute token
         
-        @param request: ListKyuubiTokenRequest
-        @return: ListKyuubiTokenResponse
+        @param request: ListLivyComputeTokenRequest
+        @return: ListLivyComputeTokenResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return self.list_kyuubi_token_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_token_async(
+    async def list_livy_compute_token_async(
         self,
-        workspace_id: str,
-        kyuubi_service_id: str,
-        request: emr_serverless_spark_20230808_models.ListKyuubiTokenRequest,
-    ) -> emr_serverless_spark_20230808_models.ListKyuubiTokenResponse:
+        workspace_biz_id: str,
+        livy_compute_id: str,
+        request: emr_serverless_spark_20230808_models.ListLivyComputeTokenRequest,
+    ) -> emr_serverless_spark_20230808_models.ListLivyComputeTokenResponse:
         """
-        @summary 列出compute的token
+        @summary 列出livy compute token
         
-        @param request: ListKyuubiTokenRequest
-        @return: ListKyuubiTokenResponse
+        @param request: ListLivyComputeTokenRequest
+        @return: ListLivyComputeTokenResponse
         """
         runtime = util_models.RuntimeOptions()
         headers = {}
-        return await self.list_kyuubi_token_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,
@@ -3007,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,
@@ -3053,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',
@@ -3068,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',
@@ -3133,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,
@@ -3435,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,
@@ -3667,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,