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

alibabacloud_emr_serverless_spark20230808/models.py

@@ -1756,6 +1756,196 @@ class CancelJobRunResponse(TeaModel):
         return self
 
 
+class CreateKyuubiTokenRequestAutoExpireConfiguration(TeaModel):
+    def __init__(
+        self,
+        enable: bool = None,
+        expire_days: int = None,
+    ):
+        self.enable = enable
+        self.expire_days = expire_days
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.enable is not None:
+            result['enable'] = self.enable
+        if self.expire_days is not None:
+            result['expireDays'] = self.expire_days
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('enable') is not None:
+            self.enable = m.get('enable')
+        if m.get('expireDays') is not None:
+            self.expire_days = m.get('expireDays')
+        return self
+
+
+class CreateKyuubiTokenRequest(TeaModel):
+    def __init__(
+        self,
+        auto_expire_configuration: CreateKyuubiTokenRequestAutoExpireConfiguration = None,
+        member_arns: List[str] = None,
+        name: str = None,
+        token: str = None,
+        region_id: str = None,
+    ):
+        self.auto_expire_configuration = auto_expire_configuration
+        self.member_arns = member_arns
+        self.name = name
+        self.token = token
+        self.region_id = region_id
+
+    def validate(self):
+        if self.auto_expire_configuration:
+            self.auto_expire_configuration.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.auto_expire_configuration is not None:
+            result['autoExpireConfiguration'] = self.auto_expire_configuration.to_map()
+        if self.member_arns is not None:
+            result['memberArns'] = self.member_arns
+        if self.name is not None:
+            result['name'] = self.name
+        if self.token is not None:
+            result['token'] = self.token
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('autoExpireConfiguration') is not None:
+            temp_model = CreateKyuubiTokenRequestAutoExpireConfiguration()
+            self.auto_expire_configuration = temp_model.from_map(m['autoExpireConfiguration'])
+        if m.get('memberArns') is not None:
+            self.member_arns = m.get('memberArns')
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('token') is not None:
+            self.token = m.get('token')
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
+        return self
+
+
+class CreateKyuubiTokenResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        token_id: str = None,
+    ):
+        # Token ID。
+        self.token_id = token_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.token_id is not None:
+            result['tokenId'] = self.token_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('tokenId') is not None:
+            self.token_id = m.get('tokenId')
+        return self
+
+
+class CreateKyuubiTokenResponseBody(TeaModel):
+    def __init__(
+        self,
+        data: CreateKyuubiTokenResponseBodyData = None,
+        request_id: str = None,
+    ):
+        self.data = data
+        self.request_id = request_id
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('data') is not None:
+            temp_model = CreateKyuubiTokenResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class CreateKyuubiTokenResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: CreateKyuubiTokenResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = CreateKyuubiTokenResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class CreateLivyComputeRequestAutoStartConfiguration(TeaModel):
     def __init__(
         self,
@@ -3556,6 +3746,7 @@ class CreateSqlStatementRequest(TeaModel):
         default_database: str = None,
         limit: int = None,
         sql_compute_id: str = None,
+        task_biz_id: str = None,
         region_id: str = None,
     ):
         # The SQL code. You can specify one or more SQL statements.
@@ -3568,6 +3759,7 @@ class CreateSqlStatementRequest(TeaModel):
         self.limit = limit
         # The SQL session ID. You can create an SQL session in the workspace created in EMR Serverless Spark.
         self.sql_compute_id = sql_compute_id
+        self.task_biz_id = task_biz_id
         # The region ID.
         self.region_id = region_id
 
@@ -3590,6 +3782,8 @@ class CreateSqlStatementRequest(TeaModel):
             result['limit'] = self.limit
         if self.sql_compute_id is not None:
             result['sqlComputeId'] = self.sql_compute_id
+        if self.task_biz_id is not None:
+            result['taskBizId'] = self.task_biz_id
         if self.region_id is not None:
             result['regionId'] = self.region_id
         return result
@@ -3606,6 +3800,8 @@ class CreateSqlStatementRequest(TeaModel):
             self.limit = m.get('limit')
         if m.get('sqlComputeId') is not None:
             self.sql_compute_id = m.get('sqlComputeId')
+        if m.get('taskBizId') is not None:
+            self.task_biz_id = m.get('taskBizId')
         if m.get('regionId') is not None:
             self.region_id = m.get('regionId')
         return self
@@ -4014,7 +4210,7 @@ class CreateWorkspaceResponse(TeaModel):
         return self
 
 
-class DeleteLivyComputeRequest(TeaModel):
+class DeleteKyuubiTokenRequest(TeaModel):
     def __init__(
         self,
         region_id: str = None,
@@ -4041,15 +4237,11 @@ class DeleteLivyComputeRequest(TeaModel):
         return self
 
 
-class DeleteLivyComputeResponseBody(TeaModel):
+class DeleteKyuubiTokenResponseBody(TeaModel):
     def __init__(
         self,
-        code: str = None,
-        message: str = None,
         request_id: str = None,
     ):
-        self.code = code
-        self.message = message
         self.request_id = request_id
 
     def validate(self):
@@ -4061,31 +4253,23 @@ class DeleteLivyComputeResponseBody(TeaModel):
             return _map
 
         result = dict()
-        if self.code is not None:
-            result['code'] = self.code
-        if self.message is not None:
-            result['message'] = self.message
         if self.request_id is not None:
             result['requestId'] = self.request_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('code') is not None:
-            self.code = m.get('code')
-        if m.get('message') is not None:
-            self.message = m.get('message')
         if m.get('requestId') is not None:
             self.request_id = m.get('requestId')
         return self
 
 
-class DeleteLivyComputeResponse(TeaModel):
+class DeleteKyuubiTokenResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: DeleteLivyComputeResponseBody = None,
+        body: DeleteKyuubiTokenResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -4116,12 +4300,12 @@ class DeleteLivyComputeResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = DeleteLivyComputeResponseBody()
+            temp_model = DeleteKyuubiTokenResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class DeleteLivyComputeTokenRequest(TeaModel):
+class DeleteLivyComputeRequest(TeaModel):
     def __init__(
         self,
         region_id: str = None,
@@ -4148,7 +4332,7 @@ class DeleteLivyComputeTokenRequest(TeaModel):
         return self
 
 
-class DeleteLivyComputeTokenResponseBody(TeaModel):
+class DeleteLivyComputeResponseBody(TeaModel):
     def __init__(
         self,
         code: str = None,
@@ -4187,12 +4371,12 @@ class DeleteLivyComputeTokenResponseBody(TeaModel):
         return self
 
 
-class DeleteLivyComputeTokenResponse(TeaModel):
+class DeleteLivyComputeResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: DeleteLivyComputeTokenResponseBody = None,
+        body: DeleteLivyComputeResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -4223,17 +4407,17 @@ class DeleteLivyComputeTokenResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = DeleteLivyComputeTokenResponseBody()
+            temp_model = DeleteLivyComputeResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class EditWorkspaceQueueRequestResourceSpec(TeaModel):
+class DeleteLivyComputeTokenRequest(TeaModel):
     def __init__(
         self,
-        cu: int = None,
+        region_id: str = None,
     ):
-        self.cu = cu
+        self.region_id = region_id
 
     def validate(self):
         pass
@@ -4244,35 +4428,30 @@ class EditWorkspaceQueueRequestResourceSpec(TeaModel):
             return _map
 
         result = dict()
-        if self.cu is not None:
-            result['cu'] = self.cu
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('cu') is not None:
-            self.cu = m.get('cu')
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
         return self
 
 
-class EditWorkspaceQueueRequest(TeaModel):
+class DeleteLivyComputeTokenResponseBody(TeaModel):
     def __init__(
         self,
-        environments: List[str] = None,
-        resource_spec: EditWorkspaceQueueRequestResourceSpec = None,
-        workspace_id: str = None,
-        workspace_queue_name: str = None,
-        region_id: str = None,
+        code: str = None,
+        message: str = None,
+        request_id: str = None,
     ):
-        self.environments = environments
-        self.resource_spec = resource_spec
-        self.workspace_id = workspace_id
-        self.workspace_queue_name = workspace_queue_name
-        self.region_id = region_id
+        self.code = code
+        self.message = message
+        self.request_id = request_id
 
     def validate(self):
-        if self.resource_spec:
-            self.resource_spec.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -4280,15 +4459,127 @@ class EditWorkspaceQueueRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.environments is not None:
-            result['environments'] = self.environments
-        if self.resource_spec is not None:
-            result['resourceSpec'] = self.resource_spec.to_map()
-        if self.workspace_id is not None:
-            result['workspaceId'] = self.workspace_id
-        if self.workspace_queue_name is not None:
-            result['workspaceQueueName'] = self.workspace_queue_name
-        if self.region_id is not None:
+        if self.code is not None:
+            result['code'] = self.code
+        if self.message is not None:
+            result['message'] = self.message
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('message') is not None:
+            self.message = m.get('message')
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class DeleteLivyComputeTokenResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: DeleteLivyComputeTokenResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = DeleteLivyComputeTokenResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class EditWorkspaceQueueRequestResourceSpec(TeaModel):
+    def __init__(
+        self,
+        cu: int = None,
+    ):
+        self.cu = cu
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.cu is not None:
+            result['cu'] = self.cu
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('cu') is not None:
+            self.cu = m.get('cu')
+        return self
+
+
+class EditWorkspaceQueueRequest(TeaModel):
+    def __init__(
+        self,
+        environments: List[str] = None,
+        resource_spec: EditWorkspaceQueueRequestResourceSpec = None,
+        workspace_id: str = None,
+        workspace_queue_name: str = None,
+        region_id: str = None,
+    ):
+        self.environments = environments
+        self.resource_spec = resource_spec
+        self.workspace_id = workspace_id
+        self.workspace_queue_name = workspace_queue_name
+        self.region_id = region_id
+
+    def validate(self):
+        if self.resource_spec:
+            self.resource_spec.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.environments is not None:
+            result['environments'] = self.environments
+        if self.resource_spec is not None:
+            result['resourceSpec'] = self.resource_spec.to_map()
+        if self.workspace_id is not None:
+            result['workspaceId'] = self.workspace_id
+        if self.workspace_queue_name is not None:
+            result['workspaceQueueName'] = self.workspace_queue_name
+        if self.region_id is not None:
             result['regionId'] = self.region_id
         return result
 
@@ -4873,94 +5164,308 @@ class GetJobRunResponseBodyJobRun(TeaModel):
             result['log'] = self.log.to_map()
         if self.name is not None:
             result['name'] = self.name
-        if self.release_version is not None:
-            result['releaseVersion'] = self.release_version
-        if self.resource_owner_id is not None:
-            result['resourceOwnerId'] = self.resource_owner_id
-        if self.resource_queue_id is not None:
-            result['resourceQueueId'] = self.resource_queue_id
-        if self.state is not None:
-            result['state'] = self.state
-        if self.state_change_reason is not None:
-            result['stateChangeReason'] = self.state_change_reason.to_map()
-        if self.submit_time is not None:
-            result['submitTime'] = self.submit_time
-        result['tags'] = []
-        if self.tags is not None:
-            for k in self.tags:
-                result['tags'].append(k.to_map() if k else None)
-        if self.web_ui is not None:
-            result['webUI'] = self.web_ui
-        if self.workspace_id is not None:
-            result['workspaceId'] = self.workspace_id
+        if self.release_version is not None:
+            result['releaseVersion'] = self.release_version
+        if self.resource_owner_id is not None:
+            result['resourceOwnerId'] = self.resource_owner_id
+        if self.resource_queue_id is not None:
+            result['resourceQueueId'] = self.resource_queue_id
+        if self.state is not None:
+            result['state'] = self.state
+        if self.state_change_reason is not None:
+            result['stateChangeReason'] = self.state_change_reason.to_map()
+        if self.submit_time is not None:
+            result['submitTime'] = self.submit_time
+        result['tags'] = []
+        if self.tags is not None:
+            for k in self.tags:
+                result['tags'].append(k.to_map() if k else None)
+        if self.web_ui is not None:
+            result['webUI'] = self.web_ui
+        if self.workspace_id is not None:
+            result['workspaceId'] = self.workspace_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('codeType') is not None:
+            self.code_type = m.get('codeType')
+        if m.get('configurationOverrides') is not None:
+            temp_model = GetJobRunResponseBodyJobRunConfigurationOverrides()
+            self.configuration_overrides = temp_model.from_map(m['configurationOverrides'])
+        if m.get('displayReleaseVersion') is not None:
+            self.display_release_version = m.get('displayReleaseVersion')
+        if m.get('endTime') is not None:
+            self.end_time = m.get('endTime')
+        if m.get('environmentId') is not None:
+            self.environment_id = m.get('environmentId')
+        if m.get('executionTimeoutSeconds') is not None:
+            self.execution_timeout_seconds = m.get('executionTimeoutSeconds')
+        if m.get('fusion') is not None:
+            self.fusion = m.get('fusion')
+        if m.get('jobDriver') is not None:
+            temp_model = JobDriver()
+            self.job_driver = temp_model.from_map(m['jobDriver'])
+        if m.get('jobRunId') is not None:
+            self.job_run_id = m.get('jobRunId')
+        if m.get('log') is not None:
+            temp_model = RunLog()
+            self.log = temp_model.from_map(m['log'])
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('releaseVersion') is not None:
+            self.release_version = m.get('releaseVersion')
+        if m.get('resourceOwnerId') is not None:
+            self.resource_owner_id = m.get('resourceOwnerId')
+        if m.get('resourceQueueId') is not None:
+            self.resource_queue_id = m.get('resourceQueueId')
+        if m.get('state') is not None:
+            self.state = m.get('state')
+        if m.get('stateChangeReason') is not None:
+            temp_model = GetJobRunResponseBodyJobRunStateChangeReason()
+            self.state_change_reason = temp_model.from_map(m['stateChangeReason'])
+        if m.get('submitTime') is not None:
+            self.submit_time = m.get('submitTime')
+        self.tags = []
+        if m.get('tags') is not None:
+            for k in m.get('tags'):
+                temp_model = Tag()
+                self.tags.append(temp_model.from_map(k))
+        if m.get('webUI') is not None:
+            self.web_ui = m.get('webUI')
+        if m.get('workspaceId') is not None:
+            self.workspace_id = m.get('workspaceId')
+        return self
+
+
+class GetJobRunResponseBody(TeaModel):
+    def __init__(
+        self,
+        job_run: GetJobRunResponseBodyJobRun = None,
+        request_id: str = None,
+    ):
+        # The details of the job.
+        self.job_run = job_run
+        # The request ID.
+        self.request_id = request_id
+
+    def validate(self):
+        if self.job_run:
+            self.job_run.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.job_run is not None:
+            result['jobRun'] = self.job_run.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('jobRun') is not None:
+            temp_model = GetJobRunResponseBodyJobRun()
+            self.job_run = temp_model.from_map(m['jobRun'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class GetJobRunResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetJobRunResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = GetJobRunResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetKyuubiTokenRequest(TeaModel):
+    def __init__(
+        self,
+        region_id: str = None,
+    ):
+        self.region_id = region_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
+        return self
+
+
+class GetKyuubiTokenResponseBodyDataAutoExpireConfiguration(TeaModel):
+    def __init__(
+        self,
+        enable: bool = None,
+        expire_days: int = None,
+    ):
+        self.enable = enable
+        self.expire_days = expire_days
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.enable is not None:
+            result['enable'] = self.enable
+        if self.expire_days is not None:
+            result['expireDays'] = self.expire_days
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('enable') is not None:
+            self.enable = m.get('enable')
+        if m.get('expireDays') is not None:
+            self.expire_days = m.get('expireDays')
+        return self
+
+
+class GetKyuubiTokenResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        auto_expire_configuration: GetKyuubiTokenResponseBodyDataAutoExpireConfiguration = None,
+        create_time: int = None,
+        created_by: str = None,
+        expire_time: int = None,
+        last_used_time: int = None,
+        member_arns: List[str] = None,
+        name: str = None,
+        token: str = None,
+        token_id: str = None,
+    ):
+        self.auto_expire_configuration = auto_expire_configuration
+        self.create_time = create_time
+        self.created_by = created_by
+        self.expire_time = expire_time
+        self.last_used_time = last_used_time
+        self.member_arns = member_arns
+        self.name = name
+        self.token = token
+        # Token ID。
+        self.token_id = token_id
+
+    def validate(self):
+        if self.auto_expire_configuration:
+            self.auto_expire_configuration.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.auto_expire_configuration is not None:
+            result['autoExpireConfiguration'] = self.auto_expire_configuration.to_map()
+        if self.create_time is not None:
+            result['createTime'] = self.create_time
+        if self.created_by is not None:
+            result['createdBy'] = self.created_by
+        if self.expire_time is not None:
+            result['expireTime'] = self.expire_time
+        if self.last_used_time is not None:
+            result['lastUsedTime'] = self.last_used_time
+        if self.member_arns is not None:
+            result['memberArns'] = self.member_arns
+        if self.name is not None:
+            result['name'] = self.name
+        if self.token is not None:
+            result['token'] = self.token
+        if self.token_id is not None:
+            result['tokenId'] = self.token_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('codeType') is not None:
-            self.code_type = m.get('codeType')
-        if m.get('configurationOverrides') is not None:
-            temp_model = GetJobRunResponseBodyJobRunConfigurationOverrides()
-            self.configuration_overrides = temp_model.from_map(m['configurationOverrides'])
-        if m.get('displayReleaseVersion') is not None:
-            self.display_release_version = m.get('displayReleaseVersion')
-        if m.get('endTime') is not None:
-            self.end_time = m.get('endTime')
-        if m.get('environmentId') is not None:
-            self.environment_id = m.get('environmentId')
-        if m.get('executionTimeoutSeconds') is not None:
-            self.execution_timeout_seconds = m.get('executionTimeoutSeconds')
-        if m.get('fusion') is not None:
-            self.fusion = m.get('fusion')
-        if m.get('jobDriver') is not None:
-            temp_model = JobDriver()
-            self.job_driver = temp_model.from_map(m['jobDriver'])
-        if m.get('jobRunId') is not None:
-            self.job_run_id = m.get('jobRunId')
-        if m.get('log') is not None:
-            temp_model = RunLog()
-            self.log = temp_model.from_map(m['log'])
+        if m.get('autoExpireConfiguration') is not None:
+            temp_model = GetKyuubiTokenResponseBodyDataAutoExpireConfiguration()
+            self.auto_expire_configuration = temp_model.from_map(m['autoExpireConfiguration'])
+        if m.get('createTime') is not None:
+            self.create_time = m.get('createTime')
+        if m.get('createdBy') is not None:
+            self.created_by = m.get('createdBy')
+        if m.get('expireTime') is not None:
+            self.expire_time = m.get('expireTime')
+        if m.get('lastUsedTime') is not None:
+            self.last_used_time = m.get('lastUsedTime')
+        if m.get('memberArns') is not None:
+            self.member_arns = m.get('memberArns')
         if m.get('name') is not None:
             self.name = m.get('name')
-        if m.get('releaseVersion') is not None:
-            self.release_version = m.get('releaseVersion')
-        if m.get('resourceOwnerId') is not None:
-            self.resource_owner_id = m.get('resourceOwnerId')
-        if m.get('resourceQueueId') is not None:
-            self.resource_queue_id = m.get('resourceQueueId')
-        if m.get('state') is not None:
-            self.state = m.get('state')
-        if m.get('stateChangeReason') is not None:
-            temp_model = GetJobRunResponseBodyJobRunStateChangeReason()
-            self.state_change_reason = temp_model.from_map(m['stateChangeReason'])
-        if m.get('submitTime') is not None:
-            self.submit_time = m.get('submitTime')
-        self.tags = []
-        if m.get('tags') is not None:
-            for k in m.get('tags'):
-                temp_model = Tag()
-                self.tags.append(temp_model.from_map(k))
-        if m.get('webUI') is not None:
-            self.web_ui = m.get('webUI')
-        if m.get('workspaceId') is not None:
-            self.workspace_id = m.get('workspaceId')
+        if m.get('token') is not None:
+            self.token = m.get('token')
+        if m.get('tokenId') is not None:
+            self.token_id = m.get('tokenId')
         return self
 
 
-class GetJobRunResponseBody(TeaModel):
+class GetKyuubiTokenResponseBody(TeaModel):
     def __init__(
         self,
-        job_run: GetJobRunResponseBodyJobRun = None,
+        data: GetKyuubiTokenResponseBodyData = None,
         request_id: str = None,
     ):
-        # The details of the job.
-        self.job_run = job_run
-        # The request ID.
+        self.data = data
         self.request_id = request_id
 
     def validate(self):
-        if self.job_run:
-            self.job_run.validate()
+        if self.data:
+            self.data.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -4968,28 +5473,28 @@ class GetJobRunResponseBody(TeaModel):
             return _map
 
         result = dict()
-        if self.job_run is not None:
-            result['jobRun'] = self.job_run.to_map()
+        if self.data is not None:
+            result['data'] = self.data.to_map()
         if self.request_id is not None:
             result['requestId'] = self.request_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('jobRun') is not None:
-            temp_model = GetJobRunResponseBodyJobRun()
-            self.job_run = temp_model.from_map(m['jobRun'])
+        if m.get('data') is not None:
+            temp_model = GetKyuubiTokenResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
         if m.get('requestId') is not None:
             self.request_id = m.get('requestId')
         return self
 
 
-class GetJobRunResponse(TeaModel):
+class GetKyuubiTokenResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: GetJobRunResponseBody = None,
+        body: GetKyuubiTokenResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -5020,7 +5525,7 @@ class GetJobRunResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = GetJobRunResponseBody()
+            temp_model = GetKyuubiTokenResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
@@ -12281,6 +12786,160 @@ class TerminateSqlStatementResponse(TeaModel):
         return self
 
 
+class UpdateKyuubiTokenRequestAutoExpireConfiguration(TeaModel):
+    def __init__(
+        self,
+        enable: bool = None,
+        expire_days: int = None,
+    ):
+        self.enable = enable
+        self.expire_days = expire_days
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.enable is not None:
+            result['enable'] = self.enable
+        if self.expire_days is not None:
+            result['expireDays'] = self.expire_days
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('enable') is not None:
+            self.enable = m.get('enable')
+        if m.get('expireDays') is not None:
+            self.expire_days = m.get('expireDays')
+        return self
+
+
+class UpdateKyuubiTokenRequest(TeaModel):
+    def __init__(
+        self,
+        auto_expire_configuration: UpdateKyuubiTokenRequestAutoExpireConfiguration = None,
+        member_arns: List[str] = None,
+        name: str = None,
+        token: str = None,
+        region_id: str = None,
+    ):
+        self.auto_expire_configuration = auto_expire_configuration
+        self.member_arns = member_arns
+        self.name = name
+        self.token = token
+        self.region_id = region_id
+
+    def validate(self):
+        if self.auto_expire_configuration:
+            self.auto_expire_configuration.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.auto_expire_configuration is not None:
+            result['autoExpireConfiguration'] = self.auto_expire_configuration.to_map()
+        if self.member_arns is not None:
+            result['memberArns'] = self.member_arns
+        if self.name is not None:
+            result['name'] = self.name
+        if self.token is not None:
+            result['token'] = self.token
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('autoExpireConfiguration') is not None:
+            temp_model = UpdateKyuubiTokenRequestAutoExpireConfiguration()
+            self.auto_expire_configuration = temp_model.from_map(m['autoExpireConfiguration'])
+        if m.get('memberArns') is not None:
+            self.member_arns = m.get('memberArns')
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('token') is not None:
+            self.token = m.get('token')
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
+        return self
+
+
+class UpdateKyuubiTokenResponseBody(TeaModel):
+    def __init__(
+        self,
+        request_id: str = None,
+    ):
+        self.request_id = request_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class UpdateKyuubiTokenResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: UpdateKyuubiTokenResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = UpdateKyuubiTokenResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class UpdateLivyComputeRequestAutoStartConfiguration(TeaModel):
     def __init__(
         self,