# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
from Tea.model import TeaModel


class Collection(TeaModel):
    def __init__(self, collection_type=None, comment=None, create_time=None, level=None, name=None, owner_id=None,
                 owner_name=None, qualified_name=None, update_time=None):
        self.collection_type = collection_type  # type: str
        self.comment = comment  # type: str
        self.create_time = create_time  # type: long
        self.level = level  # type: int
        self.name = name  # type: str
        self.owner_id = owner_id  # type: str
        self.owner_name = owner_name  # type: str
        self.qualified_name = qualified_name  # type: str
        self.update_time = update_time  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(Collection, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.collection_type is not None:
            result['CollectionType'] = self.collection_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.level is not None:
            result['Level'] = self.level
        if self.name is not None:
            result['Name'] = self.name
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.owner_name is not None:
            result['OwnerName'] = self.owner_name
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        if self.update_time is not None:
            result['UpdateTime'] = self.update_time
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CollectionType') is not None:
            self.collection_type = m.get('CollectionType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('Level') is not None:
            self.level = m.get('Level')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('OwnerName') is not None:
            self.owner_name = m.get('OwnerName')
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        if m.get('UpdateTime') is not None:
            self.update_time = m.get('UpdateTime')
        return self


class Entity(TeaModel):
    def __init__(self, entity_content=None, qualified_name=None, tenant_id=None):
        self.entity_content = entity_content  # type: dict[str, any]
        self.qualified_name = qualified_name  # type: str
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(Entity, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.entity_content is not None:
            result['EntityContent'] = self.entity_content
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EntityContent') is not None:
            self.entity_content = m.get('EntityContent')
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class LineageEntityVO(TeaModel):
    def __init__(self, detail_url=None, name=None, parent_name=None, qualified_name=None):
        self.detail_url = detail_url  # type: str
        self.name = name  # type: str
        self.parent_name = parent_name  # type: str
        self.qualified_name = qualified_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(LineageEntityVO, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.detail_url is not None:
            result['DetailUrl'] = self.detail_url
        if self.name is not None:
            result['Name'] = self.name
        if self.parent_name is not None:
            result['ParentName'] = self.parent_name
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DetailUrl') is not None:
            self.detail_url = m.get('DetailUrl')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ParentName') is not None:
            self.parent_name = m.get('ParentName')
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        return self


class LineageRelationRegisterVO(TeaModel):
    def __init__(self, create_timestamp=None, dest_entity=None, relationship=None, src_entity=None):
        self.create_timestamp = create_timestamp  # type: long
        self.dest_entity = dest_entity  # type: LineageEntityVO
        self.relationship = relationship  # type: RelationshipVO
        self.src_entity = src_entity  # type: LineageEntityVO

    def validate(self):
        if self.dest_entity:
            self.dest_entity.validate()
        if self.relationship:
            self.relationship.validate()
        if self.src_entity:
            self.src_entity.validate()

    def to_map(self):
        _map = super(LineageRelationRegisterVO, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.create_timestamp is not None:
            result['CreateTimestamp'] = self.create_timestamp
        if self.dest_entity is not None:
            result['DestEntity'] = self.dest_entity.to_map()
        if self.relationship is not None:
            result['Relationship'] = self.relationship.to_map()
        if self.src_entity is not None:
            result['SrcEntity'] = self.src_entity.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreateTimestamp') is not None:
            self.create_timestamp = m.get('CreateTimestamp')
        if m.get('DestEntity') is not None:
            temp_model = LineageEntityVO()
            self.dest_entity = temp_model.from_map(m['DestEntity'])
        if m.get('Relationship') is not None:
            temp_model = RelationshipVO()
            self.relationship = temp_model.from_map(m['Relationship'])
        if m.get('SrcEntity') is not None:
            temp_model = LineageEntityVO()
            self.src_entity = temp_model.from_map(m['SrcEntity'])
        return self


class RelationshipVO(TeaModel):
    def __init__(self, type=None):
        self.type = type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(RelationshipVO, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.type is not None:
            result['Type'] = self.type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class UserEntityTag(TeaModel):
    def __init__(self, tag_key=None, tag_value=None):
        self.tag_key = tag_key  # type: str
        self.tag_value = tag_value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UserEntityTag, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.tag_key is not None:
            result['TagKey'] = self.tag_key
        if self.tag_value is not None:
            result['TagValue'] = self.tag_value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TagKey') is not None:
            self.tag_key = m.get('TagKey')
        if m.get('TagValue') is not None:
            self.tag_value = m.get('TagValue')
        return self


class AbolishDataServiceApiRequest(TeaModel):
    def __init__(self, api_id=None, project_id=None, tenant_id=None):
        # The ID of the DataService Studio API.
        self.api_id = api_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(AbolishDataServiceApiRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class AbolishDataServiceApiResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the DataService Studio API is unpublished.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(AbolishDataServiceApiResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class AbolishDataServiceApiResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: AbolishDataServiceApiResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(AbolishDataServiceApiResponse, self).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=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 = AbolishDataServiceApiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class AddMetaCollectionEntityRequest(TeaModel):
    def __init__(self, collection_qualified_name=None, entity_qualified_name=None, remark=None):
        # The unique identifier of the entity.
        # 
        # Example: maxcompute-table.projectA.tableA.
        self.collection_qualified_name = collection_qualified_name  # type: str
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.entity_qualified_name = entity_qualified_name  # type: str
        self.remark = remark  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(AddMetaCollectionEntityRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.collection_qualified_name is not None:
            result['CollectionQualifiedName'] = self.collection_qualified_name
        if self.entity_qualified_name is not None:
            result['EntityQualifiedName'] = self.entity_qualified_name
        if self.remark is not None:
            result['Remark'] = self.remark
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CollectionQualifiedName') is not None:
            self.collection_qualified_name = m.get('CollectionQualifiedName')
        if m.get('EntityQualifiedName') is not None:
            self.entity_qualified_name = m.get('EntityQualifiedName')
        if m.get('Remark') is not None:
            self.remark = m.get('Remark')
        return self


class AddMetaCollectionEntityResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, status=None,
                 success=None):
        # Indicates whether the request was successful. Valid values:
        # 
        # true: The request was successful.
        # 
        # false: The request failed.
        self.error_code = error_code  # type: str
        # The error code returned.
        self.error_message = error_message  # type: str
        # The error message returned.
        self.http_status_code = http_status_code  # type: int
        # The result of the operation. Valid values:
        # 
        # *   true: succeeded
        # *   false: failed
        self.request_id = request_id  # type: str
        # The HTTP status code returned.
        self.status = status  # type: bool
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(AddMetaCollectionEntityResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.status is not None:
            result['Status'] = self.status
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class AddMetaCollectionEntityResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: AddMetaCollectionEntityResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(AddMetaCollectionEntityResponse, self).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=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 = AddMetaCollectionEntityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class AddProjectMemberToRoleRequest(TeaModel):
    def __init__(self, client_token=None, project_id=None, role_code=None, user_id=None):
        # The ID of the request. You can use the ID to search for logs and troubleshoot issues based on the logs.
        self.client_token = client_token  # type: str
        # The ID of your Alibaba Cloud account. To view the ID, log on to [the DataWorks console](https://workbench.data.aliyun.com/console) and move the pointer over the profile picture in the upper-right corner.
        self.project_id = project_id  # type: long
        # The client token. It is a field with the idempotence property. We recommend that you use a universally unique identifier (UUID). This parameter is used to uniquely identify the API operation call.
        self.role_code = role_code  # type: str
        # The region of the workspace. For example, the ID of the China (Shanghai) region is cn-shanghai, and that of the China (Zhangjiakou) region is cn-zhangjiakou. The system automatically determines the value of this parameter based on the endpoint used to call the operation.
        self.user_id = user_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(AddProjectMemberToRoleRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.client_token is not None:
            result['ClientToken'] = self.client_token
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.role_code is not None:
            result['RoleCode'] = self.role_code
        if self.user_id is not None:
            result['UserId'] = self.user_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClientToken') is not None:
            self.client_token = m.get('ClientToken')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RoleCode') is not None:
            self.role_code = m.get('RoleCode')
        if m.get('UserId') is not None:
            self.user_id = m.get('UserId')
        return self


class AddProjectMemberToRoleResponseBody(TeaModel):
    def __init__(self, request_id=None):
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(AddProjectMemberToRoleResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class AddProjectMemberToRoleResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: AddProjectMemberToRoleResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(AddProjectMemberToRoleResponse, self).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=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 = AddProjectMemberToRoleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class AddToMetaCategoryRequest(TeaModel):
    def __init__(self, category_id=None, table_guid=None):
        # The ID of the category.
        self.category_id = category_id  # type: long
        # The GUID of the metatable.
        self.table_guid = table_guid  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(AddToMetaCategoryRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.category_id is not None:
            result['CategoryId'] = self.category_id
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CategoryId') is not None:
            self.category_id = m.get('CategoryId')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        return self


class AddToMetaCategoryResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the metatable was added to the specified category.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(AddToMetaCategoryResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class AddToMetaCategoryResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: AddToMetaCategoryResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(AddToMetaCategoryResponse, self).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=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 = AddToMetaCategoryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ApprovePermissionApplyOrderRequest(TeaModel):
    def __init__(self, approve_action=None, approve_comment=None, flow_id=None):
        # The approval action. Valid values:
        # 
        # *   1: Approve the permission request order.
        # *   2: Reject the permission request order.
        self.approve_action = approve_action  # type: int
        # The comment on the approval.
        self.approve_comment = approve_comment  # type: str
        # The ID of the permission request order. You can call the ListPermissionApplyOrders operation to obtain the order ID.
        self.flow_id = flow_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ApprovePermissionApplyOrderRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.approve_action is not None:
            result['ApproveAction'] = self.approve_action
        if self.approve_comment is not None:
            result['ApproveComment'] = self.approve_comment
        if self.flow_id is not None:
            result['FlowId'] = self.flow_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApproveAction') is not None:
            self.approve_action = m.get('ApproveAction')
        if m.get('ApproveComment') is not None:
            self.approve_comment = m.get('ApproveComment')
        if m.get('FlowId') is not None:
            self.flow_id = m.get('FlowId')
        return self


class ApprovePermissionApplyOrderResponseBody(TeaModel):
    def __init__(self, approve_success=None, request_id=None):
        # Indicates that the approval is successful.
        self.approve_success = approve_success  # type: bool
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ApprovePermissionApplyOrderResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.approve_success is not None:
            result['ApproveSuccess'] = self.approve_success
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApproveSuccess') is not None:
            self.approve_success = m.get('ApproveSuccess')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ApprovePermissionApplyOrderResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ApprovePermissionApplyOrderResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ApprovePermissionApplyOrderResponse, self).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=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 = ApprovePermissionApplyOrderResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CallbackExtensionRequest(TeaModel):
    def __init__(self, check_message=None, check_result=None, extension_code=None, message_id=None):
        self.check_message = check_message  # type: str
        self.check_result = check_result  # type: str
        self.extension_code = extension_code  # type: str
        self.message_id = message_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CallbackExtensionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.check_message is not None:
            result['CheckMessage'] = self.check_message
        if self.check_result is not None:
            result['CheckResult'] = self.check_result
        if self.extension_code is not None:
            result['ExtensionCode'] = self.extension_code
        if self.message_id is not None:
            result['MessageId'] = self.message_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CheckMessage') is not None:
            self.check_message = m.get('CheckMessage')
        if m.get('CheckResult') is not None:
            self.check_result = m.get('CheckResult')
        if m.get('ExtensionCode') is not None:
            self.extension_code = m.get('ExtensionCode')
        if m.get('MessageId') is not None:
            self.message_id = m.get('MessageId')
        return self


class CallbackExtensionResponseBody(TeaModel):
    def __init__(self, request_id=None, success=None):
        self.request_id = request_id  # type: str
        self.success = success  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CallbackExtensionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CallbackExtensionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CallbackExtensionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CallbackExtensionResponse, self).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=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 = CallbackExtensionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ChangeResourceManagerResourceGroupRequest(TeaModel):
    def __init__(self, resource_id=None, resource_manager_resource_group_id=None, resource_type=None):
        # The ID of the new resource group.
        self.resource_id = resource_id  # type: str
        # Indicates whether the resource group was successfully modified.
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        # The ID of the resource type. Valid values:
        # 
        # *   If you set the ResourceType parameter to project, set this parameter to the value of ProjectIdentifier. You can call the [ListProjects](~~178393~~) operation to obtain the value of ProjectIdentifier.
        # *   If you set the ResourceType parameter to tenantresourcegroup, set this parameter to the value of ResourceGroupType. You can call the [ListResourceGroups](~~173913~~) operation to obtain the value of ResourceGroupType. Only the values 7, 8, and 9 are valid.
        self.resource_type = resource_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ChangeResourceManagerResourceGroupRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.resource_id is not None:
            result['ResourceId'] = self.resource_id
        if self.resource_manager_resource_group_id is not None:
            result['ResourceManagerResourceGroupId'] = self.resource_manager_resource_group_id
        if self.resource_type is not None:
            result['ResourceType'] = self.resource_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ResourceId') is not None:
            self.resource_id = m.get('ResourceId')
        if m.get('ResourceManagerResourceGroupId') is not None:
            self.resource_manager_resource_group_id = m.get('ResourceManagerResourceGroupId')
        if m.get('ResourceType') is not None:
            self.resource_type = m.get('ResourceType')
        return self


class ChangeResourceManagerResourceGroupResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.data = data  # type: bool
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.http_status_code = http_status_code  # type: int
        # The HTTP status code returned.
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(ChangeResourceManagerResourceGroupResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ChangeResourceManagerResourceGroupResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ChangeResourceManagerResourceGroupResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ChangeResourceManagerResourceGroupResponse, self).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=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 = ChangeResourceManagerResourceGroupResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CheckFileDeploymentRequest(TeaModel):
    def __init__(self, check_detail_url=None, checker_instance_id=None, status=None):
        # This parameter is deprecated.
        self.check_detail_url = check_detail_url  # type: str
        # The ID of the instance to which the file checker belongs. You can obtain the ID from the CheckerInstanceId parameter in the check event logs returned by DataWorks.
        self.checker_instance_id = checker_instance_id  # type: str
        # The check status of the file that you want to deploy. Valid values:
        # 
        # *   OK: The file passes the check.
        # *   WARN: The file passes the check, but an alert is reported.
        # *   FAIL: The file fails the check.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CheckFileDeploymentRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.check_detail_url is not None:
            result['CheckDetailUrl'] = self.check_detail_url
        if self.checker_instance_id is not None:
            result['CheckerInstanceId'] = self.checker_instance_id
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CheckDetailUrl') is not None:
            self.check_detail_url = m.get('CheckDetailUrl')
        if m.get('CheckerInstanceId') is not None:
            self.checker_instance_id = m.get('CheckerInstanceId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class CheckFileDeploymentResponseBody(TeaModel):
    def __init__(self, request_id=None):
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CheckFileDeploymentResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CheckFileDeploymentResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CheckFileDeploymentResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CheckFileDeploymentResponse, self).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=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 = CheckFileDeploymentResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CheckMetaPartitionRequest(TeaModel):
    def __init__(self, cluster_id=None, data_source_type=None, database_name=None, partition=None, table_guid=None,
                 table_name=None):
        # The name of the table.
        self.cluster_id = cluster_id  # type: str
        # Indicates whether the partition exists.
        self.data_source_type = data_source_type  # type: str
        # The type of the data source. Valid values: odps and emr.
        self.database_name = database_name  # type: str
        # The name of the database.
        self.partition = partition  # type: str
        # The ID of the E-MapReduce (EMR) cluster.
        self.table_guid = table_guid  # type: str
        # The HTTP status code.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CheckMetaPartitionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.partition is not None:
            result['Partition'] = self.partition
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('Partition') is not None:
            self.partition = m.get('Partition')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class CheckMetaPartitionResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The error message.
        self.data = data  # type: bool
        self.error_code = error_code  # type: str
        # Indicates whether the request is successful.
        self.error_message = error_message  # type: str
        # The ID of the request.
        self.http_status_code = http_status_code  # type: int
        # The error code.
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CheckMetaPartitionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CheckMetaPartitionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CheckMetaPartitionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CheckMetaPartitionResponse, self).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=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 = CheckMetaPartitionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CheckMetaTableRequest(TeaModel):
    def __init__(self, cluster_id=None, data_source_type=None, database_name=None, table_guid=None, table_name=None):
        # The name of the EMR table.
        self.cluster_id = cluster_id  # type: str
        # The ID of the request.
        self.data_source_type = data_source_type  # type: str
        # The type of the data source. Valid values: odps and emr.
        self.database_name = database_name  # type: str
        # The name of the EMR database.
        self.table_guid = table_guid  # type: str
        # Indicates whether the table exists.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CheckMetaTableRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class CheckMetaTableResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None):
        self.data = data  # type: bool
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CheckMetaTableResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CheckMetaTableResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CheckMetaTableResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CheckMetaTableResponse, self).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=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 = CheckMetaTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateBaselineRequestOvertimeSettings(TeaModel):
    def __init__(self, cycle=None, time=None):
        self.cycle = cycle  # type: int
        self.time = time  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateBaselineRequestOvertimeSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cycle is not None:
            result['Cycle'] = self.cycle
        if self.time is not None:
            result['Time'] = self.time
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Cycle') is not None:
            self.cycle = m.get('Cycle')
        if m.get('Time') is not None:
            self.time = m.get('Time')
        return self


class CreateBaselineRequest(TeaModel):
    def __init__(self, alert_margin_threshold=None, baseline_name=None, baseline_type=None, node_ids=None,
                 overtime_settings=None, owner=None, priority=None, project_id=None):
        self.alert_margin_threshold = alert_margin_threshold  # type: int
        self.baseline_name = baseline_name  # type: str
        self.baseline_type = baseline_type  # type: str
        self.node_ids = node_ids  # type: str
        self.overtime_settings = overtime_settings  # type: list[CreateBaselineRequestOvertimeSettings]
        self.owner = owner  # type: str
        self.priority = priority  # type: int
        self.project_id = project_id  # type: long

    def validate(self):
        if self.overtime_settings:
            for k in self.overtime_settings:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(CreateBaselineRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_margin_threshold is not None:
            result['AlertMarginThreshold'] = self.alert_margin_threshold
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.baseline_type is not None:
            result['BaselineType'] = self.baseline_type
        if self.node_ids is not None:
            result['NodeIds'] = self.node_ids
        result['OvertimeSettings'] = []
        if self.overtime_settings is not None:
            for k in self.overtime_settings:
                result['OvertimeSettings'].append(k.to_map() if k else None)
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertMarginThreshold') is not None:
            self.alert_margin_threshold = m.get('AlertMarginThreshold')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('BaselineType') is not None:
            self.baseline_type = m.get('BaselineType')
        if m.get('NodeIds') is not None:
            self.node_ids = m.get('NodeIds')
        self.overtime_settings = []
        if m.get('OvertimeSettings') is not None:
            for k in m.get('OvertimeSettings'):
                temp_model = CreateBaselineRequestOvertimeSettings()
                self.overtime_settings.append(temp_model.from_map(k))
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class CreateBaselineResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: long
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateBaselineResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateBaselineResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateBaselineResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateBaselineResponse, self).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=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 = CreateBaselineResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateBusinessRequest(TeaModel):
    def __init__(self, business_name=None, description=None, owner=None, project_id=None, project_identifier=None,
                 use_type=None):
        self.business_name = business_name  # type: str
        self.description = description  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: long
        self.project_identifier = project_identifier  # type: str
        self.use_type = use_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateBusinessRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.business_name is not None:
            result['BusinessName'] = self.business_name
        if self.description is not None:
            result['Description'] = self.description
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.use_type is not None:
            result['UseType'] = self.use_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BusinessName') is not None:
            self.business_name = m.get('BusinessName')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('UseType') is not None:
            self.use_type = m.get('UseType')
        return self


class CreateBusinessResponseBody(TeaModel):
    def __init__(self, business_id=None, error_code=None, error_message=None, http_status_code=None,
                 request_id=None, success=None):
        self.business_id = business_id  # type: long
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateBusinessResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateBusinessResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateBusinessResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateBusinessResponse, self).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=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 = CreateBusinessResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateConnectionRequest(TeaModel):
    def __init__(self, connection_type=None, content=None, description=None, env_type=None, name=None,
                 project_id=None, sub_type=None):
        # The type of the connection string.
        self.connection_type = connection_type  # type: str
        # Details of the data source.
        self.content = content  # type: str
        # The description of the connection string.
        self.description = description  # type: str
        # Environment of the data source.
        self.env_type = env_type  # type: int
        # The name of the data source.
        self.name = name  # type: str
        # The ID of the workspace to be associated with the data source.
        self.project_id = project_id  # type: long
        # The sub-type of a connection string.
        self.sub_type = sub_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateConnectionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_type is not None:
            result['ConnectionType'] = self.connection_type
        if self.content is not None:
            result['Content'] = self.content
        if self.description is not None:
            result['Description'] = self.description
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.name is not None:
            result['Name'] = self.name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.sub_type is not None:
            result['SubType'] = self.sub_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionType') is not None:
            self.connection_type = m.get('ConnectionType')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SubType') is not None:
            self.sub_type = m.get('SubType')
        return self


class CreateConnectionResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        # The ID of the data source.
        self.data = data  # type: long
        # The HTTP status code.
        self.http_status_code = http_status_code  # type: str
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful. A value of true indicates that the request is successful. A value of false indicates that the request has failed.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateConnectionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateConnectionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateConnectionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateConnectionResponse, self).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=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 = CreateConnectionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateDIAlarmRuleRequestNotificationSettingsNotificationChannels(TeaModel):
    def __init__(self, channels=None, severity=None):
        self.channels = channels  # type: list[str]
        self.severity = severity  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIAlarmRuleRequestNotificationSettingsNotificationChannels, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.channels is not None:
            result['Channels'] = self.channels
        if self.severity is not None:
            result['Severity'] = self.severity
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Channels') is not None:
            self.channels = m.get('Channels')
        if m.get('Severity') is not None:
            self.severity = m.get('Severity')
        return self


class CreateDIAlarmRuleRequestNotificationSettingsNotificationReceivers(TeaModel):
    def __init__(self, receiver_type=None, receiver_values=None):
        self.receiver_type = receiver_type  # type: str
        self.receiver_values = receiver_values  # type: list[str]

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIAlarmRuleRequestNotificationSettingsNotificationReceivers, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.receiver_type is not None:
            result['ReceiverType'] = self.receiver_type
        if self.receiver_values is not None:
            result['ReceiverValues'] = self.receiver_values
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ReceiverType') is not None:
            self.receiver_type = m.get('ReceiverType')
        if m.get('ReceiverValues') is not None:
            self.receiver_values = m.get('ReceiverValues')
        return self


class CreateDIAlarmRuleRequestNotificationSettings(TeaModel):
    def __init__(self, inhibition_interval=None, notification_channels=None, notification_receivers=None):
        self.inhibition_interval = inhibition_interval  # type: int
        self.notification_channels = notification_channels  # type: list[CreateDIAlarmRuleRequestNotificationSettingsNotificationChannels]
        self.notification_receivers = notification_receivers  # type: list[CreateDIAlarmRuleRequestNotificationSettingsNotificationReceivers]

    def validate(self):
        if self.notification_channels:
            for k in self.notification_channels:
                if k:
                    k.validate()
        if self.notification_receivers:
            for k in self.notification_receivers:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(CreateDIAlarmRuleRequestNotificationSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.inhibition_interval is not None:
            result['InhibitionInterval'] = self.inhibition_interval
        result['NotificationChannels'] = []
        if self.notification_channels is not None:
            for k in self.notification_channels:
                result['NotificationChannels'].append(k.to_map() if k else None)
        result['NotificationReceivers'] = []
        if self.notification_receivers is not None:
            for k in self.notification_receivers:
                result['NotificationReceivers'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InhibitionInterval') is not None:
            self.inhibition_interval = m.get('InhibitionInterval')
        self.notification_channels = []
        if m.get('NotificationChannels') is not None:
            for k in m.get('NotificationChannels'):
                temp_model = CreateDIAlarmRuleRequestNotificationSettingsNotificationChannels()
                self.notification_channels.append(temp_model.from_map(k))
        self.notification_receivers = []
        if m.get('NotificationReceivers') is not None:
            for k in m.get('NotificationReceivers'):
                temp_model = CreateDIAlarmRuleRequestNotificationSettingsNotificationReceivers()
                self.notification_receivers.append(temp_model.from_map(k))
        return self


class CreateDIAlarmRuleRequestTriggerConditions(TeaModel):
    def __init__(self, duration=None, severity=None, threshold=None):
        self.duration = duration  # type: long
        self.severity = severity  # type: str
        self.threshold = threshold  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIAlarmRuleRequestTriggerConditions, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.duration is not None:
            result['Duration'] = self.duration
        if self.severity is not None:
            result['Severity'] = self.severity
        if self.threshold is not None:
            result['Threshold'] = self.threshold
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Duration') is not None:
            self.duration = m.get('Duration')
        if m.get('Severity') is not None:
            self.severity = m.get('Severity')
        if m.get('Threshold') is not None:
            self.threshold = m.get('Threshold')
        return self


class CreateDIAlarmRuleRequest(TeaModel):
    def __init__(self, dijob_id=None, description=None, enabled=None, metric_type=None, notification_settings=None,
                 trigger_conditions=None):
        self.dijob_id = dijob_id  # type: long
        self.description = description  # type: str
        self.enabled = enabled  # type: bool
        self.metric_type = metric_type  # type: str
        self.notification_settings = notification_settings  # type: CreateDIAlarmRuleRequestNotificationSettings
        self.trigger_conditions = trigger_conditions  # type: list[CreateDIAlarmRuleRequestTriggerConditions]

    def validate(self):
        if self.notification_settings:
            self.notification_settings.validate()
        if self.trigger_conditions:
            for k in self.trigger_conditions:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(CreateDIAlarmRuleRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.description is not None:
            result['Description'] = self.description
        if self.enabled is not None:
            result['Enabled'] = self.enabled
        if self.metric_type is not None:
            result['MetricType'] = self.metric_type
        if self.notification_settings is not None:
            result['NotificationSettings'] = self.notification_settings.to_map()
        result['TriggerConditions'] = []
        if self.trigger_conditions is not None:
            for k in self.trigger_conditions:
                result['TriggerConditions'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Enabled') is not None:
            self.enabled = m.get('Enabled')
        if m.get('MetricType') is not None:
            self.metric_type = m.get('MetricType')
        if m.get('NotificationSettings') is not None:
            temp_model = CreateDIAlarmRuleRequestNotificationSettings()
            self.notification_settings = temp_model.from_map(m['NotificationSettings'])
        self.trigger_conditions = []
        if m.get('TriggerConditions') is not None:
            for k in m.get('TriggerConditions'):
                temp_model = CreateDIAlarmRuleRequestTriggerConditions()
                self.trigger_conditions.append(temp_model.from_map(k))
        return self


class CreateDIAlarmRuleShrinkRequest(TeaModel):
    def __init__(self, dijob_id=None, description=None, enabled=None, metric_type=None,
                 notification_settings_shrink=None, trigger_conditions_shrink=None):
        self.dijob_id = dijob_id  # type: long
        self.description = description  # type: str
        self.enabled = enabled  # type: bool
        self.metric_type = metric_type  # type: str
        self.notification_settings_shrink = notification_settings_shrink  # type: str
        self.trigger_conditions_shrink = trigger_conditions_shrink  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIAlarmRuleShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.description is not None:
            result['Description'] = self.description
        if self.enabled is not None:
            result['Enabled'] = self.enabled
        if self.metric_type is not None:
            result['MetricType'] = self.metric_type
        if self.notification_settings_shrink is not None:
            result['NotificationSettings'] = self.notification_settings_shrink
        if self.trigger_conditions_shrink is not None:
            result['TriggerConditions'] = self.trigger_conditions_shrink
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Enabled') is not None:
            self.enabled = m.get('Enabled')
        if m.get('MetricType') is not None:
            self.metric_type = m.get('MetricType')
        if m.get('NotificationSettings') is not None:
            self.notification_settings_shrink = m.get('NotificationSettings')
        if m.get('TriggerConditions') is not None:
            self.trigger_conditions_shrink = m.get('TriggerConditions')
        return self


class CreateDIAlarmRuleResponseBody(TeaModel):
    def __init__(self, dialarm_rule_id=None, request_id=None):
        self.dialarm_rule_id = dialarm_rule_id  # type: long
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIAlarmRuleResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dialarm_rule_id is not None:
            result['DIAlarmRuleId'] = self.dialarm_rule_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIAlarmRuleId') is not None:
            self.dialarm_rule_id = m.get('DIAlarmRuleId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CreateDIAlarmRuleResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateDIAlarmRuleResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateDIAlarmRuleResponse, self).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=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 = CreateDIAlarmRuleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateDIJobRequestDestinationDataSourceSettings(TeaModel):
    def __init__(self, data_source_name=None, data_source_properties=None):
        self.data_source_name = data_source_name  # type: str
        self.data_source_properties = data_source_properties  # type: dict[str, str]

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobRequestDestinationDataSourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data_source_name is not None:
            result['DataSourceName'] = self.data_source_name
        if self.data_source_properties is not None:
            result['DataSourceProperties'] = self.data_source_properties
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DataSourceName') is not None:
            self.data_source_name = m.get('DataSourceName')
        if m.get('DataSourceProperties') is not None:
            self.data_source_properties = m.get('DataSourceProperties')
        return self


class CreateDIJobRequestJobSettingsColumnDataTypeSettings(TeaModel):
    def __init__(self, destination_data_type=None, source_data_type=None):
        self.destination_data_type = destination_data_type  # type: str
        self.source_data_type = source_data_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobRequestJobSettingsColumnDataTypeSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.destination_data_type is not None:
            result['DestinationDataType'] = self.destination_data_type
        if self.source_data_type is not None:
            result['SourceDataType'] = self.source_data_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DestinationDataType') is not None:
            self.destination_data_type = m.get('DestinationDataType')
        if m.get('SourceDataType') is not None:
            self.source_data_type = m.get('SourceDataType')
        return self


class CreateDIJobRequestJobSettingsDdlHandlingSettings(TeaModel):
    def __init__(self, action=None, type=None):
        self.action = action  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobRequestJobSettingsDdlHandlingSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.action is not None:
            result['Action'] = self.action
        if self.type is not None:
            result['Type'] = self.type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Action') is not None:
            self.action = m.get('Action')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class CreateDIJobRequestJobSettingsRuntimeSettings(TeaModel):
    def __init__(self, name=None, value=None):
        self.name = name  # type: str
        self.value = value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobRequestJobSettingsRuntimeSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.name is not None:
            result['Name'] = self.name
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class CreateDIJobRequestJobSettings(TeaModel):
    def __init__(self, column_data_type_settings=None, ddl_handling_settings=None, runtime_settings=None):
        self.column_data_type_settings = column_data_type_settings  # type: list[CreateDIJobRequestJobSettingsColumnDataTypeSettings]
        self.ddl_handling_settings = ddl_handling_settings  # type: list[CreateDIJobRequestJobSettingsDdlHandlingSettings]
        self.runtime_settings = runtime_settings  # type: list[CreateDIJobRequestJobSettingsRuntimeSettings]

    def validate(self):
        if self.column_data_type_settings:
            for k in self.column_data_type_settings:
                if k:
                    k.validate()
        if self.ddl_handling_settings:
            for k in self.ddl_handling_settings:
                if k:
                    k.validate()
        if self.runtime_settings:
            for k in self.runtime_settings:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(CreateDIJobRequestJobSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ColumnDataTypeSettings'] = []
        if self.column_data_type_settings is not None:
            for k in self.column_data_type_settings:
                result['ColumnDataTypeSettings'].append(k.to_map() if k else None)
        result['DdlHandlingSettings'] = []
        if self.ddl_handling_settings is not None:
            for k in self.ddl_handling_settings:
                result['DdlHandlingSettings'].append(k.to_map() if k else None)
        result['RuntimeSettings'] = []
        if self.runtime_settings is not None:
            for k in self.runtime_settings:
                result['RuntimeSettings'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.column_data_type_settings = []
        if m.get('ColumnDataTypeSettings') is not None:
            for k in m.get('ColumnDataTypeSettings'):
                temp_model = CreateDIJobRequestJobSettingsColumnDataTypeSettings()
                self.column_data_type_settings.append(temp_model.from_map(k))
        self.ddl_handling_settings = []
        if m.get('DdlHandlingSettings') is not None:
            for k in m.get('DdlHandlingSettings'):
                temp_model = CreateDIJobRequestJobSettingsDdlHandlingSettings()
                self.ddl_handling_settings.append(temp_model.from_map(k))
        self.runtime_settings = []
        if m.get('RuntimeSettings') is not None:
            for k in m.get('RuntimeSettings'):
                temp_model = CreateDIJobRequestJobSettingsRuntimeSettings()
                self.runtime_settings.append(temp_model.from_map(k))
        return self


class CreateDIJobRequestResourceSettingsOfflineResourceSettings(TeaModel):
    def __init__(self, resource_group_identifier=None):
        self.resource_group_identifier = resource_group_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobRequestResourceSettingsOfflineResourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.resource_group_identifier is not None:
            result['ResourceGroupIdentifier'] = self.resource_group_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ResourceGroupIdentifier') is not None:
            self.resource_group_identifier = m.get('ResourceGroupIdentifier')
        return self


class CreateDIJobRequestResourceSettingsRealtimeResourceSettings(TeaModel):
    def __init__(self, resource_group_identifier=None):
        self.resource_group_identifier = resource_group_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobRequestResourceSettingsRealtimeResourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.resource_group_identifier is not None:
            result['ResourceGroupIdentifier'] = self.resource_group_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ResourceGroupIdentifier') is not None:
            self.resource_group_identifier = m.get('ResourceGroupIdentifier')
        return self


class CreateDIJobRequestResourceSettings(TeaModel):
    def __init__(self, offline_resource_settings=None, realtime_resource_settings=None):
        self.offline_resource_settings = offline_resource_settings  # type: CreateDIJobRequestResourceSettingsOfflineResourceSettings
        self.realtime_resource_settings = realtime_resource_settings  # type: CreateDIJobRequestResourceSettingsRealtimeResourceSettings

    def validate(self):
        if self.offline_resource_settings:
            self.offline_resource_settings.validate()
        if self.realtime_resource_settings:
            self.realtime_resource_settings.validate()

    def to_map(self):
        _map = super(CreateDIJobRequestResourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.offline_resource_settings is not None:
            result['OfflineResourceSettings'] = self.offline_resource_settings.to_map()
        if self.realtime_resource_settings is not None:
            result['RealtimeResourceSettings'] = self.realtime_resource_settings.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('OfflineResourceSettings') is not None:
            temp_model = CreateDIJobRequestResourceSettingsOfflineResourceSettings()
            self.offline_resource_settings = temp_model.from_map(m['OfflineResourceSettings'])
        if m.get('RealtimeResourceSettings') is not None:
            temp_model = CreateDIJobRequestResourceSettingsRealtimeResourceSettings()
            self.realtime_resource_settings = temp_model.from_map(m['RealtimeResourceSettings'])
        return self


class CreateDIJobRequestSourceDataSourceSettings(TeaModel):
    def __init__(self, data_source_name=None, data_source_properties=None):
        self.data_source_name = data_source_name  # type: str
        self.data_source_properties = data_source_properties  # type: dict[str, str]

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobRequestSourceDataSourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data_source_name is not None:
            result['DataSourceName'] = self.data_source_name
        if self.data_source_properties is not None:
            result['DataSourceProperties'] = self.data_source_properties
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DataSourceName') is not None:
            self.data_source_name = m.get('DataSourceName')
        if m.get('DataSourceProperties') is not None:
            self.data_source_properties = m.get('DataSourceProperties')
        return self


class CreateDIJobRequestTableMappingsSourceObjectSelectionRules(TeaModel):
    def __init__(self, expression=None, object_type=None):
        self.expression = expression  # type: str
        self.object_type = object_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobRequestTableMappingsSourceObjectSelectionRules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.expression is not None:
            result['Expression'] = self.expression
        if self.object_type is not None:
            result['ObjectType'] = self.object_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Expression') is not None:
            self.expression = m.get('Expression')
        if m.get('ObjectType') is not None:
            self.object_type = m.get('ObjectType')
        return self


class CreateDIJobRequestTableMappingsTransformationRules(TeaModel):
    def __init__(self, rule_action_type=None, rule_name=None, rule_target_type=None):
        self.rule_action_type = rule_action_type  # type: str
        self.rule_name = rule_name  # type: str
        self.rule_target_type = rule_target_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobRequestTableMappingsTransformationRules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.rule_action_type is not None:
            result['RuleActionType'] = self.rule_action_type
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        if self.rule_target_type is not None:
            result['RuleTargetType'] = self.rule_target_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RuleActionType') is not None:
            self.rule_action_type = m.get('RuleActionType')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        if m.get('RuleTargetType') is not None:
            self.rule_target_type = m.get('RuleTargetType')
        return self


class CreateDIJobRequestTableMappings(TeaModel):
    def __init__(self, source_object_selection_rules=None, transformation_rules=None):
        self.source_object_selection_rules = source_object_selection_rules  # type: list[CreateDIJobRequestTableMappingsSourceObjectSelectionRules]
        self.transformation_rules = transformation_rules  # type: list[CreateDIJobRequestTableMappingsTransformationRules]

    def validate(self):
        if self.source_object_selection_rules:
            for k in self.source_object_selection_rules:
                if k:
                    k.validate()
        if self.transformation_rules:
            for k in self.transformation_rules:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(CreateDIJobRequestTableMappings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['SourceObjectSelectionRules'] = []
        if self.source_object_selection_rules is not None:
            for k in self.source_object_selection_rules:
                result['SourceObjectSelectionRules'].append(k.to_map() if k else None)
        result['TransformationRules'] = []
        if self.transformation_rules is not None:
            for k in self.transformation_rules:
                result['TransformationRules'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.source_object_selection_rules = []
        if m.get('SourceObjectSelectionRules') is not None:
            for k in m.get('SourceObjectSelectionRules'):
                temp_model = CreateDIJobRequestTableMappingsSourceObjectSelectionRules()
                self.source_object_selection_rules.append(temp_model.from_map(k))
        self.transformation_rules = []
        if m.get('TransformationRules') is not None:
            for k in m.get('TransformationRules'):
                temp_model = CreateDIJobRequestTableMappingsTransformationRules()
                self.transformation_rules.append(temp_model.from_map(k))
        return self


class CreateDIJobRequestTransformationRules(TeaModel):
    def __init__(self, rule_action_type=None, rule_expression=None, rule_name=None, rule_target_type=None):
        self.rule_action_type = rule_action_type  # type: str
        self.rule_expression = rule_expression  # type: str
        self.rule_name = rule_name  # type: str
        self.rule_target_type = rule_target_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobRequestTransformationRules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.rule_action_type is not None:
            result['RuleActionType'] = self.rule_action_type
        if self.rule_expression is not None:
            result['RuleExpression'] = self.rule_expression
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        if self.rule_target_type is not None:
            result['RuleTargetType'] = self.rule_target_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RuleActionType') is not None:
            self.rule_action_type = m.get('RuleActionType')
        if m.get('RuleExpression') is not None:
            self.rule_expression = m.get('RuleExpression')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        if m.get('RuleTargetType') is not None:
            self.rule_target_type = m.get('RuleTargetType')
        return self


class CreateDIJobRequest(TeaModel):
    def __init__(self, description=None, destination_data_source_settings=None, destination_data_source_type=None,
                 job_name=None, job_settings=None, migration_type=None, project_id=None, resource_settings=None,
                 source_data_source_settings=None, source_data_source_type=None, system_debug=None, table_mappings=None,
                 transformation_rules=None):
        self.description = description  # type: str
        self.destination_data_source_settings = destination_data_source_settings  # type: list[CreateDIJobRequestDestinationDataSourceSettings]
        self.destination_data_source_type = destination_data_source_type  # type: str
        self.job_name = job_name  # type: str
        self.job_settings = job_settings  # type: CreateDIJobRequestJobSettings
        self.migration_type = migration_type  # type: str
        self.project_id = project_id  # type: long
        self.resource_settings = resource_settings  # type: CreateDIJobRequestResourceSettings
        self.source_data_source_settings = source_data_source_settings  # type: list[CreateDIJobRequestSourceDataSourceSettings]
        self.source_data_source_type = source_data_source_type  # type: str
        self.system_debug = system_debug  # type: str
        self.table_mappings = table_mappings  # type: list[CreateDIJobRequestTableMappings]
        self.transformation_rules = transformation_rules  # type: list[CreateDIJobRequestTransformationRules]

    def validate(self):
        if self.destination_data_source_settings:
            for k in self.destination_data_source_settings:
                if k:
                    k.validate()
        if self.job_settings:
            self.job_settings.validate()
        if self.resource_settings:
            self.resource_settings.validate()
        if self.source_data_source_settings:
            for k in self.source_data_source_settings:
                if k:
                    k.validate()
        if self.table_mappings:
            for k in self.table_mappings:
                if k:
                    k.validate()
        if self.transformation_rules:
            for k in self.transformation_rules:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(CreateDIJobRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        result['DestinationDataSourceSettings'] = []
        if self.destination_data_source_settings is not None:
            for k in self.destination_data_source_settings:
                result['DestinationDataSourceSettings'].append(k.to_map() if k else None)
        if self.destination_data_source_type is not None:
            result['DestinationDataSourceType'] = self.destination_data_source_type
        if self.job_name is not None:
            result['JobName'] = self.job_name
        if self.job_settings is not None:
            result['JobSettings'] = self.job_settings.to_map()
        if self.migration_type is not None:
            result['MigrationType'] = self.migration_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.resource_settings is not None:
            result['ResourceSettings'] = self.resource_settings.to_map()
        result['SourceDataSourceSettings'] = []
        if self.source_data_source_settings is not None:
            for k in self.source_data_source_settings:
                result['SourceDataSourceSettings'].append(k.to_map() if k else None)
        if self.source_data_source_type is not None:
            result['SourceDataSourceType'] = self.source_data_source_type
        if self.system_debug is not None:
            result['SystemDebug'] = self.system_debug
        result['TableMappings'] = []
        if self.table_mappings is not None:
            for k in self.table_mappings:
                result['TableMappings'].append(k.to_map() if k else None)
        result['TransformationRules'] = []
        if self.transformation_rules is not None:
            for k in self.transformation_rules:
                result['TransformationRules'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Description') is not None:
            self.description = m.get('Description')
        self.destination_data_source_settings = []
        if m.get('DestinationDataSourceSettings') is not None:
            for k in m.get('DestinationDataSourceSettings'):
                temp_model = CreateDIJobRequestDestinationDataSourceSettings()
                self.destination_data_source_settings.append(temp_model.from_map(k))
        if m.get('DestinationDataSourceType') is not None:
            self.destination_data_source_type = m.get('DestinationDataSourceType')
        if m.get('JobName') is not None:
            self.job_name = m.get('JobName')
        if m.get('JobSettings') is not None:
            temp_model = CreateDIJobRequestJobSettings()
            self.job_settings = temp_model.from_map(m['JobSettings'])
        if m.get('MigrationType') is not None:
            self.migration_type = m.get('MigrationType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ResourceSettings') is not None:
            temp_model = CreateDIJobRequestResourceSettings()
            self.resource_settings = temp_model.from_map(m['ResourceSettings'])
        self.source_data_source_settings = []
        if m.get('SourceDataSourceSettings') is not None:
            for k in m.get('SourceDataSourceSettings'):
                temp_model = CreateDIJobRequestSourceDataSourceSettings()
                self.source_data_source_settings.append(temp_model.from_map(k))
        if m.get('SourceDataSourceType') is not None:
            self.source_data_source_type = m.get('SourceDataSourceType')
        if m.get('SystemDebug') is not None:
            self.system_debug = m.get('SystemDebug')
        self.table_mappings = []
        if m.get('TableMappings') is not None:
            for k in m.get('TableMappings'):
                temp_model = CreateDIJobRequestTableMappings()
                self.table_mappings.append(temp_model.from_map(k))
        self.transformation_rules = []
        if m.get('TransformationRules') is not None:
            for k in m.get('TransformationRules'):
                temp_model = CreateDIJobRequestTransformationRules()
                self.transformation_rules.append(temp_model.from_map(k))
        return self


class CreateDIJobShrinkRequest(TeaModel):
    def __init__(self, description=None, destination_data_source_settings_shrink=None,
                 destination_data_source_type=None, job_name=None, job_settings_shrink=None, migration_type=None, project_id=None,
                 resource_settings_shrink=None, source_data_source_settings_shrink=None, source_data_source_type=None, system_debug=None,
                 table_mappings_shrink=None, transformation_rules_shrink=None):
        self.description = description  # type: str
        self.destination_data_source_settings_shrink = destination_data_source_settings_shrink  # type: str
        self.destination_data_source_type = destination_data_source_type  # type: str
        self.job_name = job_name  # type: str
        self.job_settings_shrink = job_settings_shrink  # type: str
        self.migration_type = migration_type  # type: str
        self.project_id = project_id  # type: long
        self.resource_settings_shrink = resource_settings_shrink  # type: str
        self.source_data_source_settings_shrink = source_data_source_settings_shrink  # type: str
        self.source_data_source_type = source_data_source_type  # type: str
        self.system_debug = system_debug  # type: str
        self.table_mappings_shrink = table_mappings_shrink  # type: str
        self.transformation_rules_shrink = transformation_rules_shrink  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        if self.destination_data_source_settings_shrink is not None:
            result['DestinationDataSourceSettings'] = self.destination_data_source_settings_shrink
        if self.destination_data_source_type is not None:
            result['DestinationDataSourceType'] = self.destination_data_source_type
        if self.job_name is not None:
            result['JobName'] = self.job_name
        if self.job_settings_shrink is not None:
            result['JobSettings'] = self.job_settings_shrink
        if self.migration_type is not None:
            result['MigrationType'] = self.migration_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.resource_settings_shrink is not None:
            result['ResourceSettings'] = self.resource_settings_shrink
        if self.source_data_source_settings_shrink is not None:
            result['SourceDataSourceSettings'] = self.source_data_source_settings_shrink
        if self.source_data_source_type is not None:
            result['SourceDataSourceType'] = self.source_data_source_type
        if self.system_debug is not None:
            result['SystemDebug'] = self.system_debug
        if self.table_mappings_shrink is not None:
            result['TableMappings'] = self.table_mappings_shrink
        if self.transformation_rules_shrink is not None:
            result['TransformationRules'] = self.transformation_rules_shrink
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('DestinationDataSourceSettings') is not None:
            self.destination_data_source_settings_shrink = m.get('DestinationDataSourceSettings')
        if m.get('DestinationDataSourceType') is not None:
            self.destination_data_source_type = m.get('DestinationDataSourceType')
        if m.get('JobName') is not None:
            self.job_name = m.get('JobName')
        if m.get('JobSettings') is not None:
            self.job_settings_shrink = m.get('JobSettings')
        if m.get('MigrationType') is not None:
            self.migration_type = m.get('MigrationType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ResourceSettings') is not None:
            self.resource_settings_shrink = m.get('ResourceSettings')
        if m.get('SourceDataSourceSettings') is not None:
            self.source_data_source_settings_shrink = m.get('SourceDataSourceSettings')
        if m.get('SourceDataSourceType') is not None:
            self.source_data_source_type = m.get('SourceDataSourceType')
        if m.get('SystemDebug') is not None:
            self.system_debug = m.get('SystemDebug')
        if m.get('TableMappings') is not None:
            self.table_mappings_shrink = m.get('TableMappings')
        if m.get('TransformationRules') is not None:
            self.transformation_rules_shrink = m.get('TransformationRules')
        return self


class CreateDIJobResponseBody(TeaModel):
    def __init__(self, dijob_id=None, request_id=None):
        self.dijob_id = dijob_id  # type: long
        # Id of the request
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDIJobResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CreateDIJobResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateDIJobResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateDIJobResponse, self).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=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 = CreateDIJobResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateDISyncTaskRequest(TeaModel):
    def __init__(self, client_token=None, project_id=None, task_content=None, task_name=None, task_param=None,
                 task_type=None):
        self.client_token = client_token  # type: str
        self.project_id = project_id  # type: long
        self.task_content = task_content  # type: str
        self.task_name = task_name  # type: str
        self.task_param = task_param  # type: str
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDISyncTaskRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.client_token is not None:
            result['ClientToken'] = self.client_token
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.task_content is not None:
            result['TaskContent'] = self.task_content
        if self.task_name is not None:
            result['TaskName'] = self.task_name
        if self.task_param is not None:
            result['TaskParam'] = self.task_param
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClientToken') is not None:
            self.client_token = m.get('ClientToken')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TaskContent') is not None:
            self.task_content = m.get('TaskContent')
        if m.get('TaskName') is not None:
            self.task_name = m.get('TaskName')
        if m.get('TaskParam') is not None:
            self.task_param = m.get('TaskParam')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class CreateDISyncTaskResponseBodyData(TeaModel):
    def __init__(self, file_id=None, message=None, status=None):
        self.file_id = file_id  # type: long
        self.message = message  # type: str
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDISyncTaskResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.message is not None:
            result['Message'] = self.message
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class CreateDISyncTaskResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        self.data = data  # type: CreateDISyncTaskResponseBodyData
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(CreateDISyncTaskResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = CreateDISyncTaskResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateDISyncTaskResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateDISyncTaskResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateDISyncTaskResponse, self).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=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 = CreateDISyncTaskResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateDagComplementRequest(TeaModel):
    def __init__(self, biz_begin_time=None, biz_end_time=None, end_biz_date=None, exclude_node_ids=None,
                 include_node_ids=None, name=None, node_params=None, parallelism=None, project_env=None, root_node_id=None,
                 start_biz_date=None):
        self.biz_begin_time = biz_begin_time  # type: str
        self.biz_end_time = biz_end_time  # type: str
        self.end_biz_date = end_biz_date  # type: str
        self.exclude_node_ids = exclude_node_ids  # type: str
        self.include_node_ids = include_node_ids  # type: str
        self.name = name  # type: str
        self.node_params = node_params  # type: str
        self.parallelism = parallelism  # type: bool
        self.project_env = project_env  # type: str
        self.root_node_id = root_node_id  # type: long
        self.start_biz_date = start_biz_date  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDagComplementRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_begin_time is not None:
            result['BizBeginTime'] = self.biz_begin_time
        if self.biz_end_time is not None:
            result['BizEndTime'] = self.biz_end_time
        if self.end_biz_date is not None:
            result['EndBizDate'] = self.end_biz_date
        if self.exclude_node_ids is not None:
            result['ExcludeNodeIds'] = self.exclude_node_ids
        if self.include_node_ids is not None:
            result['IncludeNodeIds'] = self.include_node_ids
        if self.name is not None:
            result['Name'] = self.name
        if self.node_params is not None:
            result['NodeParams'] = self.node_params
        if self.parallelism is not None:
            result['Parallelism'] = self.parallelism
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.root_node_id is not None:
            result['RootNodeId'] = self.root_node_id
        if self.start_biz_date is not None:
            result['StartBizDate'] = self.start_biz_date
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizBeginTime') is not None:
            self.biz_begin_time = m.get('BizBeginTime')
        if m.get('BizEndTime') is not None:
            self.biz_end_time = m.get('BizEndTime')
        if m.get('EndBizDate') is not None:
            self.end_biz_date = m.get('EndBizDate')
        if m.get('ExcludeNodeIds') is not None:
            self.exclude_node_ids = m.get('ExcludeNodeIds')
        if m.get('IncludeNodeIds') is not None:
            self.include_node_ids = m.get('IncludeNodeIds')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('NodeParams') is not None:
            self.node_params = m.get('NodeParams')
        if m.get('Parallelism') is not None:
            self.parallelism = m.get('Parallelism')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('RootNodeId') is not None:
            self.root_node_id = m.get('RootNodeId')
        if m.get('StartBizDate') is not None:
            self.start_biz_date = m.get('StartBizDate')
        return self


class CreateDagComplementResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: list[long]
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDagComplementResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateDagComplementResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateDagComplementResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateDagComplementResponse, self).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=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 = CreateDagComplementResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateDagTestRequest(TeaModel):
    def __init__(self, bizdate=None, name=None, node_id=None, node_params=None, project_env=None):
        self.bizdate = bizdate  # type: str
        self.name = name  # type: str
        self.node_id = node_id  # type: long
        self.node_params = node_params  # type: str
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDagTestRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.name is not None:
            result['Name'] = self.name
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_params is not None:
            result['NodeParams'] = self.node_params
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeParams') is not None:
            self.node_params = m.get('NodeParams')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class CreateDagTestResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: long
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDagTestResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateDagTestResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateDagTestResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateDagTestResponse, self).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=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 = CreateDagTestResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateDataServiceApiRequest(TeaModel):
    def __init__(self, api_description=None, api_mode=None, api_name=None, api_path=None, folder_id=None,
                 group_id=None, project_id=None, protocols=None, registration_details=None, request_content_type=None,
                 request_method=None, resource_group_id=None, response_content_type=None, script_details=None, sql_mode=None,
                 tenant_id=None, timeout=None, visible_range=None, wizard_details=None):
        # The HTTP status code.
        self.api_description = api_description  # type: str
        # The format in which the response of the API request is returned. Valid values: 0 and 1. The value 0 indicates the JSON format. The value 1 indicates the XML format. APIs generated in wizard or script mode support the JSON format. APIs generated by registration support the JSON and XML formats.
        self.api_mode = api_mode  # type: int
        # The type of the API. Valid values: 0, 1, and 2. The value 0 indicates that the API is generated in wizard mode. The value 1 indicates that the API is generated in script mode. The value 2 indicates that the API is generated by registration.
        self.api_name = api_name  # type: str
        # The ID of the folder used to store the API. The ID of the root folder in a business process is 0. The ID of the folder created by a user must be greater than 0.
        self.api_path = api_path  # type: str
        # The ID of the API.
        self.folder_id = folder_id  # type: long
        # The request method of the API. Valid values: 0, 1, 2, and 3. The value 0 indicates the GET method. The value 1 indicates the POST method. The value 2 indicates the PUT method. The value 3 indicates the DELETE method. APIs generated in wizard or script mode support the GET and POST methods. APIs generated by registration support the GET, POST, PUT, and DELETE methods.
        self.group_id = group_id  # type: str
        # The ID of the business process.
        self.project_id = project_id  # type: long
        # The details of the API generated in script mode. For more information, see the ScriptDetails parameter returned by the [GetDataServiceApi](~~174013~~) operation.
        self.protocols = protocols  # type: str
        # The description of the API.
        self.registration_details = registration_details  # type: str
        self.request_content_type = request_content_type  # type: int
        # The timeout period of the API request. Unit: milliseconds. Valid values: (0,30000].
        self.request_method = request_method  # type: int
        self.resource_group_id = resource_group_id  # type: long
        # The scope in which the API is visible. Valid values:
        # 
        # *   0: The API is visible to all members in the workspace.
        # *   1: The API is visible only to its owner, and permissions on the API cannot be granted to other members.
        self.response_content_type = response_content_type  # type: int
        # The path of the API. The path cannot exceed 200 characters in length. The path can contain letters, digits, underscores (\_), and hyphens (-) and must start with a forward slash (/).
        self.script_details = script_details  # type: str
        self.sql_mode = sql_mode  # type: long
        # The name of the API. The name must be 4 to 50 characters in length. The name can contain letters, digits, and underscores (\_) and must start with a letter.
        self.tenant_id = tenant_id  # type: long
        # The protocol used by the API. Valid values: 0 and 1. The value 0 indicates HTTP. The value 1 indicates HTTPS. You can specify multiple protocols. Separate them with commas (,).
        self.timeout = timeout  # type: int
        # The details of the API generated in wizard mode. For more information, see the WizardDetails parameter returned by the [GetDataServiceApi](~~174013~~) operation.
        self.visible_range = visible_range  # type: int
        # The details of the API generated by registration. For more information, see the RegistrationDetails parameter returned by the [GetDataServiceApi](~~174013~~) operation.
        self.wizard_details = wizard_details  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDataServiceApiRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_description is not None:
            result['ApiDescription'] = self.api_description
        if self.api_mode is not None:
            result['ApiMode'] = self.api_mode
        if self.api_name is not None:
            result['ApiName'] = self.api_name
        if self.api_path is not None:
            result['ApiPath'] = self.api_path
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.protocols is not None:
            result['Protocols'] = self.protocols
        if self.registration_details is not None:
            result['RegistrationDetails'] = self.registration_details
        if self.request_content_type is not None:
            result['RequestContentType'] = self.request_content_type
        if self.request_method is not None:
            result['RequestMethod'] = self.request_method
        if self.resource_group_id is not None:
            result['ResourceGroupId'] = self.resource_group_id
        if self.response_content_type is not None:
            result['ResponseContentType'] = self.response_content_type
        if self.script_details is not None:
            result['ScriptDetails'] = self.script_details
        if self.sql_mode is not None:
            result['SqlMode'] = self.sql_mode
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.timeout is not None:
            result['Timeout'] = self.timeout
        if self.visible_range is not None:
            result['VisibleRange'] = self.visible_range
        if self.wizard_details is not None:
            result['WizardDetails'] = self.wizard_details
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiDescription') is not None:
            self.api_description = m.get('ApiDescription')
        if m.get('ApiMode') is not None:
            self.api_mode = m.get('ApiMode')
        if m.get('ApiName') is not None:
            self.api_name = m.get('ApiName')
        if m.get('ApiPath') is not None:
            self.api_path = m.get('ApiPath')
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Protocols') is not None:
            self.protocols = m.get('Protocols')
        if m.get('RegistrationDetails') is not None:
            self.registration_details = m.get('RegistrationDetails')
        if m.get('RequestContentType') is not None:
            self.request_content_type = m.get('RequestContentType')
        if m.get('RequestMethod') is not None:
            self.request_method = m.get('RequestMethod')
        if m.get('ResourceGroupId') is not None:
            self.resource_group_id = m.get('ResourceGroupId')
        if m.get('ResponseContentType') is not None:
            self.response_content_type = m.get('ResponseContentType')
        if m.get('ScriptDetails') is not None:
            self.script_details = m.get('ScriptDetails')
        if m.get('SqlMode') is not None:
            self.sql_mode = m.get('SqlMode')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('Timeout') is not None:
            self.timeout = m.get('Timeout')
        if m.get('VisibleRange') is not None:
            self.visible_range = m.get('VisibleRange')
        if m.get('WizardDetails') is not None:
            self.wizard_details = m.get('WizardDetails')
        return self


class CreateDataServiceApiResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the request.
        self.data = data  # type: long
        self.error_code = error_code  # type: str
        # The error code.
        self.error_message = error_message  # type: str
        # The error message.
        self.http_status_code = http_status_code  # type: int
        # Indicates whether the request is successful.
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDataServiceApiResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateDataServiceApiResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateDataServiceApiResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateDataServiceApiResponse, self).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=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 = CreateDataServiceApiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateDataServiceApiAuthorityRequest(TeaModel):
    def __init__(self, api_id=None, authorized_project_id=None, end_time=None, project_id=None, tenant_id=None):
        # The ID of the API.
        self.api_id = api_id  # type: long
        # The ID of the workspace to which the access permissions on the API are granted.
        self.authorized_project_id = authorized_project_id  # type: long
        # The end time of the validity period of the access permissions. The time must be a UNIX timestamp. Unit: seconds. Example: 1600531564, which indicates 2020-09-20 00:06:04 (UTC+8).
        self.end_time = end_time  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDataServiceApiAuthorityRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.authorized_project_id is not None:
            result['AuthorizedProjectId'] = self.authorized_project_id
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('AuthorizedProjectId') is not None:
            self.authorized_project_id = m.get('AuthorizedProjectId')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class CreateDataServiceApiAuthorityResponseBody(TeaModel):
    def __init__(self, request_id=None, success=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the authorization was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDataServiceApiAuthorityResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateDataServiceApiAuthorityResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateDataServiceApiAuthorityResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateDataServiceApiAuthorityResponse, self).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=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 = CreateDataServiceApiAuthorityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateDataServiceFolderRequest(TeaModel):
    def __init__(self, folder_name=None, group_id=None, parent_id=None, project_id=None, tenant_id=None):
        # The name of the folder.
        self.folder_name = folder_name  # type: str
        # The ID of the desired workflow to which the folder belongs.
        self.group_id = group_id  # type: str
        # The ID of the desired parent folder of the folder. The ID of the root folder in a workflow is 0. The ID of the folder created by users in a workflow is greater than 0.
        self.parent_id = parent_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDataServiceFolderRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder_name is not None:
            result['FolderName'] = self.folder_name
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.parent_id is not None:
            result['ParentId'] = self.parent_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FolderName') is not None:
            self.folder_name = m.get('FolderName')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('ParentId') is not None:
            self.parent_id = m.get('ParentId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class CreateDataServiceFolderResponseBody(TeaModel):
    def __init__(self, folder_id=None, request_id=None):
        # The ID of the created folder.
        self.folder_id = folder_id  # type: long
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDataServiceFolderResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CreateDataServiceFolderResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateDataServiceFolderResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateDataServiceFolderResponse, self).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=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 = CreateDataServiceFolderResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateDataServiceGroupRequest(TeaModel):
    def __init__(self, api_gateway_group_id=None, description=None, group_name=None, project_id=None,
                 tenant_id=None):
        # The ID of the API group that is associated with the business process in the API Gateway console. You can log on to the API Gateway console and go to the Group Details page to view the ID.
        self.api_gateway_group_id = api_gateway_group_id  # type: str
        # The description of the business process.
        self.description = description  # type: str
        # The name of the business process.
        self.group_name = group_name  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDataServiceGroupRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_gateway_group_id is not None:
            result['ApiGatewayGroupId'] = self.api_gateway_group_id
        if self.description is not None:
            result['Description'] = self.description
        if self.group_name is not None:
            result['GroupName'] = self.group_name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiGatewayGroupId') is not None:
            self.api_gateway_group_id = m.get('ApiGatewayGroupId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('GroupName') is not None:
            self.group_name = m.get('GroupName')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class CreateDataServiceGroupResponseBody(TeaModel):
    def __init__(self, group_id=None, request_id=None):
        # The ID of the business process.
        self.group_id = group_id  # type: str
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDataServiceGroupResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CreateDataServiceGroupResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateDataServiceGroupResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateDataServiceGroupResponse, self).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=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 = CreateDataServiceGroupResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateDataSourceRequest(TeaModel):
    def __init__(self, content=None, data_source_type=None, description=None, env_type=None, name=None,
                 project_id=None, sub_type=None):
        # The ID of the data source.
        self.content = content  # type: str
        # The environment in which the data source is used. Valid values: 0 and 1. 0 indicates the development environment. 1 indicates the production environment.
        self.data_source_type = data_source_type  # type: str
        # The subtype of the data source. Example:
        # 
        # *   This parameter takes effect only if the DataSourceType parameter is set to rds.
        # *   If the DataSourceType parameter is set to rds, this parameter can be set to mysql, sqlserver, or postgresql.
        self.description = description  # type: str
        # The HTTP status code returned.
        self.env_type = env_type  # type: int
        # The type of the data source. Valid values:
        # 
        # *   odps
        # *   mysql
        # *   rds
        # *   oss
        # *   sqlserver
        # *   polardb
        # *   oracle
        # *   mongodb
        # *   emr
        # *   postgresql
        # *   analyticdb_for_mysql
        # *   hybriddb_for_postgresql
        # *   holo
        self.name = name  # type: str
        # The description of the data source.
        self.project_id = project_id  # type: long
        # The details of the data source. Examples of details of some common data sources:
        # 
        # *   odps
        # 
        # ```
        # 
        # {
        #   "accessId": "xssssss",
        #   "accessKey": "xsaxsaxsa",
        #   "authType": 2,
        #   "endpoint": "http://service.odps.aliyun.com/api",
        #   "project": "xsaxsax",
        #   "tag": "public"
        # }
        # ```
        # 
        # *   mysql
        # 
        # ```
        # 
        # {
        #   "database": "xsaxsa",
        #   "instanceName": "rm-xsaxsa",
        #   "password": "xsaxsa",
        #   "rdsOwnerId": "xasxsa",
        #   "regionId": "cn-shanghai",
        #   "tag": "rds",
        #   "username": "xsaxsa"
        # }
        # ```
        # 
        # *   rds
        # 
        # ```
        # 
        # {
        #   "configType": 1,
        #   "tag": "rds",
        #   "database": "xsaxsa",
        #   "username": "xsaxsa",
        #   "password": "xssaxsa$32050",
        #   "instanceName": "rm-xsaxs",
        #   "rdsOwnerId": "11111111"
        # }
        # ```
        # 
        # *   oss
        # 
        # ```
        # 
        # {
        #   "accessId": "sssssxx",
        #   "accessKey": "xsaxaxsaxs",
        #   "bucket": "xsa-xs-xs",
        #   "endpoint": "http://oss-cn-shanghai.aliyuncs.com",
        #   "tag": "public"
        # }
        # ```
        # 
        # *   sqlserver
        # 
        # ```
        # 
        # {
        #   "jdbcUrl": "jdbc:sqlserver://xsaxsa-xsaxsa.database.xxx.cn:123;DatabaseName=xsxs-xsxs",
        #   "password": "sdasda$fs",
        #   "tag": "public",
        #   "username": "sxaxacdacdd"
        # }
        # ```
        # 
        # *   polardb
        # 
        # ```
        # 
        # {
        #   "clusterId": "pc-sdadsadsa",
        #   "database": "dsadsadsa",
        #   "ownerId": "121212122",
        #   "password": "sdasdafssa",
        #   "region": "cn-shanghai",
        #   "tag": "polardb",
        #   "username": "asdadsads"
        # }
        # ```
        # 
        # *   oracle
        # 
        # ```
        # 
        # {
        #   "jdbcUrl": "jdbc:oracle:saaa:@xxxxx:1521:PROD",
        #   "password": "sxasaxsa",
        #   "tag": "public",
        #   "username": "sasfadfa"
        # }
        # ```
        # 
        # *   mongodb
        # 
        # ```
        # 
        # {
        #   "address": "[\"xsaxxsa.mongodb.rds.aliyuncs.com:3717\"]",
        #   "database": "admin",
        #   "password": "sadsda@",
        #   "tag": "public",
        #   "username": "dsadsadas"
        # }
        # ```
        # 
        # *   emr
        # 
        # ```
        # 
        # {
        #   "accessId": "xsaxsa",
        #   "emrClusterId": "C-dsads",
        #   "emrResourceQueueName": "default",
        #   "emrEndpoint": "emr.aliyuncs.com",
        #   "accessKey": "dsadsad",
        #   "emrUserId": "224833315798889783",
        #   "name": "sasdsadsa",
        #   "emrAccessMode": "simple",
        #   "region": "cn-shanghai",
        #   "authType": "2",
        #   "emrProjectId": "FP-sdadsad"
        # }
        # ```
        # 
        # *   postgresql
        # 
        # ```
        # 
        # {
        #   "jdbcUrl": "jdbc:postgresql://xxxx:1921/ssss",
        #   "password": "sdadsads",
        #   "tag": "public",
        #   "username": "sdsasda"
        # }
        # ```
        # 
        # *   analyticdb_for_mysql
        # 
        # ```
        # 
        # {
        #   "instanceId": "am-sadsada",
        #   "database": "xsxsx",
        #   "username": "xsxsa",
        #   "password": "asdadsa",
        #   "connectionString": "am-xssxsxs.ads.aliyuncs.com:3306"
        # }
        # ```
        # 
        # *   hybriddb_for_postgresql
        # 
        # ```
        # 
        # {
        #   "connectionString": "gp-xsaxsaxa-master.gpdbmaster.rds.aliyuncs.com",
        #   "database": "xsaxsaxas",
        #   "password": "xsaxsaxsa@11",
        #   "instanceId": "gp-xsaxsaxsa",
        #   "port": "541132",
        #   "ownerId": "xsaxsaxsas",
        #   "username": "sadsad"
        # }
        # ```
        # 
        # *   holo
        # 
        # ```
        # 
        # {
        #   "accessId": "xsaxsaxs",
        #   "accessKey": "xsaxsaxsa",
        #   "database": "xsaxsaxsa",
        #   "instanceId": "xsaxa",
        #   "tag": "aliyun"
        # }
        # ```
        # 
        # *   kafka
        # 
        # ```
        # 
        # {
        #   "instanceId": "xsax-cn-xsaxsa",
        #   "regionId": "cn-shanghai",
        #   "tag": "aliyun",
        #   "ownerId": "1212121212112"
        # }
        # ```
        self.sub_type = sub_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDataSourceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.description is not None:
            result['Description'] = self.description
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.name is not None:
            result['Name'] = self.name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.sub_type is not None:
            result['SubType'] = self.sub_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SubType') is not None:
            self.sub_type = m.get('SubType')
        return self


class CreateDataSourceResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        # Indicates whether the request was successful.
        self.data = data  # type: long
        # The ID of the request.
        self.http_status_code = http_status_code  # type: str
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateDataSourceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateDataSourceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateDataSourceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateDataSourceResponse, self).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=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 = CreateDataSourceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateExportMigrationRequest(TeaModel):
    def __init__(self, description=None, export_mode=None, export_object_status=None, incremental_since=None,
                 name=None, project_id=None):
        # The description of the export task.
        self.description = description  # type: str
        # The export mode of the export task. Valid values:
        # 
        # *   FULL: The export task is used to export all data objects.
        # *   INCREMENTAL: The export task is used to export data objects that were modified since the specified point in time. If you set this parameter to INCREMENTAL, you must configure the IncrementalSince parameter.
        self.export_mode = export_mode  # type: str
        # The status of the data objects that you want to export in the export task. The system exports data objects in the state that is specified by this parameter. Valid values:
        # 
        # *   SAVED: Data objects that are in the SAVED state are exported.
        # *   SUBMITTED: Data objects that are in the SUBMITTED state are exported.
        # *   DEPLOYED: Data objects that are in the DEPLOYED state are exported.
        self.export_object_status = export_object_status  # type: str
        # The start time of the incremental export task.
        # 
        # The IncrementalSince parameter takes effect only when the ExportMode parameter is set to INCREMENTAL.
        self.incremental_since = incremental_since  # type: long
        # The name of the export task.
        # 
        # The name of each export task must be unique. You must ensure that no duplicate export task exists in the current workspace.
        self.name = name  # type: str
        # The ID of the workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace ID.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateExportMigrationRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        if self.export_mode is not None:
            result['ExportMode'] = self.export_mode
        if self.export_object_status is not None:
            result['ExportObjectStatus'] = self.export_object_status
        if self.incremental_since is not None:
            result['IncrementalSince'] = self.incremental_since
        if self.name is not None:
            result['Name'] = self.name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('ExportMode') is not None:
            self.export_mode = m.get('ExportMode')
        if m.get('ExportObjectStatus') is not None:
            self.export_object_status = m.get('ExportObjectStatus')
        if m.get('IncrementalSince') is not None:
            self.incremental_since = m.get('IncrementalSince')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class CreateExportMigrationResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # The ID of the export task.
        self.data = data  # type: long
        # The ID of the request. You can use the ID to locate logs and troubleshoot errors.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The call succeeded.
        # *   false: The call failed. You can locate errors based on the request ID.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateExportMigrationResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateExportMigrationResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateExportMigrationResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateExportMigrationResponse, self).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=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 = CreateExportMigrationResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateFileRequest(TeaModel):
    def __init__(self, advanced_settings=None, auto_parsing=None, auto_rerun_interval_millis=None,
                 auto_rerun_times=None, connection_name=None, content=None, create_folder_if_not_exists=None, cron_express=None,
                 cycle_type=None, dependent_node_id_list=None, dependent_type=None, end_effect_date=None,
                 file_description=None, file_folder_path=None, file_name=None, file_type=None,
                 ignore_parent_skip_running_property=None, input_list=None, input_parameters=None, output_parameters=None, owner=None, para_value=None,
                 project_id=None, project_identifier=None, rerun_mode=None, resource_group_id=None,
                 resource_group_identifier=None, scheduler_type=None, start_effect_date=None, start_immediately=None, stop=None):
        # The advanced configurations of the node.
        # 
        # This parameter is valid only for an EMR Spark Streaming node or an EMR Streaming SQL node. This parameter corresponds to the Advanced Settings tab of the node in the [DataWorks console](https://workbench.data.aliyun.com/console).
        # 
        # The value of this parameter must be in the JSON format.
        self.advanced_settings = advanced_settings  # type: str
        # Specifies whether to enable the automatic parsing feature for the file. Valid values:
        # 
        # *   true: enables the automatic parsing feature for the file.
        # *   false: does not enable the automatic parsing feature for the file.
        # 
        # This parameter corresponds to the Analyze Code parameter that is displayed after Same Cycle is selected in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.auto_parsing = auto_parsing  # type: bool
        # The interval between automatic reruns after an error occurs. Unit: milliseconds. Maximum value: 1800000 (30 minutes).
        # 
        # This parameter corresponds to the Rerun Interval parameter that is displayed after the Auto Rerun upon Error check box is selected in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        # 
        # The interval that you specify in the DataWorks console is measured in minutes. Pay attention to the conversion between the units of time when you call the operation.
        self.auto_rerun_interval_millis = auto_rerun_interval_millis  # type: int
        # The number of automatic reruns that are allowed after an error occurs. Maximum value: 10.
        self.auto_rerun_times = auto_rerun_times  # type: int
        # The name of the data source for which the node is run.
        # 
        # You can call the [UpdateDataSource](~~211432~~) operation to query the available data sources in the workspace.
        self.connection_name = connection_name  # type: str
        # The code for the file. The code format varies based on the file type. To view the code format for a specific file type, go to Operation Center, right-click a node of the file type, and then select View Code.
        self.content = content  # type: str
        self.create_folder_if_not_exists = create_folder_if_not_exists  # type: bool
        # The CRON expression that represents the automatic scheduling policy of the node. This parameter corresponds to the Cron Expression parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console). After you configure the Scheduling Cycle and Run At parameters in the DataWorks console, DataWorks generates the value of the Cron Expression parameter.
        # 
        # Examples:
        # 
        # *   CRON expression for a node that is scheduled to run at 05:30 every day: `00 30 05 * * ?`
        # *   CRON expression for a node that is scheduled to run at the fifteenth minute of each hour: `00 15 00-23/1 * * ?`
        # *   CRON expression for a node that is scheduled to run every 10 minutes: `00 00/10 * * * ?`
        # *   CRON expression for a node that is scheduled to run every 10 minutes from 08:00 to 17:00 every day: `00 00-59/10 8-17 * * * ?`
        # *   CRON expression for a node that is scheduled to run at 00:20 on the first day of each month: `00 20 00 1 * ?`
        # *   CRON expression for a node that is scheduled to run every three months starting from 00:10 on January 1: `00 10 00 1 1-12/3 ?`
        # *   CRON expression for a node that is scheduled to run at 00:05 every Tuesday and Friday: `00 05 00 * * 2,5`
        # 
        # The scheduling system of DataWorks imposes the following limits on CRON expressions:
        # 
        # *   A node can be scheduled to run at a minimum interval of 5 minutes.
        # *   A node can be scheduled to run at 00:05 every day at the earliest.
        self.cron_express = cron_express  # type: str
        # The type of the scheduling cycle. Valid values: NOT_DAY and DAY. The value NOT_DAY indicates that the node is scheduled to run by minute or hour. The value DAY indicates that the node is scheduled to run by day, week, or month.
        # 
        # This parameter corresponds to the Scheduling Cycle parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.cycle_type = cycle_type  # type: str
        # The IDs of the nodes that generate instances in the previous cycle on which the current node depends.
        self.dependent_node_id_list = dependent_node_id_list  # type: str
        # The type of the cross-cycle scheduling dependency of the node. Valid values:
        # 
        # *   SELF: The instance generated for the node in the current cycle depends on the instance generated for the node in the previous cycle.
        # 
        # *   CHILD: The instance generated for the node in the current cycle depends on the instances generated for the descendant nodes at the nearest level of the node in the previous cycle.
        # 
        # *   USER_DEFINE: The instance generated for the node in the current cycle depends on the instances generated for one or more specified nodes in the previous cycle.
        # 
        # *   NONE: No cross-cycle scheduling dependency type is selected for the node.
        # 
        # *   USER_DEFINE_AND_SELF: The instance generated for the node in the current cycle depends on the instance generated for the node in the previous cycle and the instances generated for one or more specified nodes in the previous cycle.
        # 
        # *   CHILD_AND_SELF: The instance generated for the node in the current cycle depends on the instances generated for the descendant nodes at the nearest level of the node in the previous cycle and the instance generated for the node in the previous cycle.
        self.dependent_type = dependent_type  # type: str
        # The end time of automatic scheduling. Set the value to a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        # 
        # This parameter corresponds to the Validity Period parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.end_effect_date = end_effect_date  # type: long
        # The description of the file.
        self.file_description = file_description  # type: str
        # The path of the file.
        self.file_folder_path = file_folder_path  # type: str
        # The name of the file.
        self.file_name = file_name  # type: str
        # The type of the code in the file.
        # 
        # Valid values: 6 (Shell), 10 (ODPS SQL), 11 (ODPS MR), 24 (ODPS Script), 99 (zero load), 221 (PyODPS 2), 225 (ODPS Spark), 227 (EMR Hive), 228 (EMR Spark), 229 (EMR Spark SQL), 230 (EMR MR), 239 (OSS object inspection), 257 (EMR Shell), 258 (EMR Spark Shell), 259 (EMR Presto), 260 (EMR Impala), 900 (real-time synchronization), 1089 (cross-tenant collaboration), 1091 (Hologres development), 1093 (Hologres SQL), 1100 (assignment), and 1221 (PyODPS 3).
        # 
        # You can call the [ListFileType](~~212428~~) operation to query the type of the code for the file.
        self.file_type = file_type  # type: int
        self.ignore_parent_skip_running_property = ignore_parent_skip_running_property  # type: bool
        # The output name of the parent file on which the current file depends. If you specify multiple output names, separate them with commas (,).
        # 
        # This parameter corresponds to the Output Name parameter under Parent Nodes in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.input_list = input_list  # type: str
        # The input parameters of the node. The value of this parameter must be in the JSON format. For more information about the input parameters, see the InputContextParameterList parameter in the Response parameters section of the [GetFile](~~173954~~) operation.
        # 
        # This parameter corresponds to the Input Parameters table in the Input and Output Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.input_parameters = input_parameters  # type: str
        # The output parameters of the node. The value of this parameter must be in the JSON format. For more information about the output parameters, see the OutputContextParameterList parameter in the Response parameters section of the [GetFile](~~173954~~) operation.
        # 
        # This parameter corresponds to the Output Parameters table in the Input and Output Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.output_parameters = output_parameters  # type: str
        # The ID of the Alibaba Cloud account used by the file owner. If this parameter is not configured, the ID of the Alibaba Cloud account of the user who calls the operation is used.
        self.owner = owner  # type: str
        # The scheduling parameters of the node. Separate multiple parameters with spaces.
        # 
        # This parameter corresponds to the Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console). For more information about the configurations of the scheduling parameters, see [Configure scheduling parameters](~~137548~~).
        self.para_value = para_value  # type: str
        # The ID of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace ID.
        # 
        # You must configure this parameter or the ProjectIdentifier parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace name.
        # 
        # You must configure this parameter or the ProjectId parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str
        # Specifies whether the node that corresponds to the file can be rerun. Valid values:
        # 
        # *   ALL_ALLOWED: The node can be rerun regardless of whether it is successfully run or fails to run.
        # *   FAILURE_ALLOWED: The node can be rerun only after it fails to run.
        # *   ALL_DENIED: The node cannot be rerun regardless of whether it is successfully run or fails to run.
        # 
        # This parameter corresponds to the Rerun parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.rerun_mode = rerun_mode  # type: str
        # This parameter is deprecated. Do not use this parameter.
        # 
        # The identifier of the resource group that is used to run the node. This parameter corresponds to the Resource Group parameter in the Resource Group section of the Properties tab in the DataWorks console. You must configure one of the ResourceGroupId and ResourceGroupIdentifier parameters to determine the resource group that is used to run the node.
        # 
        # You can call the [ListResourceGroups](~~173913~~) operation to query the available resource groups in the workspace. When you call the operation, set the ResourceGroupType parameter to 1. The response parameter Id indicates the ID of an available resource group.
        self.resource_group_id = resource_group_id  # type: long
        # The identifier of the resource group that is used to run the node. You can call the [ListResourceGroups](~~173913~~) operation to query the available resource groups in the workspace.
        self.resource_group_identifier = resource_group_identifier  # type: str
        # The scheduling type of the inner node. Valid values:
        # 
        # *   NORMAL: The node is an auto triggered node.
        # *   MANUAL: The node is a manually triggered node. Manually triggered nodes cannot be automatically triggered. They correspond to the nodes in the Manually Triggered Workflows pane.
        # *   PAUSE: The node is a paused node.
        # *   SKIP: The node is a dry-run node. Dry-run nodes are started as scheduled, but the system sets the status of the nodes to successful when it starts to run them.
        self.scheduler_type = scheduler_type  # type: str
        # The start time of automatic scheduling. Set the value to a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        # 
        # This parameter corresponds to the Validity Period parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.start_effect_date = start_effect_date  # type: long
        # Specifies whether to immediately run a node after the node is deployed to the production environment.
        # 
        # This parameter is valid only for an EMR Spark Streaming node or an EMR Streaming SQL node. This parameter corresponds to the Start Method parameter in the Schedule section of the Configure tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.start_immediately = start_immediately  # type: bool
        # Specifies whether to suspend the scheduling of the node. Valid values:
        # 
        # *   true: suspends the scheduling of the node.
        # *   false: does not suspend the scheduling of the node.
        # 
        # This parameter corresponds to the Recurrence parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.stop = stop  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateFileRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.advanced_settings is not None:
            result['AdvancedSettings'] = self.advanced_settings
        if self.auto_parsing is not None:
            result['AutoParsing'] = self.auto_parsing
        if self.auto_rerun_interval_millis is not None:
            result['AutoRerunIntervalMillis'] = self.auto_rerun_interval_millis
        if self.auto_rerun_times is not None:
            result['AutoRerunTimes'] = self.auto_rerun_times
        if self.connection_name is not None:
            result['ConnectionName'] = self.connection_name
        if self.content is not None:
            result['Content'] = self.content
        if self.create_folder_if_not_exists is not None:
            result['CreateFolderIfNotExists'] = self.create_folder_if_not_exists
        if self.cron_express is not None:
            result['CronExpress'] = self.cron_express
        if self.cycle_type is not None:
            result['CycleType'] = self.cycle_type
        if self.dependent_node_id_list is not None:
            result['DependentNodeIdList'] = self.dependent_node_id_list
        if self.dependent_type is not None:
            result['DependentType'] = self.dependent_type
        if self.end_effect_date is not None:
            result['EndEffectDate'] = self.end_effect_date
        if self.file_description is not None:
            result['FileDescription'] = self.file_description
        if self.file_folder_path is not None:
            result['FileFolderPath'] = self.file_folder_path
        if self.file_name is not None:
            result['FileName'] = self.file_name
        if self.file_type is not None:
            result['FileType'] = self.file_type
        if self.ignore_parent_skip_running_property is not None:
            result['IgnoreParentSkipRunningProperty'] = self.ignore_parent_skip_running_property
        if self.input_list is not None:
            result['InputList'] = self.input_list
        if self.input_parameters is not None:
            result['InputParameters'] = self.input_parameters
        if self.output_parameters is not None:
            result['OutputParameters'] = self.output_parameters
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.para_value is not None:
            result['ParaValue'] = self.para_value
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.rerun_mode is not None:
            result['RerunMode'] = self.rerun_mode
        if self.resource_group_id is not None:
            result['ResourceGroupId'] = self.resource_group_id
        if self.resource_group_identifier is not None:
            result['ResourceGroupIdentifier'] = self.resource_group_identifier
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        if self.start_effect_date is not None:
            result['StartEffectDate'] = self.start_effect_date
        if self.start_immediately is not None:
            result['StartImmediately'] = self.start_immediately
        if self.stop is not None:
            result['Stop'] = self.stop
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AdvancedSettings') is not None:
            self.advanced_settings = m.get('AdvancedSettings')
        if m.get('AutoParsing') is not None:
            self.auto_parsing = m.get('AutoParsing')
        if m.get('AutoRerunIntervalMillis') is not None:
            self.auto_rerun_interval_millis = m.get('AutoRerunIntervalMillis')
        if m.get('AutoRerunTimes') is not None:
            self.auto_rerun_times = m.get('AutoRerunTimes')
        if m.get('ConnectionName') is not None:
            self.connection_name = m.get('ConnectionName')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('CreateFolderIfNotExists') is not None:
            self.create_folder_if_not_exists = m.get('CreateFolderIfNotExists')
        if m.get('CronExpress') is not None:
            self.cron_express = m.get('CronExpress')
        if m.get('CycleType') is not None:
            self.cycle_type = m.get('CycleType')
        if m.get('DependentNodeIdList') is not None:
            self.dependent_node_id_list = m.get('DependentNodeIdList')
        if m.get('DependentType') is not None:
            self.dependent_type = m.get('DependentType')
        if m.get('EndEffectDate') is not None:
            self.end_effect_date = m.get('EndEffectDate')
        if m.get('FileDescription') is not None:
            self.file_description = m.get('FileDescription')
        if m.get('FileFolderPath') is not None:
            self.file_folder_path = m.get('FileFolderPath')
        if m.get('FileName') is not None:
            self.file_name = m.get('FileName')
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        if m.get('IgnoreParentSkipRunningProperty') is not None:
            self.ignore_parent_skip_running_property = m.get('IgnoreParentSkipRunningProperty')
        if m.get('InputList') is not None:
            self.input_list = m.get('InputList')
        if m.get('InputParameters') is not None:
            self.input_parameters = m.get('InputParameters')
        if m.get('OutputParameters') is not None:
            self.output_parameters = m.get('OutputParameters')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ParaValue') is not None:
            self.para_value = m.get('ParaValue')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('RerunMode') is not None:
            self.rerun_mode = m.get('RerunMode')
        if m.get('ResourceGroupId') is not None:
            self.resource_group_id = m.get('ResourceGroupId')
        if m.get('ResourceGroupIdentifier') is not None:
            self.resource_group_identifier = m.get('ResourceGroupIdentifier')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        if m.get('StartEffectDate') is not None:
            self.start_effect_date = m.get('StartEffectDate')
        if m.get('StartImmediately') is not None:
            self.start_immediately = m.get('StartImmediately')
        if m.get('Stop') is not None:
            self.stop = m.get('Stop')
        return self


class CreateFileResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the file that was created.
        self.data = data  # type: long
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateFileResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateFileResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateFileResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateFileResponse, self).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=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 = CreateFileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateFolderRequest(TeaModel):
    def __init__(self, folder_path=None, project_id=None, project_identifier=None):
        # The HTTP status code returned.
        self.folder_path = folder_path  # type: str
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace name. You must configure either the ProjectId or ProjectIdentifier parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The path of the folder.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateFolderRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder_path is not None:
            result['FolderPath'] = self.folder_path
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FolderPath') is not None:
            self.folder_path = m.get('FolderPath')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class CreateFolderResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.data = data  # type: str
        self.error_code = error_code  # type: str
        # Indicates whether the request was successful.
        self.error_message = error_message  # type: str
        # The unique identifier of the folder.
        self.http_status_code = http_status_code  # type: int
        # The error message returned.
        self.request_id = request_id  # type: str
        # The error code returned.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateFolderResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateFolderResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateFolderResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateFolderResponse, self).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=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 = CreateFolderResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateImportMigrationRequest(TeaModel):
    def __init__(self, calculate_engine_map=None, commit_rule=None, description=None, name=None, package_file=None,
                 package_type=None, project_id=None, resource_group_map=None, workspace_map=None):
        # The mapping between the source compute engine instance and the destination compute engine instance.
        # 
        # The following types of compute engine instances are supported: MaxCompute, E-MapReduce (EMR), Hadoop CDH, and Hologres.
        self.calculate_engine_map = calculate_engine_map  # type: str
        # The rule configured for automatically committing and deploying the import task. The rule contains the following parameters:
        # 
        # *   resourceAutoCommit: specifies whether resources are automatically committed. The value true indicates that the resources are automatically committed, and the value false indicates that the resources are not automatically committed.
        # *   resourceAutoDeploy: specifies whether resources are automatically deployed. The value true indicates that the resources are automatically deployed, and the value false indicates that the resources are not automatically deployed.
        # *   functionAutoCommit: specifies whether the function is automatically committed. The value true indicates that the function is automatically committed, and the value false indicates that the function is not automatically committed.
        # *   functionAutoDeploy: specifies whether the function is automatically deployed. The value true indicates that the function is automatically deployed, and the value false indicates that the function is not automatically deployed.
        # *   tableAutoCommitToDev: specifies whether the table is automatically committed to the development environment. The value true indicates that the table is automatically committed to the development environment, and the value false indicates that the table is not automatically committed to the development environment.
        # *   tableAutoCommitToProd: specifies whether the table is automatically committed to the production environment. The value true indicates that the table is automatically committed to the production environment, and the value false indicates that the table is not automatically committed to the production environment.
        # *   ignoreLock: specifies whether the lock is automatically ignored when an import task is locked. The value true indicates that the lock is automatically ignored, and the value false indicates that the lock is not automatically ignored. If you set this parameter to true for an import task, you can forcibly update the task even if the task is locked.
        # *   fileAutoCommit: specifies whether the file is automatically committed. The value true indicates that the file is automatically committed, and the value false indicates that the file is not automatically committed.
        # *   fileAutoDeploy: specifies whether the file is automatically deployed. The value true indicates that the file is automatically deployed, and the value false indicates that the file is not automatically deployed.
        self.commit_rule = commit_rule  # type: str
        # The description of the import package.
        self.description = description  # type: str
        # The name of the import task. The name must be unique within the workspace.
        self.name = name  # type: str
        # The path of the import package.
        # 
        # **The import package must be uploaded. Example of the upload method:**`  Config config = new Config(); config.setAccessKeyId(accessId); config.setAccessKeySecret(accessKey); config.setEndpoint(popEndpoint); config.setRegionId(regionId); Client client = new Client(config); CreateImportMigrationAdvanceRequest request = new CreateImportMigrationAdvanceRequest(); request.setName("test_migration_api_" + System.currentTimeMillis()); request.setProjectId(123456L); request.setPackageType("DATAWORKS_MODEL"); request.setPackageFileObject(new FileInputStream("/home/admin/Downloads/test.zip")); RuntimeOptions runtime = new RuntimeOptions(); CreateImportMigrationResponse response = client.createImportMigrationAdvance(request, runtime); ... `
        self.package_file = package_file  # type: str
        # The type of the import package. Valid values:
        # 
        # *   DATAWORKS_MODEL (standard format)
        # *   DATAWORKS_V2 (Apsara Stack DataWorks V3.6.1 to V3.11)
        # *   DATAWORKS_V3 (Apsara Stack DataWorks V3.12 and later)
        self.package_type = package_type  # type: str
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID.
        self.project_id = project_id  # type: long
        # The mapping between the resource group for scheduling and the resource group for Data Integration. The keys and values in the mapping are the identifiers of the resource groups. Specify the mapping in the following format:
        # 
        # ```
        # 
        # {
        #     "SCHEDULER_RESOURCE_GROUP": {
        #         "xxx": "yyy"
        #     },
        #     "DI_RESOURCE_GROUP": {
        #         "ccc": "dfdd"
        #     }
        # }
        # 
        #                                 
        # ```
        self.resource_group_map = resource_group_map  # type: str
        # The mapping between the prefixes for the names of the source and destination workspaces. When the system performs the import operation, the prefix for the name of the source workspace in the import package is replaced based on the mapping.
        self.workspace_map = workspace_map  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateImportMigrationRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.calculate_engine_map is not None:
            result['CalculateEngineMap'] = self.calculate_engine_map
        if self.commit_rule is not None:
            result['CommitRule'] = self.commit_rule
        if self.description is not None:
            result['Description'] = self.description
        if self.name is not None:
            result['Name'] = self.name
        if self.package_file is not None:
            result['PackageFile'] = self.package_file
        if self.package_type is not None:
            result['PackageType'] = self.package_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.resource_group_map is not None:
            result['ResourceGroupMap'] = self.resource_group_map
        if self.workspace_map is not None:
            result['WorkspaceMap'] = self.workspace_map
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CalculateEngineMap') is not None:
            self.calculate_engine_map = m.get('CalculateEngineMap')
        if m.get('CommitRule') is not None:
            self.commit_rule = m.get('CommitRule')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('PackageFile') is not None:
            self.package_file = m.get('PackageFile')
        if m.get('PackageType') is not None:
            self.package_type = m.get('PackageType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ResourceGroupMap') is not None:
            self.resource_group_map = m.get('ResourceGroupMap')
        if m.get('WorkspaceMap') is not None:
            self.workspace_map = m.get('WorkspaceMap')
        return self


class CreateImportMigrationAdvanceRequest(TeaModel):
    def __init__(self, calculate_engine_map=None, commit_rule=None, description=None, name=None,
                 package_file_object=None, package_type=None, project_id=None, resource_group_map=None, workspace_map=None):
        # The mapping between the source compute engine instance and the destination compute engine instance.
        # 
        # The following types of compute engine instances are supported: MaxCompute, E-MapReduce (EMR), Hadoop CDH, and Hologres.
        self.calculate_engine_map = calculate_engine_map  # type: str
        # The rule configured for automatically committing and deploying the import task. The rule contains the following parameters:
        # 
        # *   resourceAutoCommit: specifies whether resources are automatically committed. The value true indicates that the resources are automatically committed, and the value false indicates that the resources are not automatically committed.
        # *   resourceAutoDeploy: specifies whether resources are automatically deployed. The value true indicates that the resources are automatically deployed, and the value false indicates that the resources are not automatically deployed.
        # *   functionAutoCommit: specifies whether the function is automatically committed. The value true indicates that the function is automatically committed, and the value false indicates that the function is not automatically committed.
        # *   functionAutoDeploy: specifies whether the function is automatically deployed. The value true indicates that the function is automatically deployed, and the value false indicates that the function is not automatically deployed.
        # *   tableAutoCommitToDev: specifies whether the table is automatically committed to the development environment. The value true indicates that the table is automatically committed to the development environment, and the value false indicates that the table is not automatically committed to the development environment.
        # *   tableAutoCommitToProd: specifies whether the table is automatically committed to the production environment. The value true indicates that the table is automatically committed to the production environment, and the value false indicates that the table is not automatically committed to the production environment.
        # *   ignoreLock: specifies whether the lock is automatically ignored when an import task is locked. The value true indicates that the lock is automatically ignored, and the value false indicates that the lock is not automatically ignored. If you set this parameter to true for an import task, you can forcibly update the task even if the task is locked.
        # *   fileAutoCommit: specifies whether the file is automatically committed. The value true indicates that the file is automatically committed, and the value false indicates that the file is not automatically committed.
        # *   fileAutoDeploy: specifies whether the file is automatically deployed. The value true indicates that the file is automatically deployed, and the value false indicates that the file is not automatically deployed.
        self.commit_rule = commit_rule  # type: str
        # The description of the import package.
        self.description = description  # type: str
        # The name of the import task. The name must be unique within the workspace.
        self.name = name  # type: str
        # The path of the import package.
        # 
        # **The import package must be uploaded. Example of the upload method:**`  Config config = new Config(); config.setAccessKeyId(accessId); config.setAccessKeySecret(accessKey); config.setEndpoint(popEndpoint); config.setRegionId(regionId); Client client = new Client(config); CreateImportMigrationAdvanceRequest request = new CreateImportMigrationAdvanceRequest(); request.setName("test_migration_api_" + System.currentTimeMillis()); request.setProjectId(123456L); request.setPackageType("DATAWORKS_MODEL"); request.setPackageFileObject(new FileInputStream("/home/admin/Downloads/test.zip")); RuntimeOptions runtime = new RuntimeOptions(); CreateImportMigrationResponse response = client.createImportMigrationAdvance(request, runtime); ... `
        self.package_file_object = package_file_object  # type: READABLE
        # The type of the import package. Valid values:
        # 
        # *   DATAWORKS_MODEL (standard format)
        # *   DATAWORKS_V2 (Apsara Stack DataWorks V3.6.1 to V3.11)
        # *   DATAWORKS_V3 (Apsara Stack DataWorks V3.12 and later)
        self.package_type = package_type  # type: str
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID.
        self.project_id = project_id  # type: long
        # The mapping between the resource group for scheduling and the resource group for Data Integration. The keys and values in the mapping are the identifiers of the resource groups. Specify the mapping in the following format:
        # 
        # ```
        # 
        # {
        #     "SCHEDULER_RESOURCE_GROUP": {
        #         "xxx": "yyy"
        #     },
        #     "DI_RESOURCE_GROUP": {
        #         "ccc": "dfdd"
        #     }
        # }
        # 
        #                                 
        # ```
        self.resource_group_map = resource_group_map  # type: str
        # The mapping between the prefixes for the names of the source and destination workspaces. When the system performs the import operation, the prefix for the name of the source workspace in the import package is replaced based on the mapping.
        self.workspace_map = workspace_map  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateImportMigrationAdvanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.calculate_engine_map is not None:
            result['CalculateEngineMap'] = self.calculate_engine_map
        if self.commit_rule is not None:
            result['CommitRule'] = self.commit_rule
        if self.description is not None:
            result['Description'] = self.description
        if self.name is not None:
            result['Name'] = self.name
        if self.package_file_object is not None:
            result['PackageFile'] = self.package_file_object
        if self.package_type is not None:
            result['PackageType'] = self.package_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.resource_group_map is not None:
            result['ResourceGroupMap'] = self.resource_group_map
        if self.workspace_map is not None:
            result['WorkspaceMap'] = self.workspace_map
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CalculateEngineMap') is not None:
            self.calculate_engine_map = m.get('CalculateEngineMap')
        if m.get('CommitRule') is not None:
            self.commit_rule = m.get('CommitRule')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('PackageFile') is not None:
            self.package_file_object = m.get('PackageFile')
        if m.get('PackageType') is not None:
            self.package_type = m.get('PackageType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ResourceGroupMap') is not None:
            self.resource_group_map = m.get('ResourceGroupMap')
        if m.get('WorkspaceMap') is not None:
            self.workspace_map = m.get('WorkspaceMap')
        return self


class CreateImportMigrationResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the import task. The ID is used as an input parameter if you want the system to run the import task or you want to obtain the running progress of the import task.
        self.data = data  # type: long
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to locate logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateImportMigrationResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateImportMigrationResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateImportMigrationResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateImportMigrationResponse, self).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=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 = CreateImportMigrationResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateManualDagRequest(TeaModel):
    def __init__(self, biz_date=None, dag_parameters=None, exclude_node_ids=None, flow_name=None,
                 include_node_ids=None, node_parameters=None, project_env=None, project_name=None):
        self.biz_date = biz_date  # type: str
        self.dag_parameters = dag_parameters  # type: str
        self.exclude_node_ids = exclude_node_ids  # type: str
        self.flow_name = flow_name  # type: str
        self.include_node_ids = include_node_ids  # type: str
        self.node_parameters = node_parameters  # type: str
        self.project_env = project_env  # type: str
        self.project_name = project_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateManualDagRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.dag_parameters is not None:
            result['DagParameters'] = self.dag_parameters
        if self.exclude_node_ids is not None:
            result['ExcludeNodeIds'] = self.exclude_node_ids
        if self.flow_name is not None:
            result['FlowName'] = self.flow_name
        if self.include_node_ids is not None:
            result['IncludeNodeIds'] = self.include_node_ids
        if self.node_parameters is not None:
            result['NodeParameters'] = self.node_parameters
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('DagParameters') is not None:
            self.dag_parameters = m.get('DagParameters')
        if m.get('ExcludeNodeIds') is not None:
            self.exclude_node_ids = m.get('ExcludeNodeIds')
        if m.get('FlowName') is not None:
            self.flow_name = m.get('FlowName')
        if m.get('IncludeNodeIds') is not None:
            self.include_node_ids = m.get('IncludeNodeIds')
        if m.get('NodeParameters') is not None:
            self.node_parameters = m.get('NodeParameters')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class CreateManualDagResponseBody(TeaModel):
    def __init__(self, dag_id=None, request_id=None):
        self.dag_id = dag_id  # type: long
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateManualDagResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CreateManualDagResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateManualDagResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateManualDagResponse, self).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=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 = CreateManualDagResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateMetaCategoryRequest(TeaModel):
    def __init__(self, comment=None, name=None, parent_id=None):
        # The remarks of the category.
        self.comment = comment  # type: str
        # The name of the category.
        self.name = name  # type: str
        # The ID of the parent category.
        self.parent_id = parent_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateMetaCategoryRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.name is not None:
            result['Name'] = self.name
        if self.parent_id is not None:
            result['ParentId'] = self.parent_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ParentId') is not None:
            self.parent_id = m.get('ParentId')
        return self


class CreateMetaCategoryResponseBodyData(TeaModel):
    def __init__(self, category_id=None):
        # The ID of the category.
        self.category_id = category_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateMetaCategoryResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.category_id is not None:
            result['CategoryId'] = self.category_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CategoryId') is not None:
            self.category_id = m.get('CategoryId')
        return self


class CreateMetaCategoryResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The information about the category.
        self.data = data  # type: CreateMetaCategoryResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(CreateMetaCategoryResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = CreateMetaCategoryResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateMetaCategoryResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateMetaCategoryResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateMetaCategoryResponse, self).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=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 = CreateMetaCategoryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateMetaCollectionRequest(TeaModel):
    def __init__(self, collection_type=None, comment=None, name=None, parent_qualified_name=None):
        # The ID of the request.
        self.collection_type = collection_type  # type: str
        # The unique identifier of the parent collection.
        self.comment = comment  # type: str
        # The comment of the collection.
        # 
        # The comment must be 1 to 64 characters in length.
        self.name = name  # type: str
        # The type of the collection.
        self.parent_qualified_name = parent_qualified_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateMetaCollectionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.collection_type is not None:
            result['CollectionType'] = self.collection_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.name is not None:
            result['Name'] = self.name
        if self.parent_qualified_name is not None:
            result['ParentQualifiedName'] = self.parent_qualified_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CollectionType') is not None:
            self.collection_type = m.get('CollectionType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ParentQualifiedName') is not None:
            self.parent_qualified_name = m.get('ParentQualifiedName')
        return self


class CreateMetaCollectionResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, qualified_name=None,
                 request_id=None, success=None):
        # The error message returned.
        self.error_code = error_code  # type: str
        # The HTTP status code returned.
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.qualified_name = qualified_name  # type: str
        # The unique identifier of the collection.
        self.request_id = request_id  # type: str
        # The error code returned.
        self.success = success  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateMetaCollectionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateMetaCollectionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateMetaCollectionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateMetaCollectionResponse, self).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=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 = CreateMetaCollectionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreatePermissionApplyOrderRequestApplyObjectColumnMetaList(TeaModel):
    def __init__(self, name=None):
        # The name of the field on which you want to request permissions. If you want to request permissions on an entire table, enter the names of all fields in the table.
        # 
        # You can request permissions on specific fields of a table in a MaxCompute project only after LabelSecurity is enabled for this project. If LabelSecurity is disabled, you can request permissions only on an entire table.
        self.name = name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreatePermissionApplyOrderRequestApplyObjectColumnMetaList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.name is not None:
            result['Name'] = self.name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Name') is not None:
            self.name = m.get('Name')
        return self


class CreatePermissionApplyOrderRequestApplyObject(TeaModel):
    def __init__(self, actions=None, column_meta_list=None, name=None):
        # The permission that you want to request. If you want to request multiple permissions at the same time, separate them with commas (,). You can request only the following permissions: Select, Describe, Drop, Alter, Update, and Download.
        self.actions = actions  # type: str
        self.column_meta_list = column_meta_list  # type: list[CreatePermissionApplyOrderRequestApplyObjectColumnMetaList]
        # The name of the object on which you want to request permissions. You can request permissions only on MaxCompute tables. Set this parameter to the name of the table on which you want to request permissions.
        self.name = name  # type: str

    def validate(self):
        if self.column_meta_list:
            for k in self.column_meta_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(CreatePermissionApplyOrderRequestApplyObject, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.actions is not None:
            result['Actions'] = self.actions
        result['ColumnMetaList'] = []
        if self.column_meta_list is not None:
            for k in self.column_meta_list:
                result['ColumnMetaList'].append(k.to_map() if k else None)
        if self.name is not None:
            result['Name'] = self.name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Actions') is not None:
            self.actions = m.get('Actions')
        self.column_meta_list = []
        if m.get('ColumnMetaList') is not None:
            for k in m.get('ColumnMetaList'):
                temp_model = CreatePermissionApplyOrderRequestApplyObjectColumnMetaList()
                self.column_meta_list.append(temp_model.from_map(k))
        if m.get('Name') is not None:
            self.name = m.get('Name')
        return self


class CreatePermissionApplyOrderRequest(TeaModel):
    def __init__(self, apply_object=None, apply_reason=None, apply_user_ids=None, deadline=None, engine_type=None,
                 max_compute_project_name=None, order_type=None, workspace_id=None):
        self.apply_object = apply_object  # type: list[CreatePermissionApplyOrderRequestApplyObject]
        # The reason for your request. The administrator determines whether to approve the request based on the reason.
        self.apply_reason = apply_reason  # type: str
        # The ID of the Alibaba Cloud account for which you want to request permissions. If you want to request permissions for multiple Alibaba Cloud accounts, separate the IDs of the accounts with commas (,).
        self.apply_user_ids = apply_user_ids  # type: str
        # The expiration time of the permissions that you request. This value is a UNIX timestamp. If you do not specify a value for this parameter, January 1, 2065 is used as the expiration time.
        # 
        # If LabelSecurity is disabled for the MaxCompute project in which you want to request permissions on the fields of a table, or the security level of the fields is 0 or is lower than or equal to the security level of the Alibaba Cloud account for which you want to request permissions, you can request only permanent permissions.
        # 
        # You can go to the Workspace Management page of the DataWorks console, click MaxCompute Management in the left-side navigation pane, and then check whether column-level access control is enabled.
        # 
        # You can go to your DataWorks workspace, view the security level of the fields in DataMap, and then view the security level of the Alibaba Cloud account on the User Management page.
        self.deadline = deadline  # type: long
        # The type of the compute engine instance in which you want to request permissions on the fields of a table. The parameter value is odps and cannot be changed. This value indicates that you can request permissions only on fields of tables in MaxCompute compute engine instances.
        self.engine_type = engine_type  # type: str
        # The name of the MaxCompute project in which you request permissions on the fields of a table.
        self.max_compute_project_name = max_compute_project_name  # type: str
        # The type of the permission request order. The parameter value is 1 and cannot be changed. This value indicates ACL-based authorization.
        self.order_type = order_type  # type: int
        # The ID of the DataWorks workspace that is associated with the MaxCompute project in which you want to request permissions on the fields of a table. You can go to the Workspace Management page in the DataWorks console to view the workspace ID.
        self.workspace_id = workspace_id  # type: int

    def validate(self):
        if self.apply_object:
            for k in self.apply_object:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(CreatePermissionApplyOrderRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ApplyObject'] = []
        if self.apply_object is not None:
            for k in self.apply_object:
                result['ApplyObject'].append(k.to_map() if k else None)
        if self.apply_reason is not None:
            result['ApplyReason'] = self.apply_reason
        if self.apply_user_ids is not None:
            result['ApplyUserIds'] = self.apply_user_ids
        if self.deadline is not None:
            result['Deadline'] = self.deadline
        if self.engine_type is not None:
            result['EngineType'] = self.engine_type
        if self.max_compute_project_name is not None:
            result['MaxComputeProjectName'] = self.max_compute_project_name
        if self.order_type is not None:
            result['OrderType'] = self.order_type
        if self.workspace_id is not None:
            result['WorkspaceId'] = self.workspace_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.apply_object = []
        if m.get('ApplyObject') is not None:
            for k in m.get('ApplyObject'):
                temp_model = CreatePermissionApplyOrderRequestApplyObject()
                self.apply_object.append(temp_model.from_map(k))
        if m.get('ApplyReason') is not None:
            self.apply_reason = m.get('ApplyReason')
        if m.get('ApplyUserIds') is not None:
            self.apply_user_ids = m.get('ApplyUserIds')
        if m.get('Deadline') is not None:
            self.deadline = m.get('Deadline')
        if m.get('EngineType') is not None:
            self.engine_type = m.get('EngineType')
        if m.get('MaxComputeProjectName') is not None:
            self.max_compute_project_name = m.get('MaxComputeProjectName')
        if m.get('OrderType') is not None:
            self.order_type = m.get('OrderType')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


class CreatePermissionApplyOrderResponseBody(TeaModel):
    def __init__(self, flow_id=None, request_id=None):
        # The ID of the request order. If you request permissions on multiple objects but each object has a different request approver, one request order is generated for each object and is sent to the related approver. In this case, an array is returned.
        self.flow_id = flow_id  # type: list[str]
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreatePermissionApplyOrderResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.flow_id is not None:
            result['FlowId'] = self.flow_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FlowId') is not None:
            self.flow_id = m.get('FlowId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CreatePermissionApplyOrderResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreatePermissionApplyOrderResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreatePermissionApplyOrderResponse, self).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=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 = CreatePermissionApplyOrderResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateProjectMemberRequest(TeaModel):
    def __init__(self, client_token=None, project_id=None, role_code=None, user_id=None):
        # The ID of the request.
        self.client_token = client_token  # type: str
        # The client token that is used to ensure the idempotence of the request. We recommend that you set this parameter to a UUID.
        self.project_id = project_id  # type: long
        self.role_code = role_code  # type: str
        # The code of the role. This parameter is optional. If you specify the RoleCode parameter, the user is assigned the role.
        self.user_id = user_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateProjectMemberRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.client_token is not None:
            result['ClientToken'] = self.client_token
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.role_code is not None:
            result['RoleCode'] = self.role_code
        if self.user_id is not None:
            result['UserId'] = self.user_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClientToken') is not None:
            self.client_token = m.get('ClientToken')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RoleCode') is not None:
            self.role_code = m.get('RoleCode')
        if m.get('UserId') is not None:
            self.user_id = m.get('UserId')
        return self


class CreateProjectMemberResponseBody(TeaModel):
    def __init__(self, request_id=None):
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateProjectMemberResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CreateProjectMemberResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateProjectMemberResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateProjectMemberResponse, self).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=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 = CreateProjectMemberResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateQualityEntityRequest(TeaModel):
    def __init__(self, entity_level=None, env_type=None, match_expression=None, project_id=None, project_name=None,
                 table_name=None):
        # Valid values: 0 (corrected when SQl is completed) and 1 (corrected when task is completed).
        self.entity_level = entity_level  # type: int
        # The engine or data source type.
        self.env_type = env_type  # type: str
        # The partition expression.
        self.match_expression = match_expression  # type: str
        self.project_id = project_id  # type: long
        # The name of the maxcompute project or data source.
        self.project_name = project_name  # type: str
        # The name of the table.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateQualityEntityRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.entity_level is not None:
            result['EntityLevel'] = self.entity_level
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.match_expression is not None:
            result['MatchExpression'] = self.match_expression
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EntityLevel') is not None:
            self.entity_level = m.get('EntityLevel')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('MatchExpression') is not None:
            self.match_expression = m.get('MatchExpression')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class CreateQualityEntityResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the partition expression.
        self.data = data  # type: int
        # The error code.
        self.error_code = error_code  # type: str
        # The returned message.
        self.error_message = error_message  # type: str
        # The HTTP request error codes.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the call is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateQualityEntityResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateQualityEntityResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateQualityEntityResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateQualityEntityResponse, self).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=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 = CreateQualityEntityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateQualityFollowerRequest(TeaModel):
    def __init__(self, alarm_mode=None, entity_id=None, follower=None, project_id=None, project_name=None):
        # The notification method. Valid values: 1, 2, 4, and 5. 1 indicates that the notification is sent by email. 2 indicates that the notification is sent by email and text message. 4 indicates that the notification is sent by a DingTalk chatbot. 5 indicates that the notification is sent by a DingTalk chatbot to all members in a DingTalk group.
        self.alarm_mode = alarm_mode  # type: int
        # The ID of the partition filter expression.
        self.entity_id = entity_id  # type: long
        # The user ID of the subscriber.
        self.follower = follower  # type: str
        self.project_id = project_id  # type: long
        # The name of the computing engine instance or data source.
        self.project_name = project_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateQualityFollowerRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alarm_mode is not None:
            result['AlarmMode'] = self.alarm_mode
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.follower is not None:
            result['Follower'] = self.follower
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlarmMode') is not None:
            self.alarm_mode = m.get('AlarmMode')
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('Follower') is not None:
            self.follower = m.get('Follower')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class CreateQualityFollowerResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the created subscription relationship.
        self.data = data  # type: int
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateQualityFollowerResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateQualityFollowerResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateQualityFollowerResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateQualityFollowerResponse, self).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=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 = CreateQualityFollowerResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateQualityRelativeNodeRequest(TeaModel):
    def __init__(self, env_type=None, match_expression=None, node_id=None, project_id=None, project_name=None,
                 table_name=None, target_node_project_id=None, target_node_project_name=None):
        # The type of the compute engine instance or data source.
        self.env_type = env_type  # type: str
        # The partition filter expression.
        self.match_expression = match_expression  # type: str
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The name of the compute engine instance or data source.
        self.project_name = project_name  # type: str
        # The name of the table.
        self.table_name = table_name  # type: str
        # The ID of the workspace to which the node to be associated with the partition filter expression belongs.
        self.target_node_project_id = target_node_project_id  # type: long
        # The name of the workspace to which the node to be associated with the partition filter expression belongs.
        self.target_node_project_name = target_node_project_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateQualityRelativeNodeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.match_expression is not None:
            result['MatchExpression'] = self.match_expression
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.target_node_project_id is not None:
            result['TargetNodeProjectId'] = self.target_node_project_id
        if self.target_node_project_name is not None:
            result['TargetNodeProjectName'] = self.target_node_project_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('MatchExpression') is not None:
            self.match_expression = m.get('MatchExpression')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('TargetNodeProjectId') is not None:
            self.target_node_project_id = m.get('TargetNodeProjectId')
        if m.get('TargetNodeProjectName') is not None:
            self.target_node_project_name = m.get('TargetNodeProjectName')
        return self


class CreateQualityRelativeNodeResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the node is associated with the partition filter expression.
        self.data = data  # type: bool
        # The error code.
        self.error_code = error_code  # type: str
        # The error message.
        self.error_message = error_message  # type: str
        # The HTTP status code.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateQualityRelativeNodeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateQualityRelativeNodeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateQualityRelativeNodeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateQualityRelativeNodeResponse, self).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=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 = CreateQualityRelativeNodeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateQualityRuleRequest(TeaModel):
    def __init__(self, block_type=None, checker=None, comment=None, critical_threshold=None, entity_id=None,
                 expect_value=None, method_name=None, operator=None, predict_type=None, project_id=None, project_name=None,
                 property=None, property_type=None, rule_name=None, rule_type=None, template_id=None, trend=None,
                 warning_threshold=None, where_condition=None):
        # The strength of the monitoring rule. Valid values: 0 and 1. 0 indicates that the monitoring rule is a weak rule. 1 indicates that the monitoring rule is a strong rule.
        self.block_type = block_type  # type: int
        # The ID of the checker.
        self.checker = checker  # type: int
        # The description of the monitoring rule.
        self.comment = comment  # type: str
        # The threshold for a critical alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements. If a strong rule is used and a critical alert is reported, nodes are blocked.
        self.critical_threshold = critical_threshold  # type: str
        # The ID of the partition filter expression.
        self.entity_id = entity_id  # type: long
        # The expected value of the monitoring result.
        self.expect_value = expect_value  # type: str
        # The method used to collect sample data. If you want to use a custom SQL statement as a sampling method, set this parameter to user_defined.
        self.method_name = method_name  # type: str
        # The comparison operator of the monitoring rule.
        self.operator = operator  # type: str
        # Specifies whether the monitoring rule is a dynamic threshold rule. Valid values: 0 and 2. 0 indicates that the monitoring rule is not a dynamic threshold rule. 2 indicates that the monitoring rule is a dynamic threshold rule.
        self.predict_type = predict_type  # type: int
        self.project_id = project_id  # type: long
        # The name of the compute engine instance or data source.
        self.project_name = project_name  # type: str
        # The fields that you want to monitor. If you want to monitor all fields in a table and check the table rows, set this parameter to table_count. If you want to monitor all fields in a table and check the table size, set this parameter to table_size.
        self.property = property  # type: str
        # The data type of the fields that you want to monitor. If you want to monitor all fields in a table, set this parameter to table. If you want to monitor only a specific field, set this parameter to bigint.
        self.property_type = property_type  # type: str
        # The name of the monitoring rule.
        self.rule_name = rule_name  # type: str
        # The type of the monitoring rule. Valid values: 0, 1, and 2. 0 indicates that the monitoring rule is created by the system. 1 indicates that the monitoring rule is created by a user. 2 indicates that the monitoring rule is a workspace-level rule.
        self.rule_type = rule_type  # type: int
        # The ID of the template that is used to create the monitoring rule.
        self.template_id = template_id  # type: int
        # The trend of the monitoring result. Valid values:
        # 
        # *   up: increasing
        # *   down: decreasing
        # *   abs: absolute value
        self.trend = trend  # type: str
        # The threshold for a warning alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements.
        self.warning_threshold = warning_threshold  # type: str
        # The filter condition or custom SQL statement.
        self.where_condition = where_condition  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateQualityRuleRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.block_type is not None:
            result['BlockType'] = self.block_type
        if self.checker is not None:
            result['Checker'] = self.checker
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.critical_threshold is not None:
            result['CriticalThreshold'] = self.critical_threshold
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.expect_value is not None:
            result['ExpectValue'] = self.expect_value
        if self.method_name is not None:
            result['MethodName'] = self.method_name
        if self.operator is not None:
            result['Operator'] = self.operator
        if self.predict_type is not None:
            result['PredictType'] = self.predict_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.property is not None:
            result['Property'] = self.property
        if self.property_type is not None:
            result['PropertyType'] = self.property_type
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        if self.rule_type is not None:
            result['RuleType'] = self.rule_type
        if self.template_id is not None:
            result['TemplateId'] = self.template_id
        if self.trend is not None:
            result['Trend'] = self.trend
        if self.warning_threshold is not None:
            result['WarningThreshold'] = self.warning_threshold
        if self.where_condition is not None:
            result['WhereCondition'] = self.where_condition
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BlockType') is not None:
            self.block_type = m.get('BlockType')
        if m.get('Checker') is not None:
            self.checker = m.get('Checker')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CriticalThreshold') is not None:
            self.critical_threshold = m.get('CriticalThreshold')
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('ExpectValue') is not None:
            self.expect_value = m.get('ExpectValue')
        if m.get('MethodName') is not None:
            self.method_name = m.get('MethodName')
        if m.get('Operator') is not None:
            self.operator = m.get('Operator')
        if m.get('PredictType') is not None:
            self.predict_type = m.get('PredictType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('Property') is not None:
            self.property = m.get('Property')
        if m.get('PropertyType') is not None:
            self.property_type = m.get('PropertyType')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        if m.get('RuleType') is not None:
            self.rule_type = m.get('RuleType')
        if m.get('TemplateId') is not None:
            self.template_id = m.get('TemplateId')
        if m.get('Trend') is not None:
            self.trend = m.get('Trend')
        if m.get('WarningThreshold') is not None:
            self.warning_threshold = m.get('WarningThreshold')
        if m.get('WhereCondition') is not None:
            self.where_condition = m.get('WhereCondition')
        return self


class CreateQualityRuleResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the monitoring rule that you created.
        self.data = data  # type: str
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateQualityRuleResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateQualityRuleResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateQualityRuleResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateQualityRuleResponse, self).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=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 = CreateQualityRuleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateRemindRequest(TeaModel):
    def __init__(self, alert_interval=None, alert_methods=None, alert_targets=None, alert_unit=None,
                 baseline_ids=None, biz_process_ids=None, detail=None, dnd_end=None, max_alert_times=None, node_ids=None,
                 project_id=None, remind_name=None, remind_type=None, remind_unit=None, robot_urls=None, webhooks=None):
        # The recipient of the alert. Valid values: OWNER and OTHER. The value OWNER indicates the node owner. The value OTHER indicates a specified user.
        self.alert_interval = alert_interval  # type: int
        # The webhook URL of the DingTalk chatbot. You can specify multiple webhook URLs. Separate the specified webhook URLs with commas (,).
        self.alert_methods = alert_methods  # type: str
        # The webhook URL of the WeCom or Lark chatbot. You can specify multiple webhook URLs. Separate the specified webhook URLs with commas (,). The WEBHOOKS notification method must be specified for alertMethods.
        # 
        # Only DataWorks Enterprise Edition supports this parameter.
        # 
        # The webhook URL-based alerting feature is supported in the following regions: China (Shanghai), China (Chengdu), China (Zhangjiakou), China (Beijing), China (Hangzhou), China (Shenzhen), China (Hong Kong), Germany (Frankfurt), and Singapore.
        self.alert_targets = alert_targets  # type: str
        # *   If the AlertUnit parameter is set to OWNER, leave this parameter empty.
        # *   If the AlertUnit parameter is set to OTHER, set this parameter to the ID of the Alibaba Cloud account used by a specific user. You can specify multiple IDs. Separate multiple IDs with commas (,). You can specify a maximum of 10 IDs.
        self.alert_unit = alert_unit  # type: str
        # The ID of the workflow to which the custom alert rule is applied. This parameter takes effect when the RemindUnit parameter is set to BIZPROCESS. You can specify multiple IDs. Separate multiple IDs with commas (,). A maximum of five workflows can be specified for a custom alert rule.
        self.baseline_ids = baseline_ids  # type: str
        # The maximum number of alerts. Valid values: 1 to 10. Default value: 3.
        self.biz_process_ids = biz_process_ids  # type: str
        # The notification method. Valid values:
        # 
        # *   MAIL: Alert notifications are sent by emails.
        # 
        # *   SMS: Alert notifications are sent by text messages.
        # 
        #     Alert notifications can be sent by text messages only in the Singapore, Malaysia (Kuala Lumpur), and Germany (Frankfurt) regions.
        # 
        # *   WEBHOOKS (WeCom or Lark chatbot): Alert notifications are sent by WeCom or Lark messages. If you want to use this notification method, you must configure the Webhooks parameter.
        # 
        # You can specify multiple notification methods. Separate them with commas (,).
        self.detail = detail  # type: str
        # The ID of the node to which the custom alert rule is applied. This parameter takes effect when the RemindUnit parameter is set to NODE. You can specify multiple IDs. Separate multiple IDs with commas (,). A maximum of 50 nodes can be specified for a custom alert rule.
        self.dnd_end = dnd_end  # type: str
        # The details of the conditions that trigger an alert.
        # 
        # *   If the RemindType parameter is set to FINISHED, leave this parameter empty.
        # *   If the RemindType parameter is set to UNFINISHED, specify this parameter as key-value pairs. Example: {"hour":23,"minu":59}. Valid values of hour: 0 to 47. Valid values of minu: 0 to 59.
        # *   If the RemindType parameter is set to ERROR, leave this parameter empty.
        # *   If the RemindType parameter is set to CYCLE_UNFINISHED, specify this parameter as key-value pairs. Example: {"1":"05:50","2":"06:50","3":"07:50","4":"08:50","5":"09:50","6":"10:50","7":"11:50","8":"12:50","9":"13:50","10":"14:50","11":"15:50","12":"16:50","13":"17:50","14":"18:50","15":"19:50","16":"20:50","17":"21:50","18":"22:50","19":"23:50","20":"24:50","21":"25:50"}. The key indicates the ID of the cycle. Valid values of the ID: 1 to 288. The value indicates the timeout period of the node that is running in the cycle. Specify the value in the hh:mm format. Valid values of hh: 0 to 47. Valid values of mm: 0 to 59.
        # *   If the RemindType parameter is set to TIMEOUT, set this parameter to the timeout period. Unit: seconds. Example: 1800. This value indicates that an alert is reported if the node has run for more than 30 minutes.
        self.max_alert_times = max_alert_times  # type: int
        # The ID of the workspace to which the custom alert rule is applied. This parameter takes effect when the RemindUnit parameter is set to PROJECT. Only one workspace can be specified for a custom alert rule.
        self.node_ids = node_ids  # type: str
        # The conditions that trigger an alert. Valid values: FINISHED, UNFINISHED, ERROR, CYCLE_UNFINISHED, and TIMEOUT. The value FINISHED indicates that the node is run. The value UNFINISHED indicates that the node is still running at the specified point in time. The value ERROR indicates that an error occurs when the node is running. The value CYCLE_UNFINISHED indicates that the node is still running in the specified cycle. The value TIMEOUT indicates that the node times out.
        self.project_id = project_id  # type: long
        # The type of the object to which the custom alert rule is applied. Valid values: NODE, BASELINE, PROJECT, and BIZPROCESS. The value NODE indicates a node. The value BASELINE indicates a baseline. The value PROJECT indicates a workspace. The value BIZPROCESS indicates a workflow.
        self.remind_name = remind_name  # type: str
        # The minimum interval at which alerts are reported. Unit: seconds. Minimum value: 1200. Default value: 1800.
        self.remind_type = remind_type  # type: str
        # The ID of the baseline to which the custom alert rule is applied. This parameter takes effect when the RemindUnit parameter is set to BASELINE. You can specify multiple IDs. Separate multiple IDs with commas (,). A maximum of five baselines can be specified for a custom alert rule.
        self.remind_unit = remind_unit  # type: str
        # The HTTP status code returned.
        self.robot_urls = robot_urls  # type: str
        # The ID of the custom alert rule returned.
        self.webhooks = webhooks  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateRemindRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_interval is not None:
            result['AlertInterval'] = self.alert_interval
        if self.alert_methods is not None:
            result['AlertMethods'] = self.alert_methods
        if self.alert_targets is not None:
            result['AlertTargets'] = self.alert_targets
        if self.alert_unit is not None:
            result['AlertUnit'] = self.alert_unit
        if self.baseline_ids is not None:
            result['BaselineIds'] = self.baseline_ids
        if self.biz_process_ids is not None:
            result['BizProcessIds'] = self.biz_process_ids
        if self.detail is not None:
            result['Detail'] = self.detail
        if self.dnd_end is not None:
            result['DndEnd'] = self.dnd_end
        if self.max_alert_times is not None:
            result['MaxAlertTimes'] = self.max_alert_times
        if self.node_ids is not None:
            result['NodeIds'] = self.node_ids
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.remind_name is not None:
            result['RemindName'] = self.remind_name
        if self.remind_type is not None:
            result['RemindType'] = self.remind_type
        if self.remind_unit is not None:
            result['RemindUnit'] = self.remind_unit
        if self.robot_urls is not None:
            result['RobotUrls'] = self.robot_urls
        if self.webhooks is not None:
            result['Webhooks'] = self.webhooks
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertInterval') is not None:
            self.alert_interval = m.get('AlertInterval')
        if m.get('AlertMethods') is not None:
            self.alert_methods = m.get('AlertMethods')
        if m.get('AlertTargets') is not None:
            self.alert_targets = m.get('AlertTargets')
        if m.get('AlertUnit') is not None:
            self.alert_unit = m.get('AlertUnit')
        if m.get('BaselineIds') is not None:
            self.baseline_ids = m.get('BaselineIds')
        if m.get('BizProcessIds') is not None:
            self.biz_process_ids = m.get('BizProcessIds')
        if m.get('Detail') is not None:
            self.detail = m.get('Detail')
        if m.get('DndEnd') is not None:
            self.dnd_end = m.get('DndEnd')
        if m.get('MaxAlertTimes') is not None:
            self.max_alert_times = m.get('MaxAlertTimes')
        if m.get('NodeIds') is not None:
            self.node_ids = m.get('NodeIds')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RemindName') is not None:
            self.remind_name = m.get('RemindName')
        if m.get('RemindType') is not None:
            self.remind_type = m.get('RemindType')
        if m.get('RemindUnit') is not None:
            self.remind_unit = m.get('RemindUnit')
        if m.get('RobotUrls') is not None:
            self.robot_urls = m.get('RobotUrls')
        if m.get('Webhooks') is not None:
            self.webhooks = m.get('Webhooks')
        return self


class CreateRemindResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.data = data  # type: long
        self.error_code = error_code  # type: str
        # Indicates whether the request was successful.
        self.error_message = error_message  # type: str
        # The error message returned.
        self.http_status_code = http_status_code  # type: int
        # The error code returned.
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateRemindResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateRemindResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateRemindResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateRemindResponse, self).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=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 = CreateRemindResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateResourceFileRequest(TeaModel):
    def __init__(self, content=None, file_description=None, file_folder_path=None, file_name=None, file_type=None,
                 origin_resource_name=None, owner=None, project_id=None, register_to_calc_engine=None, resource_file=None,
                 storage_url=None, upload_mode=None):
        self.content = content  # type: str
        self.file_description = file_description  # type: str
        self.file_folder_path = file_folder_path  # type: str
        self.file_name = file_name  # type: str
        self.file_type = file_type  # type: int
        self.origin_resource_name = origin_resource_name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: long
        self.register_to_calc_engine = register_to_calc_engine  # type: bool
        self.resource_file = resource_file  # type: str
        self.storage_url = storage_url  # type: str
        self.upload_mode = upload_mode  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateResourceFileRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.file_description is not None:
            result['FileDescription'] = self.file_description
        if self.file_folder_path is not None:
            result['FileFolderPath'] = self.file_folder_path
        if self.file_name is not None:
            result['FileName'] = self.file_name
        if self.file_type is not None:
            result['FileType'] = self.file_type
        if self.origin_resource_name is not None:
            result['OriginResourceName'] = self.origin_resource_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.register_to_calc_engine is not None:
            result['RegisterToCalcEngine'] = self.register_to_calc_engine
        if self.resource_file is not None:
            result['ResourceFile'] = self.resource_file
        if self.storage_url is not None:
            result['StorageURL'] = self.storage_url
        if self.upload_mode is not None:
            result['UploadMode'] = self.upload_mode
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('FileDescription') is not None:
            self.file_description = m.get('FileDescription')
        if m.get('FileFolderPath') is not None:
            self.file_folder_path = m.get('FileFolderPath')
        if m.get('FileName') is not None:
            self.file_name = m.get('FileName')
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        if m.get('OriginResourceName') is not None:
            self.origin_resource_name = m.get('OriginResourceName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RegisterToCalcEngine') is not None:
            self.register_to_calc_engine = m.get('RegisterToCalcEngine')
        if m.get('ResourceFile') is not None:
            self.resource_file = m.get('ResourceFile')
        if m.get('StorageURL') is not None:
            self.storage_url = m.get('StorageURL')
        if m.get('UploadMode') is not None:
            self.upload_mode = m.get('UploadMode')
        return self


class CreateResourceFileAdvanceRequest(TeaModel):
    def __init__(self, content=None, file_description=None, file_folder_path=None, file_name=None, file_type=None,
                 origin_resource_name=None, owner=None, project_id=None, register_to_calc_engine=None, resource_file_object=None,
                 storage_url=None, upload_mode=None):
        self.content = content  # type: str
        self.file_description = file_description  # type: str
        self.file_folder_path = file_folder_path  # type: str
        self.file_name = file_name  # type: str
        self.file_type = file_type  # type: int
        self.origin_resource_name = origin_resource_name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: long
        self.register_to_calc_engine = register_to_calc_engine  # type: bool
        self.resource_file_object = resource_file_object  # type: READABLE
        self.storage_url = storage_url  # type: str
        self.upload_mode = upload_mode  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateResourceFileAdvanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.file_description is not None:
            result['FileDescription'] = self.file_description
        if self.file_folder_path is not None:
            result['FileFolderPath'] = self.file_folder_path
        if self.file_name is not None:
            result['FileName'] = self.file_name
        if self.file_type is not None:
            result['FileType'] = self.file_type
        if self.origin_resource_name is not None:
            result['OriginResourceName'] = self.origin_resource_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.register_to_calc_engine is not None:
            result['RegisterToCalcEngine'] = self.register_to_calc_engine
        if self.resource_file_object is not None:
            result['ResourceFile'] = self.resource_file_object
        if self.storage_url is not None:
            result['StorageURL'] = self.storage_url
        if self.upload_mode is not None:
            result['UploadMode'] = self.upload_mode
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('FileDescription') is not None:
            self.file_description = m.get('FileDescription')
        if m.get('FileFolderPath') is not None:
            self.file_folder_path = m.get('FileFolderPath')
        if m.get('FileName') is not None:
            self.file_name = m.get('FileName')
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        if m.get('OriginResourceName') is not None:
            self.origin_resource_name = m.get('OriginResourceName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RegisterToCalcEngine') is not None:
            self.register_to_calc_engine = m.get('RegisterToCalcEngine')
        if m.get('ResourceFile') is not None:
            self.resource_file_object = m.get('ResourceFile')
        if m.get('StorageURL') is not None:
            self.storage_url = m.get('StorageURL')
        if m.get('UploadMode') is not None:
            self.upload_mode = m.get('UploadMode')
        return self


class CreateResourceFileResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None):
        self.data = data  # type: long
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateResourceFileResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class CreateResourceFileResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateResourceFileResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateResourceFileResponse, self).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=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 = CreateResourceFileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateTableRequestColumns(TeaModel):
    def __init__(self, column_name=None, column_name_cn=None, column_type=None, comment=None, is_partition_col=None,
                 length=None, seq_number=None):
        # The comment of the field.
        self.column_name = column_name  # type: str
        # The name of the field.
        # 
        # You can call the CreateTable operation to configure a maximum of 1,000 fields.
        self.column_name_cn = column_name_cn  # type: str
        # The sequence number of the field. You can use this parameter to specify how fields are sorted in a table. By default, fields are sorted in the order in which requests are created.
        # 
        # If the field is a partition field, this parameter is not supported.
        self.column_type = column_type  # type: str
        # The data type of the field.
        self.comment = comment  # type: str
        # The ID of the topic.
        self.is_partition_col = is_partition_col  # type: bool
        # Specifies whether the current field is a partition field.
        self.length = length  # type: int
        # The length of the field. For more information, see [MaxCompute V2.0 data type edition](~~159541#concept-2454988~~).
        self.seq_number = seq_number  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateTableRequestColumns, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.column_name_cn is not None:
            result['ColumnNameCn'] = self.column_name_cn
        if self.column_type is not None:
            result['ColumnType'] = self.column_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.is_partition_col is not None:
            result['IsPartitionCol'] = self.is_partition_col
        if self.length is not None:
            result['Length'] = self.length
        if self.seq_number is not None:
            result['SeqNumber'] = self.seq_number
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('ColumnNameCn') is not None:
            self.column_name_cn = m.get('ColumnNameCn')
        if m.get('ColumnType') is not None:
            self.column_type = m.get('ColumnType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('IsPartitionCol') is not None:
            self.is_partition_col = m.get('IsPartitionCol')
        if m.get('Length') is not None:
            self.length = m.get('Length')
        if m.get('SeqNumber') is not None:
            self.seq_number = m.get('SeqNumber')
        return self


class CreateTableRequestThemes(TeaModel):
    def __init__(self, theme_id=None, theme_level=None):
        # The level that corresponds to the topic ID.
        self.theme_id = theme_id  # type: long
        # The ID of the request.
        self.theme_level = theme_level  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateTableRequestThemes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.theme_id is not None:
            result['ThemeId'] = self.theme_id
        if self.theme_level is not None:
            result['ThemeLevel'] = self.theme_level
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ThemeId') is not None:
            self.theme_id = m.get('ThemeId')
        if m.get('ThemeLevel') is not None:
            self.theme_level = m.get('ThemeLevel')
        return self


class CreateTableRequest(TeaModel):
    def __init__(self, app_guid=None, category_id=None, client_token=None, columns=None, comment=None, endpoint=None,
                 env_type=None, external_table_type=None, has_part=None, is_view=None, life_cycle=None, location=None,
                 logical_level_id=None, owner_id=None, physics_level_id=None, project_id=None, schema=None, table_name=None,
                 themes=None, visibility=None):
        # The comment.
        self.app_guid = app_guid  # type: str
        # The ID of the logical level.
        self.category_id = category_id  # type: long
        # The schema information of the table. You need to enter the schema information of the table if you enable the table schema in MaxCompute.
        self.client_token = client_token  # type: str
        self.columns = columns  # type: list[CreateTableRequestColumns]
        # Specifies whether the MaxCompute table is a partitioned table. Valid values: 1 and 0. The value 1 indicates that the MaxCompute table is a partitioned table. The value 0 indicates that the MaxCompute table is not a partitioned table. This parameter is deprecated. Do not use this parameter.
        # 
        # The Column.N.isPartitionCol parameter is used to specify whether the MaxCompute table is a partitioned table. If the Column.N.isPartitionCol parameter is set to true, the MaxCompute table is a partitioned table.
        self.comment = comment  # type: str
        # The environment of the DataWorks workspace. Valid values:
        # 
        # *   0: development environment
        # *   1: production environment
        self.endpoint = endpoint  # type: str
        # The globally unique identifier (GUID) of the MaxCompute project. Specify the GUID in the odps.{projectName} format.
        self.env_type = env_type  # type: int
        # The storage location of the external table.
        self.external_table_type = external_table_type  # type: str
        # A reserved parameter.
        self.has_part = has_part  # type: int
        # Specifies whether the table or workspace is visible:
        # 
        # *   0: Both the table and workspace are not visible.
        # *   1: The table and workspace are visible.
        # *   2: Only the workspace is visible.
        self.is_view = is_view  # type: int
        # The ID of the associated category. You can call the [GetMetaCategory](~~173932~~) operation to query the ID of the category that can be associated.
        self.life_cycle = life_cycle  # type: int
        # The ID of the DataWorks workspace.
        self.location = location  # type: str
        # The ID of the physical level.
        self.logical_level_id = logical_level_id  # type: long
        self.owner_id = owner_id  # type: str
        # The storage type of the external table. Valid values:
        # 
        # *   0: Object Storage Service (OSS)
        # *   1: Tablestore
        # *   2: Volume
        # *   3: MySQL
        self.physics_level_id = physics_level_id  # type: long
        # The name of the table.
        self.project_id = project_id  # type: long
        # The display name of the field.
        self.schema = schema  # type: str
        # The endpoint of MaxCompute.
        self.table_name = table_name  # type: str
        self.themes = themes  # type: list[CreateTableRequestThemes]
        # The lifecycle of the table. Unit: days. By default, this parameter is left empty, which indicates that the table is permanently stored.
        self.visibility = visibility  # type: int

    def validate(self):
        if self.columns:
            for k in self.columns:
                if k:
                    k.validate()
        if self.themes:
            for k in self.themes:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(CreateTableRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.app_guid is not None:
            result['AppGuid'] = self.app_guid
        if self.category_id is not None:
            result['CategoryId'] = self.category_id
        if self.client_token is not None:
            result['ClientToken'] = self.client_token
        result['Columns'] = []
        if self.columns is not None:
            for k in self.columns:
                result['Columns'].append(k.to_map() if k else None)
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.endpoint is not None:
            result['Endpoint'] = self.endpoint
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.external_table_type is not None:
            result['ExternalTableType'] = self.external_table_type
        if self.has_part is not None:
            result['HasPart'] = self.has_part
        if self.is_view is not None:
            result['IsView'] = self.is_view
        if self.life_cycle is not None:
            result['LifeCycle'] = self.life_cycle
        if self.location is not None:
            result['Location'] = self.location
        if self.logical_level_id is not None:
            result['LogicalLevelId'] = self.logical_level_id
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.physics_level_id is not None:
            result['PhysicsLevelId'] = self.physics_level_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.schema is not None:
            result['Schema'] = self.schema
        if self.table_name is not None:
            result['TableName'] = self.table_name
        result['Themes'] = []
        if self.themes is not None:
            for k in self.themes:
                result['Themes'].append(k.to_map() if k else None)
        if self.visibility is not None:
            result['Visibility'] = self.visibility
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AppGuid') is not None:
            self.app_guid = m.get('AppGuid')
        if m.get('CategoryId') is not None:
            self.category_id = m.get('CategoryId')
        if m.get('ClientToken') is not None:
            self.client_token = m.get('ClientToken')
        self.columns = []
        if m.get('Columns') is not None:
            for k in m.get('Columns'):
                temp_model = CreateTableRequestColumns()
                self.columns.append(temp_model.from_map(k))
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('Endpoint') is not None:
            self.endpoint = m.get('Endpoint')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('ExternalTableType') is not None:
            self.external_table_type = m.get('ExternalTableType')
        if m.get('HasPart') is not None:
            self.has_part = m.get('HasPart')
        if m.get('IsView') is not None:
            self.is_view = m.get('IsView')
        if m.get('LifeCycle') is not None:
            self.life_cycle = m.get('LifeCycle')
        if m.get('Location') is not None:
            self.location = m.get('Location')
        if m.get('LogicalLevelId') is not None:
            self.logical_level_id = m.get('LogicalLevelId')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('PhysicsLevelId') is not None:
            self.physics_level_id = m.get('PhysicsLevelId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Schema') is not None:
            self.schema = m.get('Schema')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        self.themes = []
        if m.get('Themes') is not None:
            for k in m.get('Themes'):
                temp_model = CreateTableRequestThemes()
                self.themes.append(temp_model.from_map(k))
        if m.get('Visibility') is not None:
            self.visibility = m.get('Visibility')
        return self


class CreateTableResponseBodyTaskInfo(TeaModel):
    def __init__(self, content=None, next_task_id=None, status=None, task_id=None):
        self.content = content  # type: str
        # The ID of the current subtask.
        self.next_task_id = next_task_id  # type: str
        # The ID of the subtask that you want to run. If this parameter is left empty, all subtasks are complete. You can call the [GetDDLJobStatus](~~185659~~) operation to query the status of the subtask based on the subtask ID.
        self.status = status  # type: str
        # Details about the status of the current subtask.
        # 
        # *   If the current subtask succeeds, success is returned.
        # *   If the current subtask fails, the error details are displayed.
        self.task_id = task_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateTableResponseBodyTaskInfo, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.next_task_id is not None:
            result['NextTaskId'] = self.next_task_id
        if self.status is not None:
            result['Status'] = self.status
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('NextTaskId') is not None:
            self.next_task_id = m.get('NextTaskId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        return self


class CreateTableResponseBody(TeaModel):
    def __init__(self, request_id=None, task_info=None):
        # The information about the request task.
        # 
        # After a request task is submitted, it is divided into multiple subtasks that are run in sequence. After the current subtask is complete, the next subtask starts to run. After all subtasks are complete, the request task is complete.
        # 
        # If a request task is aborted due to one of the following issues, address the issue based on the error code and initiate the request task again:
        # 
        # *   The request task fails to be submitted.
        # *   After the request task is submitted, a subtask fails to run.
        self.request_id = request_id  # type: str
        # The status of the current subtask. Valid values:
        # 
        # *   operating: The subtask is running.
        # *   success: The subtask succeeds.
        # *   failure: The subtask fails to run. For more information about the error details, see the Content parameter.
        self.task_info = task_info  # type: CreateTableResponseBodyTaskInfo

    def validate(self):
        if self.task_info:
            self.task_info.validate()

    def to_map(self):
        _map = super(CreateTableResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.task_info is not None:
            result['TaskInfo'] = self.task_info.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TaskInfo') is not None:
            temp_model = CreateTableResponseBodyTaskInfo()
            self.task_info = temp_model.from_map(m['TaskInfo'])
        return self


class CreateTableResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateTableResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateTableResponse, self).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=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 = CreateTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateTableLevelRequest(TeaModel):
    def __init__(self, description=None, level_type=None, name=None, project_id=None):
        # Level Description
        self.description = description  # type: str
        # The ID of the region where the service is activated.
        self.level_type = level_type  # type: int
        # Level 1
        self.name = name  # type: str
        # The type of the table level. Valid values: 1 and 2. A value of 1 indicates the logical level. A value of 2 indicates the physical level.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateTableLevelRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        if self.level_type is not None:
            result['LevelType'] = self.level_type
        if self.name is not None:
            result['Name'] = self.name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('LevelType') is not None:
            self.level_type = m.get('LevelType')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class CreateTableLevelResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, level_id=None, request_id=None,
                 success=None):
        # Indicates whether the request is successful.
        self.error_code = error_code  # type: str
        # The error code returned.
        self.error_message = error_message  # type: str
        # The ID of the request.
        self.http_status_code = http_status_code  # type: int
        self.level_id = level_id  # type: long
        # 1AAE721C-F9EC-5923-BAFC-99802C4E0F21
        self.request_id = request_id  # type: str
        # The ID of the table level.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateTableLevelResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.level_id is not None:
            result['LevelId'] = self.level_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('LevelId') is not None:
            self.level_id = m.get('LevelId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateTableLevelResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateTableLevelResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateTableLevelResponse, self).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=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 = CreateTableLevelResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateTableThemeRequest(TeaModel):
    def __init__(self, level=None, name=None, parent_id=None, project_id=None):
        # The level of the table folder. Valid values: 1 and 2. A value of 1 indicates a first-level table folder. A value of 2 indicates a second-level table folder.
        self.level = level  # type: int
        # The name of the table folder.
        self.name = name  # type: str
        # The ID of the level of the parent table folder.
        self.parent_id = parent_id  # type: long
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateTableThemeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.level is not None:
            result['Level'] = self.level
        if self.name is not None:
            result['Name'] = self.name
        if self.parent_id is not None:
            result['ParentId'] = self.parent_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Level') is not None:
            self.level = m.get('Level')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ParentId') is not None:
            self.parent_id = m.get('ParentId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class CreateTableThemeResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, success=None,
                 theme_id=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool
        # The ID of the created table folder.
        self.theme_id = theme_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateTableThemeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        if self.theme_id is not None:
            result['ThemeId'] = self.theme_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        if m.get('ThemeId') is not None:
            self.theme_id = m.get('ThemeId')
        return self


class CreateTableThemeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateTableThemeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateTableThemeResponse, self).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=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 = CreateTableThemeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateUdfFileRequest(TeaModel):
    def __init__(self, class_name=None, cmd_description=None, create_folder_if_not_exists=None, example=None,
                 file_folder_path=None, file_name=None, function_type=None, parameter_description=None, project_id=None,
                 project_identifier=None, resources=None, return_value=None, udf_description=None):
        # The name of the class in which the function is defined. This parameter corresponds to the Class Name parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.class_name = class_name  # type: str
        # The syntax used for calling the function. This parameter corresponds to the Expression Syntax parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.cmd_description = cmd_description  # type: str
        self.create_folder_if_not_exists = create_folder_if_not_exists  # type: bool
        # The example for calling the function. This parameter corresponds to the Example parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.example = example  # type: str
        # The path of the folder in which the file for the function is stored.
        self.file_folder_path = file_folder_path  # type: str
        # The name of the file for the function.
        self.file_name = file_name  # type: str
        # The type of the function. Valid values: MATH, AGGREGATE, STRING, DATE, ANALYTIC, and OTHER. This parameter corresponds to the Function Type parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.function_type = function_type  # type: str
        # The description of the input parameters of the function. This parameter corresponds to the Parameter Description parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.parameter_description = parameter_description  # type: str
        # The ID of the DataWorks workspace. You can click the Workspace Manage icon in the upper-right corner of the DataStudio page to go to the Workspace Management page and view the workspace ID.
        self.project_id = project_id  # type: long
        # The unique identifier of the DataWorks workspace. You can click the identifier in the upper-left corner of the DataStudio page to switch to another workspace.
        # 
        # You must specify either this parameter or the projectId parameter to determine the DataWorks workspace to which the operation is called.
        self.project_identifier = project_identifier  # type: str
        # The names of the resources that are referenced by the function. This parameter corresponds to the Resources parameter in the Register Function section of the configuration tab of the function in the DataWorks console. Multiple resource names are separated by commas (,).
        self.resources = resources  # type: str
        # The description of the return value of the function. This parameter corresponds to the Return Value parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.return_value = return_value  # type: str
        # The description of the function. This parameter corresponds to the Description parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.udf_description = udf_description  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateUdfFileRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.class_name is not None:
            result['ClassName'] = self.class_name
        if self.cmd_description is not None:
            result['CmdDescription'] = self.cmd_description
        if self.create_folder_if_not_exists is not None:
            result['CreateFolderIfNotExists'] = self.create_folder_if_not_exists
        if self.example is not None:
            result['Example'] = self.example
        if self.file_folder_path is not None:
            result['FileFolderPath'] = self.file_folder_path
        if self.file_name is not None:
            result['FileName'] = self.file_name
        if self.function_type is not None:
            result['FunctionType'] = self.function_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.resources is not None:
            result['Resources'] = self.resources
        if self.return_value is not None:
            result['ReturnValue'] = self.return_value
        if self.udf_description is not None:
            result['UdfDescription'] = self.udf_description
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClassName') is not None:
            self.class_name = m.get('ClassName')
        if m.get('CmdDescription') is not None:
            self.cmd_description = m.get('CmdDescription')
        if m.get('CreateFolderIfNotExists') is not None:
            self.create_folder_if_not_exists = m.get('CreateFolderIfNotExists')
        if m.get('Example') is not None:
            self.example = m.get('Example')
        if m.get('FileFolderPath') is not None:
            self.file_folder_path = m.get('FileFolderPath')
        if m.get('FileName') is not None:
            self.file_name = m.get('FileName')
        if m.get('FunctionType') is not None:
            self.function_type = m.get('FunctionType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('Resources') is not None:
            self.resources = m.get('Resources')
        if m.get('ReturnValue') is not None:
            self.return_value = m.get('ReturnValue')
        if m.get('UdfDescription') is not None:
            self.udf_description = m.get('UdfDescription')
        return self


class CreateUdfFileResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the file that was created.
        self.data = data  # type: long
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(CreateUdfFileResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class CreateUdfFileResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: CreateUdfFileResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(CreateUdfFileResponse, self).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=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 = CreateUdfFileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteBaselineRequest(TeaModel):
    def __init__(self, baseline_id=None, project_id=None):
        self.baseline_id = baseline_id  # type: long
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteBaselineRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class DeleteBaselineResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: bool
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteBaselineResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteBaselineResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteBaselineResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteBaselineResponse, self).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=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 = DeleteBaselineResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteBusinessRequest(TeaModel):
    def __init__(self, business_id=None, project_id=None, project_identifier=None):
        # The ID of the workflow. You can call the [ListBusiness](~~173945~~) operation to query the workflow ID.
        self.business_id = business_id  # type: long
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID. You must specify either this parameter or ProjectIdentifier to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Settings panel to obtain the name. You must specify either this parameter or ProjectId to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteBusinessRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class DeleteBusinessResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, success=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteBusinessResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteBusinessResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteBusinessResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteBusinessResponse, self).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=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 = DeleteBusinessResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteConnectionRequest(TeaModel):
    def __init__(self, connection_id=None):
        self.connection_id = connection_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteConnectionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_id is not None:
            result['ConnectionId'] = self.connection_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionId') is not None:
            self.connection_id = m.get('ConnectionId')
        return self


class DeleteConnectionResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        self.data = data  # type: bool
        self.http_status_code = http_status_code  # type: str
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteConnectionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteConnectionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteConnectionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteConnectionResponse, self).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=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 = DeleteConnectionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteDIAlarmRuleRequest(TeaModel):
    def __init__(self, dialarm_rule_id=None):
        self.dialarm_rule_id = dialarm_rule_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDIAlarmRuleRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dialarm_rule_id is not None:
            result['DIAlarmRuleId'] = self.dialarm_rule_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIAlarmRuleId') is not None:
            self.dialarm_rule_id = m.get('DIAlarmRuleId')
        return self


class DeleteDIAlarmRuleResponseBody(TeaModel):
    def __init__(self, request_id=None):
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDIAlarmRuleResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DeleteDIAlarmRuleResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteDIAlarmRuleResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteDIAlarmRuleResponse, self).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=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 = DeleteDIAlarmRuleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteDIJobRequest(TeaModel):
    def __init__(self, dijob_id=None):
        self.dijob_id = dijob_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDIJobRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        return self


class DeleteDIJobResponseBody(TeaModel):
    def __init__(self, request_id=None):
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDIJobResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DeleteDIJobResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteDIJobResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteDIJobResponse, self).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=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 = DeleteDIJobResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteDISyncTaskRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, task_type=None):
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request failed.
        self.file_id = file_id  # type: long
        # The type of the synchronization node in Data Integration.
        # 
        # The parameter value is DI_REALTIME and cannot be changed. The value indicates a real-time synchronization node.
        self.project_id = project_id  # type: long
        # The ID of the real-time synchronization node. You can call the [ListFiles](~~173942~~) operation to query the ID of the node.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDISyncTaskRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class DeleteDISyncTaskResponseBodyData(TeaModel):
    def __init__(self, message=None, status=None):
        self.message = message  # type: str
        # The reason why the synchronization node in Data Integration failed to be deleted.
        # 
        # If the synchronization node in Data Integration is deleted, the value null is returned.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDISyncTaskResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class DeleteDISyncTaskResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # Indicates whether the synchronization node in Data Integration is deleted. Valid values:
        # 
        # *   success: The synchronization node in Data Integration is deleted.
        # *   fail: The synchronization node in Data Integration failed to be deleted. You can troubleshoot the issue based on the failure reason.
        self.data = data  # type: DeleteDISyncTaskResponseBodyData
        # The result returned after you called the DeleteDISyncTask operation.
        self.request_id = request_id  # type: str
        # The ID of the request. You can use the ID to locate logs and troubleshoot issues.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(DeleteDISyncTaskResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = DeleteDISyncTaskResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteDISyncTaskResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteDISyncTaskResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteDISyncTaskResponse, self).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=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 = DeleteDISyncTaskResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteDataServiceApiRequest(TeaModel):
    def __init__(self, api_id=None, project_id=None, tenant_id=None):
        # The ID of the API in DataService Studio.
        self.api_id = api_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDataServiceApiRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class DeleteDataServiceApiResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the API was deleted.
        self.data = data  # type: bool
        # The error code.
        self.error_code = error_code  # type: str
        # The error message.
        self.error_message = error_message  # type: str
        # The HTTP status code.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDataServiceApiResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteDataServiceApiResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteDataServiceApiResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteDataServiceApiResponse, self).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=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 = DeleteDataServiceApiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteDataServiceApiAuthorityRequest(TeaModel):
    def __init__(self, api_id=None, authorized_project_id=None, project_id=None, tenant_id=None):
        # The ID of the API.
        self.api_id = api_id  # type: long
        # The ID of the workspace from which you want to revoke the access permissions on the API.
        self.authorized_project_id = authorized_project_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDataServiceApiAuthorityRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.authorized_project_id is not None:
            result['AuthorizedProjectId'] = self.authorized_project_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('AuthorizedProjectId') is not None:
            self.authorized_project_id = m.get('AuthorizedProjectId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class DeleteDataServiceApiAuthorityResponseBody(TeaModel):
    def __init__(self, request_id=None, success=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the access permissions are revoked.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDataServiceApiAuthorityResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteDataServiceApiAuthorityResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteDataServiceApiAuthorityResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteDataServiceApiAuthorityResponse, self).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=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 = DeleteDataServiceApiAuthorityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteDataSourceRequest(TeaModel):
    def __init__(self, data_source_id=None):
        # The ID of the data source. You can call the [ListDataSources](~~211431~~) operation to obtain the ID.
        self.data_source_id = data_source_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDataSourceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data_source_id is not None:
            result['DataSourceId'] = self.data_source_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DataSourceId') is not None:
            self.data_source_id = m.get('DataSourceId')
        return self


class DeleteDataSourceResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        # Indicates whether the request is successful.
        self.data = data  # type: bool
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: str
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteDataSourceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteDataSourceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteDataSourceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteDataSourceResponse, self).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=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 = DeleteDataSourceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteFileRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, project_identifier=None):
        # The HTTP status code.
        self.file_id = file_id  # type: long
        # The name of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to view the workspace name.
        # 
        # You must specify one of the ProjectId and ProjectIdentifier parameters to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The ID of the file. You can call the [ListFiles](~~173942~~) operation to query the ID of the file.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteFileRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class DeleteFileResponseBody(TeaModel):
    def __init__(self, deployment_id=None, error_code=None, error_message=None, http_status_code=None,
                 request_id=None, success=None):
        # The ID of the request. You can troubleshoot errors based on the ID.
        self.deployment_id = deployment_id  # type: long
        self.error_code = error_code  # type: str
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.error_message = error_message  # type: str
        # The ID of the deployment task that deploys the file. If the file has been committed, an asynchronous process is triggered to delete the file in the scheduling system. The value of this parameter is used to call the GetDeployment operation to poll the status of the asynchronous process.
        # 
        # If this parameter is empty, the file is deleted and the polling is not required.
        self.http_status_code = http_status_code  # type: int
        # The error message returned.
        self.request_id = request_id  # type: str
        # The error code returned.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteFileResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.deployment_id is not None:
            result['DeploymentId'] = self.deployment_id
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DeploymentId') is not None:
            self.deployment_id = m.get('DeploymentId')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteFileResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteFileResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteFileResponse, self).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=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 = DeleteFileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteFolderRequest(TeaModel):
    def __init__(self, folder_id=None, project_id=None, project_identifier=None):
        # The ID of the folder. You can call the [ListFolders](~~173955~~) operation to query the ID.
        self.folder_id = folder_id  # type: str
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID. You must specify either this parameter or ProjectIdentifier to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Settings panel to obtain the name. You must specify either this parameter or ProjectId to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteFolderRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class DeleteFolderResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, success=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteFolderResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteFolderResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteFolderResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteFolderResponse, self).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=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 = DeleteFolderResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteFromMetaCategoryRequest(TeaModel):
    def __init__(self, category_id=None, table_guid=None):
        # The ID of the category.
        self.category_id = category_id  # type: long
        # The GUID of the metatable.
        self.table_guid = table_guid  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteFromMetaCategoryRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.category_id is not None:
            result['CategoryId'] = self.category_id
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CategoryId') is not None:
            self.category_id = m.get('CategoryId')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        return self


class DeleteFromMetaCategoryResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the metatable was removed from the specified category.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteFromMetaCategoryResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteFromMetaCategoryResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteFromMetaCategoryResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteFromMetaCategoryResponse, self).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=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 = DeleteFromMetaCategoryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteLineageRelationRequest(TeaModel):
    def __init__(self, dest_entity_qualified_name=None, relationship_guid=None, src_entity_qualified_name=None):
        self.dest_entity_qualified_name = dest_entity_qualified_name  # type: str
        self.relationship_guid = relationship_guid  # type: str
        self.src_entity_qualified_name = src_entity_qualified_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteLineageRelationRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dest_entity_qualified_name is not None:
            result['DestEntityQualifiedName'] = self.dest_entity_qualified_name
        if self.relationship_guid is not None:
            result['RelationshipGuid'] = self.relationship_guid
        if self.src_entity_qualified_name is not None:
            result['SrcEntityQualifiedName'] = self.src_entity_qualified_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DestEntityQualifiedName') is not None:
            self.dest_entity_qualified_name = m.get('DestEntityQualifiedName')
        if m.get('RelationshipGuid') is not None:
            self.relationship_guid = m.get('RelationshipGuid')
        if m.get('SrcEntityQualifiedName') is not None:
            self.src_entity_qualified_name = m.get('SrcEntityQualifiedName')
        return self


class DeleteLineageRelationResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, status=None,
                 success=None):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.status = status  # type: bool
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteLineageRelationResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.status is not None:
            result['Status'] = self.status
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteLineageRelationResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteLineageRelationResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteLineageRelationResponse, self).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=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 = DeleteLineageRelationResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteMetaCategoryRequest(TeaModel):
    def __init__(self, category_id=None):
        # The ID of the category.
        self.category_id = category_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteMetaCategoryRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.category_id is not None:
            result['CategoryId'] = self.category_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CategoryId') is not None:
            self.category_id = m.get('CategoryId')
        return self


class DeleteMetaCategoryResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The business data returned.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteMetaCategoryResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteMetaCategoryResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteMetaCategoryResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteMetaCategoryResponse, self).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=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 = DeleteMetaCategoryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteMetaCollectionRequest(TeaModel):
    def __init__(self, qualified_name=None):
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.qualified_name = qualified_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteMetaCollectionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        return self


class DeleteMetaCollectionResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, status=None,
                 success=None):
        # Indicates whether the request was successful. Valid values:
        # 
        # true: The request was successful.
        # 
        # false: The request failed.
        self.error_code = error_code  # type: str
        # The error code returned.
        self.error_message = error_message  # type: str
        # The error message returned.
        self.http_status_code = http_status_code  # type: int
        # The result of the operation. Valid values:
        # 
        # true: succeeded
        # 
        # false: failed
        self.request_id = request_id  # type: str
        # The HTTP status code returned.
        self.status = status  # type: bool
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteMetaCollectionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.status is not None:
            result['Status'] = self.status
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteMetaCollectionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteMetaCollectionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteMetaCollectionResponse, self).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=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 = DeleteMetaCollectionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteMetaCollectionEntityRequest(TeaModel):
    def __init__(self, collection_qualified_name=None, entity_qualified_name=None):
        # The unique identifier of the entity.
        self.collection_qualified_name = collection_qualified_name  # type: str
        # The ID of the request.
        self.entity_qualified_name = entity_qualified_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteMetaCollectionEntityRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.collection_qualified_name is not None:
            result['CollectionQualifiedName'] = self.collection_qualified_name
        if self.entity_qualified_name is not None:
            result['EntityQualifiedName'] = self.entity_qualified_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CollectionQualifiedName') is not None:
            self.collection_qualified_name = m.get('CollectionQualifiedName')
        if m.get('EntityQualifiedName') is not None:
            self.entity_qualified_name = m.get('EntityQualifiedName')
        return self


class DeleteMetaCollectionEntityResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, status=None,
                 success=None):
        # Indicates whether the request was successful. Valid values:
        # 
        # true: The request was successful.
        # 
        # false: The request failed.
        self.error_code = error_code  # type: str
        # The error code returned.
        self.error_message = error_message  # type: str
        # The error message returned.
        self.http_status_code = http_status_code  # type: int
        # The result of the operation. Valid values:
        # 
        # true: succeeded
        # 
        # false: failed
        self.request_id = request_id  # type: str
        # The HTTP status code returned.
        self.status = status  # type: bool
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteMetaCollectionEntityResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.status is not None:
            result['Status'] = self.status
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteMetaCollectionEntityResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteMetaCollectionEntityResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteMetaCollectionEntityResponse, self).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=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 = DeleteMetaCollectionEntityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteProjectMemberRequest(TeaModel):
    def __init__(self, project_id=None, user_id=None):
        # The ID of the region.
        self.project_id = project_id  # type: long
        self.user_id = user_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteProjectMemberRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.user_id is not None:
            result['UserId'] = self.user_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('UserId') is not None:
            self.user_id = m.get('UserId')
        return self


class DeleteProjectMemberResponseBody(TeaModel):
    def __init__(self, request_id=None):
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteProjectMemberResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DeleteProjectMemberResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteProjectMemberResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteProjectMemberResponse, self).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=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 = DeleteProjectMemberResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteQualityEntityRequest(TeaModel):
    def __init__(self, entity_id=None, env_type=None, project_id=None, project_name=None):
        # The ID of the partition filter expression.
        self.entity_id = entity_id  # type: long
        # The type of the compute engine instance or data source. Valid values: EMR, Hologres, AnalyticDB for PostgreSQL, CDH, MaxCompute, Kafka and DataHub.
        self.env_type = env_type  # type: str
        self.project_id = project_id  # type: long
        # The name of the compute engine instance or data source.
        self.project_name = project_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteQualityEntityRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class DeleteQualityEntityResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The result returned.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteQualityEntityResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteQualityEntityResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteQualityEntityResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteQualityEntityResponse, self).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=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 = DeleteQualityEntityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteQualityFollowerRequest(TeaModel):
    def __init__(self, follower_id=None, project_id=None, project_name=None):
        # The ID of the subscription relationship between the partition filter expression and the subscriber. You can call the [GetQualityFollower](~~174000~~) operation to obtain the ID of the subscription relationship.
        self.follower_id = follower_id  # type: long
        self.project_id = project_id  # type: long
        # The name of the compute engine or data source for which the partition filter expression is configured. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Monitoring Rules page of Data Quality to obtain the name.
        self.project_name = project_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteQualityFollowerRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.follower_id is not None:
            result['FollowerId'] = self.follower_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FollowerId') is not None:
            self.follower_id = m.get('FollowerId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class DeleteQualityFollowerResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the subscriber was successfully deleted. Valid values:
        # 
        # *   true: The subscriber was successfully deleted.
        # *   false: The subscriber failed to be deleted. You can troubleshoot errors based on the error message returned.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned when the subscriber failed to be deleted.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot errors.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteQualityFollowerResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteQualityFollowerResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteQualityFollowerResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteQualityFollowerResponse, self).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=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 = DeleteQualityFollowerResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteQualityRelativeNodeRequest(TeaModel):
    def __init__(self, env_type=None, match_expression=None, node_id=None, project_id=None, project_name=None,
                 table_name=None, target_node_project_id=None, target_node_project_name=None):
        # The environment in which the compute engine instance runs. Valid values: DEV and PRD. The value DEV indicates the development environment, and the value PRD indicates the production environment.
        self.env_type = env_type  # type: str
        # The partition filter expression.
        self.match_expression = match_expression  # type: str
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The name of the compute engine instance or data source.
        self.project_name = project_name  # type: str
        # The name of the table that is generated by the node.
        self.table_name = table_name  # type: str
        # The ID of the workspace to which the node associated with the partition filter expression belongs.
        self.target_node_project_id = target_node_project_id  # type: long
        # The name of the workspace to which the node associated with the partition filter expression belongs.
        self.target_node_project_name = target_node_project_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteQualityRelativeNodeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.match_expression is not None:
            result['MatchExpression'] = self.match_expression
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.target_node_project_id is not None:
            result['TargetNodeProjectId'] = self.target_node_project_id
        if self.target_node_project_name is not None:
            result['TargetNodeProjectName'] = self.target_node_project_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('MatchExpression') is not None:
            self.match_expression = m.get('MatchExpression')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('TargetNodeProjectId') is not None:
            self.target_node_project_id = m.get('TargetNodeProjectId')
        if m.get('TargetNodeProjectName') is not None:
            self.target_node_project_name = m.get('TargetNodeProjectName')
        return self


class DeleteQualityRelativeNodeResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the node is disassociated from the partition filter expression.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteQualityRelativeNodeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteQualityRelativeNodeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteQualityRelativeNodeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteQualityRelativeNodeResponse, self).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=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 = DeleteQualityRelativeNodeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteQualityRuleRequest(TeaModel):
    def __init__(self, project_id=None, project_name=None, rule_id=None):
        self.project_id = project_id  # type: long
        # The name of the database engine or data source.
        self.project_name = project_name  # type: str
        # The ID of the rule.
        self.rule_id = rule_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteQualityRuleRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.rule_id is not None:
            result['RuleId'] = self.rule_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('RuleId') is not None:
            self.rule_id = m.get('RuleId')
        return self


class DeleteQualityRuleResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the deletion was successful.
        self.data = data  # type: bool
        # The error code.
        self.error_code = error_code  # type: str
        # The returned message.
        self.error_message = error_message  # type: str
        # The HTTP status code.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the call is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteQualityRuleResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteQualityRuleResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteQualityRuleResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteQualityRuleResponse, self).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=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 = DeleteQualityRuleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteRemindRequest(TeaModel):
    def __init__(self, remind_id=None):
        # The ID of the custom alert rule.
        self.remind_id = remind_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteRemindRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.remind_id is not None:
            result['RemindId'] = self.remind_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RemindId') is not None:
            self.remind_id = m.get('RemindId')
        return self


class DeleteRemindResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the custom alert rule is deleted. Valid values: true and false. The value true indicates that the custom alert rule is deleted. The value false indicates that the custom alert rule fails to be deleted.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteRemindResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteRemindResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteRemindResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteRemindResponse, self).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=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 = DeleteRemindResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteTableRequest(TeaModel):
    def __init__(self, app_guid=None, env_type=None, project_id=None, schema=None, table_name=None):
        # The globally unique identifier (GUID) of the MaxCompute project. Specify the GUID in the odps.{projectName} format.
        self.app_guid = app_guid  # type: str
        # The environment of the DataWorks workspace. Valid values: 0 and 1. The value 0 indicates the development environment. The value 1 indicates the production environment.
        self.env_type = env_type  # type: int
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long
        # The schema information of the table. You need to enter the schema information of the table if you enable the table schema in MaxCompute.
        self.schema = schema  # type: str
        # The name of the MaxCompute table.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteTableRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.app_guid is not None:
            result['AppGuid'] = self.app_guid
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.schema is not None:
            result['Schema'] = self.schema
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AppGuid') is not None:
            self.app_guid = m.get('AppGuid')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Schema') is not None:
            self.schema = m.get('Schema')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class DeleteTableResponseBodyTaskInfo(TeaModel):
    def __init__(self, content=None, next_task_id=None, status=None, task_id=None):
        # The content of the task.
        self.content = content  # type: str
        # The ID of the task that is running.
        self.next_task_id = next_task_id  # type: str
        # The status of the task that is complete.
        self.status = status  # type: str
        # The ID of the task that is complete.
        self.task_id = task_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteTableResponseBodyTaskInfo, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.next_task_id is not None:
            result['NextTaskId'] = self.next_task_id
        if self.status is not None:
            result['Status'] = self.status
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('NextTaskId') is not None:
            self.next_task_id = m.get('NextTaskId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        return self


class DeleteTableResponseBody(TeaModel):
    def __init__(self, request_id=None, task_info=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # The information about the task that is used to delete the table.
        self.task_info = task_info  # type: DeleteTableResponseBodyTaskInfo

    def validate(self):
        if self.task_info:
            self.task_info.validate()

    def to_map(self):
        _map = super(DeleteTableResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.task_info is not None:
            result['TaskInfo'] = self.task_info.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TaskInfo') is not None:
            temp_model = DeleteTableResponseBodyTaskInfo()
            self.task_info = temp_model.from_map(m['TaskInfo'])
        return self


class DeleteTableResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteTableResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteTableResponse, self).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=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 = DeleteTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteTableLevelRequest(TeaModel):
    def __init__(self, level_id=None, project_id=None):
        # The ID of the table level to be deleted. You can call the ListTableLevel operation to obtain the ID.
        self.level_id = level_id  # type: long
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteTableLevelRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.level_id is not None:
            result['LevelId'] = self.level_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('LevelId') is not None:
            self.level_id = m.get('LevelId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class DeleteTableLevelResponseBody(TeaModel):
    def __init__(self, delete_result=None, request_id=None):
        # Indicates whether the table level is deleted.
        self.delete_result = delete_result  # type: bool
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteTableLevelResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.delete_result is not None:
            result['DeleteResult'] = self.delete_result
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DeleteResult') is not None:
            self.delete_result = m.get('DeleteResult')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DeleteTableLevelResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteTableLevelResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteTableLevelResponse, self).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=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 = DeleteTableLevelResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteTableThemeRequest(TeaModel):
    def __init__(self, project_id=None, theme_id=None):
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long
        # The ID of the table folder.
        self.theme_id = theme_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteTableThemeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.theme_id is not None:
            result['ThemeId'] = self.theme_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ThemeId') is not None:
            self.theme_id = m.get('ThemeId')
        return self


class DeleteTableThemeResponseBody(TeaModel):
    def __init__(self, delete_result=None, error_code=None, error_message=None, http_status_code=None,
                 request_id=None, success=None):
        # Indicates whether the table folder is deleted.
        self.delete_result = delete_result  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteTableThemeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.delete_result is not None:
            result['DeleteResult'] = self.delete_result
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DeleteResult') is not None:
            self.delete_result = m.get('DeleteResult')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeleteTableThemeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteTableThemeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeleteTableThemeResponse, self).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=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 = DeleteTableThemeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeployDISyncTaskRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, task_type=None):
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.file_id = file_id  # type: long
        # The type of the object that you want to deploy. Valid values:
        # 
        # *   DI_REALTIME: real-time synchronization node
        # *   DI_SOLUTION: data synchronization solution
        self.project_id = project_id  # type: long
        # *   If you set the TaskType parameter to DI_REALTIME, set the FileId parameter to the ID of the real-time synchronization node that you want to deploy.
        # *   If you set the TaskType parameter to DI_SOLUTION, set the FileId parameter to the ID of the data synchronization solution that you want to deploy.
        # 
        # You can call the [ListFiles](~~173942~~) operation to query the ID of the real-time synchronization node or data synchronization solution.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeployDISyncTaskRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class DeployDISyncTaskResponseBodyData(TeaModel):
    def __init__(self, message=None, status=None):
        self.message = message  # type: str
        # The cause of the failure to deploy the real-time synchronization node or data synchronization solution.
        # 
        # If the real-time synchronization node or data synchronization solution is deployed, the value null is returned.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeployDISyncTaskResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class DeployDISyncTaskResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # Indicates whether the real-time synchronization node or data synchronization solution is deployed. Valid values:
        # 
        # *   success: The real-time synchronization node or data synchronization solution is deployed.
        # *   fail: The real-time synchronization node or data synchronization solution fails to be deployed.
        self.data = data  # type: DeployDISyncTaskResponseBodyData
        # The result of deploying the real-time synchronization node or data synchronization solution.
        self.request_id = request_id  # type: str
        # The ID of the request. You can query logs and troubleshoot issues based on the ID.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(DeployDISyncTaskResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = DeployDISyncTaskResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeployDISyncTaskResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeployDISyncTaskResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeployDISyncTaskResponse, self).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=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 = DeployDISyncTaskResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeployFileRequest(TeaModel):
    def __init__(self, comment=None, file_id=None, node_id=None, project_id=None, project_identifier=None):
        # The description of the deployment operation.
        self.comment = comment  # type: str
        # The ID of the file. You can call the [ListFiles](~~173942~~) operation to query the ID.
        # 
        # You must configure either the FileId parameter or the NodeId parameter.
        self.file_id = file_id  # type: long
        # The ID of the node in the scheduling system that corresponds to the file that you want to deploy. You must configure either the NodeId parameter or the FileId parameter.
        self.node_id = node_id  # type: long
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace ID. You must configure either this parameter or the ProjectIdentifier parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace name. You must configure either this parameter or the ProjectId parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeployFileRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class DeployFileResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the deployment task. The ID is used as the value of a specific request parameter when you call the [GetDeployment](~~173950~~) operation to query the details of the deployment task.
        self.data = data  # type: long
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeployFileResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class DeployFileResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeployFileResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DeployFileResponse, self).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=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 = DeployFileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DesensitizeDataRequest(TeaModel):
    def __init__(self, data=None, scene_code=None):
        # The data that you want to mask.
        self.data = data  # type: str
        # The code of the data masking scene. You can view the code on the Data Masking page in Data Security Guard of the DataWorks console.
        self.scene_code = scene_code  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DesensitizeDataRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.scene_code is not None:
            result['SceneCode'] = self.scene_code
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('SceneCode') is not None:
            self.scene_code = m.get('SceneCode')
        return self


class DesensitizeDataResponseBody(TeaModel):
    def __init__(self, desensitize_data=None, request_id=None):
        # The data returned after masking.
        self.desensitize_data = desensitize_data  # type: str
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DesensitizeDataResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.desensitize_data is not None:
            result['DesensitizeData'] = self.desensitize_data
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DesensitizeData') is not None:
            self.desensitize_data = m.get('DesensitizeData')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class DesensitizeDataResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DesensitizeDataResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(DesensitizeDataResponse, self).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=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 = DesensitizeDataResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class EstablishRelationTableToBusinessRequest(TeaModel):
    def __init__(self, business_id=None, folder_id=None, project_id=None, project_identifier=None, table_guid=None):
        # The ID of the workflow. You can call the [ListBusiness](~~173945~~) operation to query the ID.
        self.business_id = business_id  # type: str
        # The ID of the folder. You can call the [GetFolder](~~173952~~) or [ListFolders](~~173955~~) operation to query the ID.
        self.folder_id = folder_id  # type: str
        # The ID of the DataWorks workspace. You can click the Workspace Manage icon in the upper-right corner of the DataStudio page to go to the Workspace Management page and view the workspace ID.
        self.project_id = project_id  # type: long
        # The unique identifier of the DataWorks workspace. You can click the identifier in the upper-left corner of the DataStudio page to switch to another workspace.
        # 
        # You must specify either this parameter or ProjectId to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str
        # The universally unique identifier (UUID) of the table. You can call the [SearchMetaTables](~~173919~~) operation to query the UUID.
        self.table_guid = table_guid  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(EstablishRelationTableToBusinessRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        return self


class EstablishRelationTableToBusinessResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, success=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(EstablishRelationTableToBusinessResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class EstablishRelationTableToBusinessResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: EstablishRelationTableToBusinessResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(EstablishRelationTableToBusinessResponse, self).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=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 = EstablishRelationTableToBusinessResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ExportDataSourcesRequest(TeaModel):
    def __init__(self, data_source_type=None, env_type=None, name=None, page_number=None, page_size=None,
                 project_id=None, sub_type=None):
        # The data source type. Valid values:
        # 
        # *   odps
        # *   mysql
        # *   rds
        # *   oss
        # *   sqlserver
        # *   polardb
        # *   oracle
        # *   mongodb
        # *   emr
        # *   postgresql
        # *   analyticdb_for_mysql
        # *   hybriddb_for_postgresql
        # *   holo
        self.data_source_type = data_source_type  # type: str
        # The environment to which the data sources belong. Valid values:
        # 
        # *   0: development environment
        # *   1: production environment
        self.env_type = env_type  # type: int
        # The keyword contained in the names of the data sources to be exported.
        # 
        # You can specify only one keyword. For example, if you set this parameter to test, all the data sources whose names contain test in the specified workspace are exported.
        self.name = name  # type: str
        # The number of the page to return. The value of this parameter must be a positive integer greater than or equal to 1.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the DataWorks workspace to which the data sources belong. You can call the [ListProjects](~~178393~~) operation to query the ID of the workspace.
        self.project_id = project_id  # type: long
        # The data source subtype. This parameter takes effect only if the DataSourceType parameter is set to rds.
        # 
        # If the DataSourceType parameter is set to rds, this parameter can be set to mysql, sqlserver, or postgresql.
        self.sub_type = sub_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ExportDataSourcesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.name is not None:
            result['Name'] = self.name
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.sub_type is not None:
            result['SubType'] = self.sub_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SubType') is not None:
            self.sub_type = m.get('SubType')
        return self


class ExportDataSourcesResponseBodyDataDataSources(TeaModel):
    def __init__(self, binding_calc_engine_id=None, connect_status=None, content=None, data_source_type=None,
                 default_engine=None, description=None, env_type=None, gmt_create=None, gmt_modified=None, id=None, name=None,
                 operator=None, project_id=None, sequence=None, shared=None, status=None, sub_type=None, tenant_id=None):
        # The ID of the compute engine to which the data source is bound.
        self.binding_calc_engine_id = binding_calc_engine_id  # type: int
        # Indicates whether the data source is connected to an exclusive resource group. Valid values:
        # 
        # *   1: The data source is connected to at least one exclusive resource group.
        # *   0: The data source is not connected to any exclusive resource group.
        self.connect_status = connect_status  # type: int
        # The configuration of the data source.
        self.content = content  # type: str
        # The type of the data source. Valid values:
        # 
        # *   odps
        # *   mysql
        # *   rds
        # *   oss
        # *   sqlserver
        # *   polardb
        # *   oracle
        # *   mongodb
        # *   emr
        # *   postgresql
        # *   analyticdb_for_mysql
        # *   hybriddb_for_postgresql
        # *   holo
        self.data_source_type = data_source_type  # type: str
        # Indicates whether the compute engine to which the data source is bound is the default compute engine. Valid values:
        # 
        # *   true: The compute engine is the default compute engine.
        # *   false: The compute engine is not the default compute engine.
        self.default_engine = default_engine  # type: bool
        # The description of the data source.
        self.description = description  # type: str
        # The environment to which the data source belongs. Valid values:
        # 
        # *   0: development environment
        # *   1: production environment
        self.env_type = env_type  # type: int
        # The time when the data source was created. Example: Mar 17, 2021 4:09:32 PM.
        self.gmt_create = gmt_create  # type: str
        # The time when the data source was last modified. Example: Mar 17, 2021 4:09:32 PM.
        self.gmt_modified = gmt_modified  # type: str
        # The ID of the data source.
        self.id = id  # type: int
        # The name of the data source.
        self.name = name  # type: str
        # The ID of the user who exported the data source.
        self.operator = operator  # type: str
        # The ID of the DataWorks workspace to which the data source belongs.
        self.project_id = project_id  # type: int
        # The sequence number of the data source.
        self.sequence = sequence  # type: int
        # Indicates whether the data source can be shared. Valid values:
        # 
        # *   true: The data source can be shared.
        # *   false: The data source cannot be shared.
        self.shared = shared  # type: bool
        # Indicates whether the data source is available. Valid values:
        # 
        # *   1: The data source is available.
        # *   0: The data source is unavailable.
        self.status = status  # type: int
        # The subtype of the data source. This parameter is returned only if the value of the DataSourceType parameter is rds.
        # 
        # If the value of the DataSourceType parameter is rds, the value of this parameter can be mysql, sqlserver, or postgresql.
        self.sub_type = sub_type  # type: str
        # The ID of the Alibaba Cloud account to which the data source belongs.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ExportDataSourcesResponseBodyDataDataSources, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.binding_calc_engine_id is not None:
            result['BindingCalcEngineId'] = self.binding_calc_engine_id
        if self.connect_status is not None:
            result['ConnectStatus'] = self.connect_status
        if self.content is not None:
            result['Content'] = self.content
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.default_engine is not None:
            result['DefaultEngine'] = self.default_engine
        if self.description is not None:
            result['Description'] = self.description
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.gmt_create is not None:
            result['GmtCreate'] = self.gmt_create
        if self.gmt_modified is not None:
            result['GmtModified'] = self.gmt_modified
        if self.id is not None:
            result['Id'] = self.id
        if self.name is not None:
            result['Name'] = self.name
        if self.operator is not None:
            result['Operator'] = self.operator
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.sequence is not None:
            result['Sequence'] = self.sequence
        if self.shared is not None:
            result['Shared'] = self.shared
        if self.status is not None:
            result['Status'] = self.status
        if self.sub_type is not None:
            result['SubType'] = self.sub_type
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BindingCalcEngineId') is not None:
            self.binding_calc_engine_id = m.get('BindingCalcEngineId')
        if m.get('ConnectStatus') is not None:
            self.connect_status = m.get('ConnectStatus')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DefaultEngine') is not None:
            self.default_engine = m.get('DefaultEngine')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('GmtCreate') is not None:
            self.gmt_create = m.get('GmtCreate')
        if m.get('GmtModified') is not None:
            self.gmt_modified = m.get('GmtModified')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Operator') is not None:
            self.operator = m.get('Operator')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Sequence') is not None:
            self.sequence = m.get('Sequence')
        if m.get('Shared') is not None:
            self.shared = m.get('Shared')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('SubType') is not None:
            self.sub_type = m.get('SubType')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ExportDataSourcesResponseBodyData(TeaModel):
    def __init__(self, data_sources=None, page_number=None, page_size=None, total_count=None):
        # The details of the exported data sources.
        # 
        # The value is an array. The following parameters are the elements in the array. The sample values of these parameters show the details of a sample data source.
        self.data_sources = data_sources  # type: list[ExportDataSourcesResponseBodyDataDataSources]
        # The page number of the returned page. The value of this parameter is a positive integer greater than or equal to 1.
        self.page_number = page_number  # type: int
        # The number of entries returned on each page.
        self.page_size = page_size  # type: int
        # The total number of entries returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.data_sources:
            for k in self.data_sources:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ExportDataSourcesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DataSources'] = []
        if self.data_sources is not None:
            for k in self.data_sources:
                result['DataSources'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data_sources = []
        if m.get('DataSources') is not None:
            for k in m.get('DataSources'):
                temp_model = ExportDataSourcesResponseBodyDataDataSources()
                self.data_sources.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ExportDataSourcesResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        # The information about the export operation.
        self.data = data  # type: ExportDataSourcesResponseBodyData
        # The HTTP status code returned. Valid values:
        # 
        # *   200: The request was successful.
        # *   Other values: The request failed. You can troubleshoot issues based on the HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ExportDataSourcesResponseBody, self).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.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ExportDataSourcesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ExportDataSourcesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ExportDataSourcesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ExportDataSourcesResponse, self).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=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 = ExportDataSourcesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GenerateDISyncTaskConfigForCreatingRequest(TeaModel):
    def __init__(self, client_token=None, project_id=None, task_param=None, task_type=None):
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.client_token = client_token  # type: str
        # The type of the object that you want to create in Data Integration in asynchronous mode. Valid values:
        # 
        # *   DI_REALTIME: real-time synchronization node
        # *   DI_SOLUTION: synchronization solution
        # 
        # DataWorks allows you to create real-time synchronization nodes and synchronization solutions in Data Integration only in asynchronous mode.
        self.project_id = project_id  # type: long
        # The client token that is used to ensure the idempotence of the request. This parameter is used to prevent repeated operations that are caused by multiple calls.
        self.task_param = task_param  # type: str
        # The script for the real-time synchronization node or synchronization solution in Data Integration.
        # 
        # The following types of real-time synchronization nodes and synchronization solutions are supported:
        # 
        # *   Real-time synchronization node or synchronization solution that is used to synchronize data from MySQL to MaxCompute
        # *   Real-time synchronization node or synchronization solution that is used to synchronize data from MySQL data to Kafka
        # *   Real-time synchronization node or synchronization solution that is used to synchronize data from MySQL to Hologres
        # 
        # The SelectedTables parameter is used to specify tables that you want to synchronize from multiple databases. The Tables parameter is used to specify tables that you want to synchronize from a single database.
        # 
        # *   If the script contains the SelectedTables parameter, the system synchronizes the tables that you specify in the SelectedTables parameter.
        # *   If the script contains the Tables parameter, the system synchronizes the tables that you specify in the Tables parameter.
        # 
        # The following sample code provides a script for data synchronization from MySQL to MaxCompute:
        # 
        # {
        # 
        # "type": "realtime",
        # 
        # "version": "1.0",
        # 
        # "setting": {
        # 
        # "resourceGroup": "S_res_group\_280749521950784\_1623033752022",
        # 
        # "taskType": "oneclick_to_odps"
        # 
        # },
        # 
        # "steps": { "stepType": "mysql", "parameter": { "connection": \[ { "datasourceType": "mysql", "datasource": "mysql_pub1", "selectedTables": \[ { "dbName": "mysql_db", "schema": \[ { "tableInfos": \[ { "table": "molin_di_test_in_pk_v4" }
        # 
        # }
        # 
        # ]
        # 
        # }
        # 
        # ]
        # 
        # }
        # 
        # ]
        # 
        # },
        # 
        # "name": "Reader",
        # 
        # "category": "reader"
        # 
        # },
        # 
        # {
        # 
        # "stepType": "odps",
        # 
        # "parameter": {
        # 
        # "datasource": "odps_first"
        # 
        # },
        # 
        # "name": "Writer",
        # 
        # "category": "writer"
        # 
        # }
        # 
        # ]
        # 
        # }
        # 
        # The following sample code provides a script for data synchronization from MySQL to Kafka:
        # 
        # {
        # 
        # "type": "realtime",
        # 
        # "version": "1.0",
        # 
        # "setting": {
        # 
        # "resourceGroup": "S_res_group\_280749521950784\_1623033752022",
        # 
        # "taskType": "oneclick_to_kafka"
        # 
        # },
        # 
        # "steps": { "stepType": "mysql", "parameter": { "connection": \[ { "datasourceType": "mysql", "datasource": "pkset_test", "selectedTables": \[ { "dbName": "mysql_db", "schema": \[ { "tableInfos": \[ { "table": "molin_di_test_in_pk_v4" }
        # 
        # }
        # 
        # ]
        # 
        # }
        # 
        # ]
        # 
        # }
        # 
        # ]
        # 
        # },
        # 
        # "name": "Reader",
        # 
        # "category": "reader"
        # 
        # },
        # 
        # {
        # 
        # "stepType": "kafka",
        # 
        # "parameter": {
        # 
        # "datasource": "azn_kafka"
        # 
        # },
        # 
        # "name": "Writer",
        # 
        # "category": "writer"
        # 
        # }
        # 
        # ]
        # 
        # }
        # 
        # The following sample code provides a script for data synchronization from MySQL to Hologres:
        # 
        # {
        # 
        # "type": "realtime",
        # 
        # "version": "1.0",
        # 
        # "setting": {
        # 
        # "resourceGroup": "S_res_group\_280749521950784\_1623033752022",
        # 
        # "taskType": "oneclick_to_holo"
        # 
        # },
        # 
        # "steps": { "stepType": "mysql", "parameter": { "connection": \[ { "datasourceType": "mysql", "datasource": "mysql_pub", "selectedTables": \[ { "dbName": "mysql_db", "schema": \[ { "tableInfos": \[ { "table": "molin_di_test_in2\_pk_v3" }
        # 
        # }
        # 
        # ]
        # 
        # }
        # 
        # ]
        # 
        # }
        # 
        # ]
        # 
        # },
        # 
        # "name": "Reader",
        # 
        # "category": "reader"
        # 
        # },
        # 
        # {
        # 
        # "stepType": "holo",
        # 
        # "parameter": {
        # 
        # "datasource": "holo"
        # 
        # },
        # 
        # "name": "Writer",
        # 
        # "category": "writer"
        # 
        # }
        # 
        # ]
        # 
        # }
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GenerateDISyncTaskConfigForCreatingRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.client_token is not None:
            result['ClientToken'] = self.client_token
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.task_param is not None:
            result['TaskParam'] = self.task_param
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClientToken') is not None:
            self.client_token = m.get('ClientToken')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TaskParam') is not None:
            self.task_param = m.get('TaskParam')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class GenerateDISyncTaskConfigForCreatingResponseBodyData(TeaModel):
    def __init__(self, message=None, process_id=None, status=None):
        self.message = message  # type: str
        # The reason why the ID of the asynchronous thread fails to be generated.
        # 
        # If the ID is successfully generated, the value null is returned.
        self.process_id = process_id  # type: long
        # The ID of the asynchronous thread. You can call the [QueryDISyncTaskConfigProcessResult](~~383465~~) operation to obtain the asynchronously generated parameters based on the ID. The parameters are used to create a real-time synchronization node or a synchronization solution in Data Integration.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GenerateDISyncTaskConfigForCreatingResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.process_id is not None:
            result['ProcessId'] = self.process_id
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('ProcessId') is not None:
            self.process_id = m.get('ProcessId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GenerateDISyncTaskConfigForCreatingResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # Indicates whether the ID of the asynchronous thread is generated. Valid values:
        # 
        # *   success: indicates that the ID of the asynchronous thread is generated.
        # *   fail: indicates that the ID of the asynchronous thread fails to be generated. You can view the reason for the failure and troubleshoot the issue based on the reason.
        self.data = data  # type: GenerateDISyncTaskConfigForCreatingResponseBodyData
        # The information returned for the ID of the asynchronous thread.
        self.request_id = request_id  # type: str
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GenerateDISyncTaskConfigForCreatingResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GenerateDISyncTaskConfigForCreatingResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GenerateDISyncTaskConfigForCreatingResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GenerateDISyncTaskConfigForCreatingResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GenerateDISyncTaskConfigForCreatingResponse, self).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=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 = GenerateDISyncTaskConfigForCreatingResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GenerateDISyncTaskConfigForUpdatingRequest(TeaModel):
    def __init__(self, client_token=None, project_id=None, task_id=None, task_param=None, task_type=None):
        # The ID of the real-time synchronization node or synchronization solution.
        # 
        # *   If you set the TaskType parameter to DI_REALTIME, set the TaskId parameter to the value of the FileId parameter for the real-time synchronization node.
        # *   If you set the TaskType parameter to DI_SOLUTION, set the TaskId parameter to the value of the FileId parameter for the synchronization solution.
        self.client_token = client_token  # type: str
        # The type of the object that you want to update in Data Integration in asynchronous mode. Valid values:
        # 
        # *   DI_REALTIME: real-time synchronization node
        # 
        # *   DI_SOLUTION: synchronization solution
        # 
        #     DataWorks allows you to update real-time synchronization nodes and synchronization solutions in Data Integration only in asynchronous mode.
        self.project_id = project_id  # type: long
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.task_id = task_id  # type: long
        # The client token that is used to ensure the idempotence of the request. This parameter is used to prevent repeated operations that are caused by multiple calls.
        self.task_param = task_param  # type: str
        # The script for updating the real-time synchronization node or synchronization solution in Data Integration.
        # 
        # DataWorks allows you to add or remove tables for a real-time synchronization node or a synchronization solution in Data Integration only in asynchronous mode. The following types of real-time synchronization nodes and synchronization solutions are supported:
        # 
        # *   Real-time synchronization node or synchronization solution that is used to synchronize data from MySQL to MaxCompute
        # *   Real-time synchronization node or synchronization solution that is used to synchronize data from MySQL data to Kafka
        # *   Real-time synchronization node or synchronization solution that is used to synchronize data from MySQL to Hologres
        # 
        # The SelectedTables parameter is used to specify tables that you want to synchronize from multiple databases. The Tables parameter is used to specify tables that you want to synchronize from a single database.
        # 
        # *   If the script contains the SelectedTables parameter, the system synchronizes the tables that you specify in the SelectedTables parameter.
        # *   If the script contains the Tables parameter, the system synchronizes the tables that you specify in the Tables parameter.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GenerateDISyncTaskConfigForUpdatingRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.client_token is not None:
            result['ClientToken'] = self.client_token
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        if self.task_param is not None:
            result['TaskParam'] = self.task_param
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClientToken') is not None:
            self.client_token = m.get('ClientToken')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        if m.get('TaskParam') is not None:
            self.task_param = m.get('TaskParam')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class GenerateDISyncTaskConfigForUpdatingResponseBodyData(TeaModel):
    def __init__(self, message=None, process_id=None, status=None):
        self.message = message  # type: str
        # The reason why the ID of the asynchronous thread fails to be generated. If the ID is successfully generated, the value null is returned.
        self.process_id = process_id  # type: long
        # The ID of the asynchronous thread. You can call the [QueryDISyncTaskConfigProcessResult](~~383465~~) operation to obtain the asynchronously generated parameters based on the ID. The parameters are used to update a real-time synchronization node or a synchronization solution in Data Integration.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GenerateDISyncTaskConfigForUpdatingResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.process_id is not None:
            result['ProcessId'] = self.process_id
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('ProcessId') is not None:
            self.process_id = m.get('ProcessId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GenerateDISyncTaskConfigForUpdatingResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # Indicates whether the ID of the asynchronous thread is generated. Valid values:
        # 
        # *   success: indicates that the ID of the asynchronous thread is generated.
        # *   fail: indicates that the ID of the asynchronous thread fails to be generated. You can view the reason for the failure and troubleshoot the issue based on the reason.
        self.data = data  # type: GenerateDISyncTaskConfigForUpdatingResponseBodyData
        # The information returned for the ID of the asynchronous thread.
        self.request_id = request_id  # type: str
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GenerateDISyncTaskConfigForUpdatingResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GenerateDISyncTaskConfigForUpdatingResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GenerateDISyncTaskConfigForUpdatingResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GenerateDISyncTaskConfigForUpdatingResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GenerateDISyncTaskConfigForUpdatingResponse, self).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=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 = GenerateDISyncTaskConfigForUpdatingResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetBaselineRequest(TeaModel):
    def __init__(self, baseline_id=None, project_id=None):
        self.baseline_id = baseline_id  # type: long
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBaselineRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetBaselineResponseBodyDataAlertSettingsDingRobots(TeaModel):
    def __init__(self, at_all=None, web_url=None):
        self.at_all = at_all  # type: bool
        self.web_url = web_url  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBaselineResponseBodyDataAlertSettingsDingRobots, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.at_all is not None:
            result['AtAll'] = self.at_all
        if self.web_url is not None:
            result['WebUrl'] = self.web_url
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AtAll') is not None:
            self.at_all = m.get('AtAll')
        if m.get('WebUrl') is not None:
            self.web_url = m.get('WebUrl')
        return self


class GetBaselineResponseBodyDataAlertSettings(TeaModel):
    def __init__(self, alert_interval=None, alert_maximum=None, alert_methods=None, alert_recipient=None,
                 alert_recipient_type=None, alert_type=None, baseline_alert_enabled=None, ding_robots=None, silence_end_time=None,
                 silence_start_time=None, topic_types=None, webhooks=None):
        self.alert_interval = alert_interval  # type: int
        self.alert_maximum = alert_maximum  # type: int
        self.alert_methods = alert_methods  # type: list[str]
        self.alert_recipient = alert_recipient  # type: str
        self.alert_recipient_type = alert_recipient_type  # type: str
        self.alert_type = alert_type  # type: str
        self.baseline_alert_enabled = baseline_alert_enabled  # type: bool
        self.ding_robots = ding_robots  # type: list[GetBaselineResponseBodyDataAlertSettingsDingRobots]
        self.silence_end_time = silence_end_time  # type: str
        self.silence_start_time = silence_start_time  # type: str
        self.topic_types = topic_types  # type: list[str]
        self.webhooks = webhooks  # type: list[str]

    def validate(self):
        if self.ding_robots:
            for k in self.ding_robots:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetBaselineResponseBodyDataAlertSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_interval is not None:
            result['AlertInterval'] = self.alert_interval
        if self.alert_maximum is not None:
            result['AlertMaximum'] = self.alert_maximum
        if self.alert_methods is not None:
            result['AlertMethods'] = self.alert_methods
        if self.alert_recipient is not None:
            result['AlertRecipient'] = self.alert_recipient
        if self.alert_recipient_type is not None:
            result['AlertRecipientType'] = self.alert_recipient_type
        if self.alert_type is not None:
            result['AlertType'] = self.alert_type
        if self.baseline_alert_enabled is not None:
            result['BaselineAlertEnabled'] = self.baseline_alert_enabled
        result['DingRobots'] = []
        if self.ding_robots is not None:
            for k in self.ding_robots:
                result['DingRobots'].append(k.to_map() if k else None)
        if self.silence_end_time is not None:
            result['SilenceEndTime'] = self.silence_end_time
        if self.silence_start_time is not None:
            result['SilenceStartTime'] = self.silence_start_time
        if self.topic_types is not None:
            result['TopicTypes'] = self.topic_types
        if self.webhooks is not None:
            result['Webhooks'] = self.webhooks
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertInterval') is not None:
            self.alert_interval = m.get('AlertInterval')
        if m.get('AlertMaximum') is not None:
            self.alert_maximum = m.get('AlertMaximum')
        if m.get('AlertMethods') is not None:
            self.alert_methods = m.get('AlertMethods')
        if m.get('AlertRecipient') is not None:
            self.alert_recipient = m.get('AlertRecipient')
        if m.get('AlertRecipientType') is not None:
            self.alert_recipient_type = m.get('AlertRecipientType')
        if m.get('AlertType') is not None:
            self.alert_type = m.get('AlertType')
        if m.get('BaselineAlertEnabled') is not None:
            self.baseline_alert_enabled = m.get('BaselineAlertEnabled')
        self.ding_robots = []
        if m.get('DingRobots') is not None:
            for k in m.get('DingRobots'):
                temp_model = GetBaselineResponseBodyDataAlertSettingsDingRobots()
                self.ding_robots.append(temp_model.from_map(k))
        if m.get('SilenceEndTime') is not None:
            self.silence_end_time = m.get('SilenceEndTime')
        if m.get('SilenceStartTime') is not None:
            self.silence_start_time = m.get('SilenceStartTime')
        if m.get('TopicTypes') is not None:
            self.topic_types = m.get('TopicTypes')
        if m.get('Webhooks') is not None:
            self.webhooks = m.get('Webhooks')
        return self


class GetBaselineResponseBodyDataOverTimeSettings(TeaModel):
    def __init__(self, cycle=None, time=None):
        self.cycle = cycle  # type: int
        self.time = time  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBaselineResponseBodyDataOverTimeSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cycle is not None:
            result['Cycle'] = self.cycle
        if self.time is not None:
            result['Time'] = self.time
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Cycle') is not None:
            self.cycle = m.get('Cycle')
        if m.get('Time') is not None:
            self.time = m.get('Time')
        return self


class GetBaselineResponseBodyData(TeaModel):
    def __init__(self, alert_enabled=None, alert_margin_threshold=None, alert_settings=None, baseline_id=None,
                 baseline_name=None, baseline_type=None, enabled=None, node_ids=None, over_time_settings=None, owner=None,
                 priority=None, project_id=None):
        self.alert_enabled = alert_enabled  # type: bool
        self.alert_margin_threshold = alert_margin_threshold  # type: int
        self.alert_settings = alert_settings  # type: list[GetBaselineResponseBodyDataAlertSettings]
        self.baseline_id = baseline_id  # type: long
        self.baseline_name = baseline_name  # type: str
        self.baseline_type = baseline_type  # type: str
        self.enabled = enabled  # type: bool
        self.node_ids = node_ids  # type: list[long]
        self.over_time_settings = over_time_settings  # type: list[GetBaselineResponseBodyDataOverTimeSettings]
        self.owner = owner  # type: str
        self.priority = priority  # type: int
        self.project_id = project_id  # type: long

    def validate(self):
        if self.alert_settings:
            for k in self.alert_settings:
                if k:
                    k.validate()
        if self.over_time_settings:
            for k in self.over_time_settings:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetBaselineResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_enabled is not None:
            result['AlertEnabled'] = self.alert_enabled
        if self.alert_margin_threshold is not None:
            result['AlertMarginThreshold'] = self.alert_margin_threshold
        result['AlertSettings'] = []
        if self.alert_settings is not None:
            for k in self.alert_settings:
                result['AlertSettings'].append(k.to_map() if k else None)
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.baseline_type is not None:
            result['BaselineType'] = self.baseline_type
        if self.enabled is not None:
            result['Enabled'] = self.enabled
        if self.node_ids is not None:
            result['NodeIds'] = self.node_ids
        result['OverTimeSettings'] = []
        if self.over_time_settings is not None:
            for k in self.over_time_settings:
                result['OverTimeSettings'].append(k.to_map() if k else None)
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertEnabled') is not None:
            self.alert_enabled = m.get('AlertEnabled')
        if m.get('AlertMarginThreshold') is not None:
            self.alert_margin_threshold = m.get('AlertMarginThreshold')
        self.alert_settings = []
        if m.get('AlertSettings') is not None:
            for k in m.get('AlertSettings'):
                temp_model = GetBaselineResponseBodyDataAlertSettings()
                self.alert_settings.append(temp_model.from_map(k))
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('BaselineType') is not None:
            self.baseline_type = m.get('BaselineType')
        if m.get('Enabled') is not None:
            self.enabled = m.get('Enabled')
        if m.get('NodeIds') is not None:
            self.node_ids = m.get('NodeIds')
        self.over_time_settings = []
        if m.get('OverTimeSettings') is not None:
            for k in m.get('OverTimeSettings'):
                temp_model = GetBaselineResponseBodyDataOverTimeSettings()
                self.over_time_settings.append(temp_model.from_map(k))
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetBaselineResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: GetBaselineResponseBodyData
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetBaselineResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetBaselineResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetBaselineResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetBaselineResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetBaselineResponse, self).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=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 = GetBaselineResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetBaselineConfigRequest(TeaModel):
    def __init__(self, baseline_id=None):
        # The ID of the baseline. You can call the [GetNode](~~173977~~) operation to obtain the ID.
        self.baseline_id = baseline_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBaselineConfigRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        return self


class GetBaselineConfigResponseBodyData(TeaModel):
    def __init__(self, baseline_id=None, baseline_name=None, baseline_type=None, exp_hour=None, exp_minu=None,
                 hour_exp_detail=None, hour_sla_detail=None, is_default=None, owner=None, priority=None, project_id=None,
                 sla_hour=None, sla_minu=None, use_flag=None):
        # The ID of the baseline.
        self.baseline_id = baseline_id  # type: long
        # The name of the baseline.
        self.baseline_name = baseline_name  # type: str
        # The type of the baseline. Valid values: DAILY and HOURLY. The value DAILY indicates that the baseline is a day-level baseline. The value HOURLY indicates that the baseline is an hour-level baseline.
        self.baseline_type = baseline_type  # type: str
        # The hour in the alert time of the day-level baseline. Valid values: 0 to 47.
        self.exp_hour = exp_hour  # type: int
        # The minute in the alert time of the day-level baseline. Valid values: 0 to 59.
        self.exp_minu = exp_minu  # type: int
        # The alert time of the hour-level baseline. This parameter is presented as key-value pairs in the JSON format. The key indicates the ID of the cycle, and the value is presented in the hh:mm format. Valid values of hh: 0 to 47. Valid values of mm: 0 to 59.
        self.hour_exp_detail = hour_exp_detail  # type: str
        # The committed time of the hour-level baseline. This parameter is presented as key-value pairs in the JSON format. The key indicates the ID of the cycle, and the value is presented in the hh:mm format. Valid values of hh: 0 to 47. Valid values of mm: 0 to 59.
        self.hour_sla_detail = hour_sla_detail  # type: str
        # Indicates whether the baseline is a default baseline of the workspace. Valid values: true and false.
        self.is_default = is_default  # type: bool
        # The ID of the Alibaba Cloud account used by the baseline owner. Multiple IDs are separated by commas (,).
        self.owner = owner  # type: str
        # The priority of the baseline. Valid values: 1, 3, 5, 7, and 8.
        self.priority = priority  # type: int
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The hour in the committed time of the day-level baseline. Valid values: 0 to 47.
        self.sla_hour = sla_hour  # type: int
        # The minute in the committed time of the day-level baseline. Valid values: 0 to 59.
        self.sla_minu = sla_minu  # type: int
        # Indicates whether the baseline is enabled. Valid values: true and false.
        self.use_flag = use_flag  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBaselineConfigResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.baseline_type is not None:
            result['BaselineType'] = self.baseline_type
        if self.exp_hour is not None:
            result['ExpHour'] = self.exp_hour
        if self.exp_minu is not None:
            result['ExpMinu'] = self.exp_minu
        if self.hour_exp_detail is not None:
            result['HourExpDetail'] = self.hour_exp_detail
        if self.hour_sla_detail is not None:
            result['HourSlaDetail'] = self.hour_sla_detail
        if self.is_default is not None:
            result['IsDefault'] = self.is_default
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.sla_hour is not None:
            result['SlaHour'] = self.sla_hour
        if self.sla_minu is not None:
            result['SlaMinu'] = self.sla_minu
        if self.use_flag is not None:
            result['UseFlag'] = self.use_flag
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('BaselineType') is not None:
            self.baseline_type = m.get('BaselineType')
        if m.get('ExpHour') is not None:
            self.exp_hour = m.get('ExpHour')
        if m.get('ExpMinu') is not None:
            self.exp_minu = m.get('ExpMinu')
        if m.get('HourExpDetail') is not None:
            self.hour_exp_detail = m.get('HourExpDetail')
        if m.get('HourSlaDetail') is not None:
            self.hour_sla_detail = m.get('HourSlaDetail')
        if m.get('IsDefault') is not None:
            self.is_default = m.get('IsDefault')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SlaHour') is not None:
            self.sla_hour = m.get('SlaHour')
        if m.get('SlaMinu') is not None:
            self.sla_minu = m.get('SlaMinu')
        if m.get('UseFlag') is not None:
            self.use_flag = m.get('UseFlag')
        return self


class GetBaselineConfigResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The details of the baseline.
        self.data = data  # type: GetBaselineConfigResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetBaselineConfigResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetBaselineConfigResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetBaselineConfigResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetBaselineConfigResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetBaselineConfigResponse, self).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=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 = GetBaselineConfigResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetBaselineKeyPathRequest(TeaModel):
    def __init__(self, baseline_id=None, bizdate=None, in_group_id=None):
        # The name of the event.
        self.baseline_id = baseline_id  # type: long
        # The ID of the instance.
        self.bizdate = bizdate  # type: str
        # The ID of the event.
        self.in_group_id = in_group_id  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBaselineKeyPathRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.in_group_id is not None:
            result['InGroupId'] = self.in_group_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('InGroupId') is not None:
            self.in_group_id = m.get('InGroupId')
        return self


class GetBaselineKeyPathResponseBodyDataRuns(TeaModel):
    def __init__(self, abs_time=None, begin_cast=None, begin_running_time=None, begin_wait_res_time=None,
                 begin_wait_time_time=None, end_cast=None, finish_time=None, status=None):
        self.abs_time = abs_time  # type: long
        self.begin_cast = begin_cast  # type: long
        self.begin_running_time = begin_running_time  # type: long
        self.begin_wait_res_time = begin_wait_res_time  # type: long
        self.begin_wait_time_time = begin_wait_time_time  # type: long
        self.end_cast = end_cast  # type: long
        self.finish_time = finish_time  # type: long
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBaselineKeyPathResponseBodyDataRuns, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.abs_time is not None:
            result['AbsTime'] = self.abs_time
        if self.begin_cast is not None:
            result['BeginCast'] = self.begin_cast
        if self.begin_running_time is not None:
            result['BeginRunningTime'] = self.begin_running_time
        if self.begin_wait_res_time is not None:
            result['BeginWaitResTime'] = self.begin_wait_res_time
        if self.begin_wait_time_time is not None:
            result['BeginWaitTimeTime'] = self.begin_wait_time_time
        if self.end_cast is not None:
            result['EndCast'] = self.end_cast
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AbsTime') is not None:
            self.abs_time = m.get('AbsTime')
        if m.get('BeginCast') is not None:
            self.begin_cast = m.get('BeginCast')
        if m.get('BeginRunningTime') is not None:
            self.begin_running_time = m.get('BeginRunningTime')
        if m.get('BeginWaitResTime') is not None:
            self.begin_wait_res_time = m.get('BeginWaitResTime')
        if m.get('BeginWaitTimeTime') is not None:
            self.begin_wait_time_time = m.get('BeginWaitTimeTime')
        if m.get('EndCast') is not None:
            self.end_cast = m.get('EndCast')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetBaselineKeyPathResponseBodyDataTopics(TeaModel):
    def __init__(self, add_time=None, instance_id=None, topic_id=None, topic_name=None):
        self.add_time = add_time  # type: long
        self.instance_id = instance_id  # type: long
        self.topic_id = topic_id  # type: long
        self.topic_name = topic_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBaselineKeyPathResponseBodyDataTopics, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.add_time is not None:
            result['AddTime'] = self.add_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.topic_id is not None:
            result['TopicId'] = self.topic_id
        if self.topic_name is not None:
            result['TopicName'] = self.topic_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AddTime') is not None:
            self.add_time = m.get('AddTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('TopicId') is not None:
            self.topic_id = m.get('TopicId')
        if m.get('TopicName') is not None:
            self.topic_name = m.get('TopicName')
        return self


class GetBaselineKeyPathResponseBodyData(TeaModel):
    def __init__(self, bizdate=None, in_group_id=None, instance_id=None, node_id=None, node_name=None, owner=None,
                 prg_type=None, project_id=None, runs=None, topics=None):
        self.bizdate = bizdate  # type: long
        self.in_group_id = in_group_id  # type: int
        self.instance_id = instance_id  # type: long
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.owner = owner  # type: str
        self.prg_type = prg_type  # type: int
        self.project_id = project_id  # type: long
        self.runs = runs  # type: list[GetBaselineKeyPathResponseBodyDataRuns]
        self.topics = topics  # type: list[GetBaselineKeyPathResponseBodyDataTopics]

    def validate(self):
        if self.runs:
            for k in self.runs:
                if k:
                    k.validate()
        if self.topics:
            for k in self.topics:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetBaselineKeyPathResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.in_group_id is not None:
            result['InGroupId'] = self.in_group_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.prg_type is not None:
            result['PrgType'] = self.prg_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        result['Runs'] = []
        if self.runs is not None:
            for k in self.runs:
                result['Runs'].append(k.to_map() if k else None)
        result['Topics'] = []
        if self.topics is not None:
            for k in self.topics:
                result['Topics'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('InGroupId') is not None:
            self.in_group_id = m.get('InGroupId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PrgType') is not None:
            self.prg_type = m.get('PrgType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        self.runs = []
        if m.get('Runs') is not None:
            for k in m.get('Runs'):
                temp_model = GetBaselineKeyPathResponseBodyDataRuns()
                self.runs.append(temp_model.from_map(k))
        self.topics = []
        if m.get('Topics') is not None:
            for k in m.get('Topics'):
                temp_model = GetBaselineKeyPathResponseBodyDataTopics()
                self.topics.append(temp_model.from_map(k))
        return self


class GetBaselineKeyPathResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: list[GetBaselineKeyPathResponseBodyData]
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        # The timestamp when the event was found.
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetBaselineKeyPathResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = GetBaselineKeyPathResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetBaselineKeyPathResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetBaselineKeyPathResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetBaselineKeyPathResponse, self).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=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 = GetBaselineKeyPathResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetBaselineStatusRequest(TeaModel):
    def __init__(self, baseline_id=None, bizdate=None, in_group_id=None):
        # The ID of the baseline.
        self.baseline_id = baseline_id  # type: long
        # The data timestamp of the baseline instance. Specify the time in the ISO 8601 standard in the yyyy-MM-dd\"T\"HH:mm:ssZ format. The time must be in UTC.
        self.bizdate = bizdate  # type: str
        # The ID of the scheduling cycle of the baseline instance. For a baseline instance that is scheduled by day, the value of this parameter is 1. For a baseline instance that is scheduled by hour, the value of this parameter ranges from 1 to 24.
        self.in_group_id = in_group_id  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBaselineStatusRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.in_group_id is not None:
            result['InGroupId'] = self.in_group_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('InGroupId') is not None:
            self.in_group_id = m.get('InGroupId')
        return self


class GetBaselineStatusResponseBodyDataBlockInstance(TeaModel):
    def __init__(self, end_cast=None, finish_time=None, instance_id=None, node_id=None, node_name=None, owner=None,
                 project_id=None, status=None):
        # The timestamp of the predicted time when the instance finished running.
        self.end_cast = end_cast  # type: long
        # The timestamp of the actual time when the instance finished running.
        self.finish_time = finish_time  # type: long
        # The ID of the instance.
        self.instance_id = instance_id  # type: long
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The ID of the Alibaba Cloud account used by the node owner.
        self.owner = owner  # type: str
        # The ID of the workspace to which the node belongs.
        self.project_id = project_id  # type: long
        # The status of the instance. Valid values: NOT_RUN, WAIT_TIME, WAIT_RESOURCE, RUNNING, CHECKING, CHECKING_CONDITION, FAILURE, and SUCCESS. The value NOT_RUN indicates that the instance is not run. The value WAIT_TIME indicates that the instance is waiting to be run. The value WAIT_RESOURCE indicates that the instance is waiting for resources. The value RUNNING indicates that the instance is running. The value CHECKING indicates that data quality is being checked for the instance. The value CHECKING_CONDITION indicates that branch conditions are being checked for the instance. The value FAILURE indicates that the instance fails to run. The value SUCCESS indicates that the instance is run.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBaselineStatusResponseBodyDataBlockInstance, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.end_cast is not None:
            result['EndCast'] = self.end_cast
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EndCast') is not None:
            self.end_cast = m.get('EndCast')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetBaselineStatusResponseBodyDataLastInstance(TeaModel):
    def __init__(self, end_cast=None, finish_time=None, instance_id=None, node_id=None, node_name=None, owner=None,
                 project_id=None, status=None):
        # The timestamp of the predicted time when the instance finished running.
        self.end_cast = end_cast  # type: long
        # The timestamp of the actual time when the instance finished running.
        self.finish_time = finish_time  # type: long
        # The ID of the instance.
        self.instance_id = instance_id  # type: long
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The ID of the Alibaba Cloud account used by the node owner.
        self.owner = owner  # type: str
        # The ID of the workspace to which the node belongs.
        self.project_id = project_id  # type: long
        # The status of the instance. Valid values: NOT_RUN, WAIT_TIME, WAIT_RESOURCE, RUNNING, CHECKING, CHECKING_CONDITION, FAILURE, and SUCCESS. The value NOT_RUN indicates that the instance is not run. The value WAIT_TIME indicates that the instance is waiting to be run. The value WAIT_RESOURCE indicates that the instance is waiting for resources. The value RUNNING indicates that the instance is running. The value CHECKING indicates that data quality is being checked for the instance. The value CHECKING_CONDITION indicates that branch conditions are being checked for the instance. The value FAILURE indicates that the instance fails to run. The value SUCCESS indicates that the instance is run.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBaselineStatusResponseBodyDataLastInstance, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.end_cast is not None:
            result['EndCast'] = self.end_cast
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EndCast') is not None:
            self.end_cast = m.get('EndCast')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetBaselineStatusResponseBodyData(TeaModel):
    def __init__(self, baseline_id=None, baseline_name=None, bizdate=None, block_instance=None, buffer=None,
                 end_cast=None, exp_time=None, finish_status=None, finish_time=None, in_group_id=None, last_instance=None,
                 owner=None, priority=None, project_id=None, sla_time=None, status=None):
        # The ID of the baseline.
        self.baseline_id = baseline_id  # type: long
        # The name of the baseline.
        self.baseline_name = baseline_name  # type: str
        # The data timestamp of the baseline instance.
        self.bizdate = bizdate  # type: long
        # The information about the key instance.
        self.block_instance = block_instance  # type: GetBaselineStatusResponseBodyDataBlockInstance
        # The margin of the baseline instance. Unit: seconds.
        self.buffer = buffer  # type: float
        # The timestamp of the predicted time when the baseline instance finished running.
        self.end_cast = end_cast  # type: long
        # The timestamp of the alerting time of the baseline instance.
        self.exp_time = exp_time  # type: long
        # The status of the baseline instance. Valid values: UNFINISH and FINISH. The value UNFINISH indicates that the baseline instance is still running. The value FINISH indicates that the baseline instance finishes running.
        self.finish_status = finish_status  # type: str
        # The timestamp of the actual time when the baseline instance finished running. This parameter is returned if the value of the FinishStatus parameter is FINISH.
        self.finish_time = finish_time  # type: long
        # The ID of the scheduling cycle of the baseline instance. For a baseline instance that is scheduled by day, the value of this parameter is 1. For a baseline instance that is scheduled by hour, the value of this parameter ranges from 1 to 24.
        self.in_group_id = in_group_id  # type: int
        # The information about the last generated instance.
        self.last_instance = last_instance  # type: GetBaselineStatusResponseBodyDataLastInstance
        # The ID of the Alibaba Cloud account used by the baseline owner. Multiple IDs are separated by commas (,).
        self.owner = owner  # type: str
        # The priority of the baseline. Valid values: 1, 2, 5, 7, and 8.
        self.priority = priority  # type: int
        # The ID of the workspace to which the baseline belongs.
        self.project_id = project_id  # type: long
        # The timestamp of the committed completion time of the baseline instance.
        self.sla_time = sla_time  # type: long
        # The status of the baseline. Valid values: ERROR, SAFE, DANGEROUS, and OVER. The value ERROR indicates that no nodes are associated with the baseline, or all nodes associated with the baseline are suspended. The value SAFE indicates that nodes finish running before the alerting time. The value DANGEROUS indicates that nodes are still running after the alerting time but before the committed completion time. The value OVER indicates that nodes are still running after the committed completion time.
        self.status = status  # type: str

    def validate(self):
        if self.block_instance:
            self.block_instance.validate()
        if self.last_instance:
            self.last_instance.validate()

    def to_map(self):
        _map = super(GetBaselineStatusResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.block_instance is not None:
            result['BlockInstance'] = self.block_instance.to_map()
        if self.buffer is not None:
            result['Buffer'] = self.buffer
        if self.end_cast is not None:
            result['EndCast'] = self.end_cast
        if self.exp_time is not None:
            result['ExpTime'] = self.exp_time
        if self.finish_status is not None:
            result['FinishStatus'] = self.finish_status
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.in_group_id is not None:
            result['InGroupId'] = self.in_group_id
        if self.last_instance is not None:
            result['LastInstance'] = self.last_instance.to_map()
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.sla_time is not None:
            result['SlaTime'] = self.sla_time
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('BlockInstance') is not None:
            temp_model = GetBaselineStatusResponseBodyDataBlockInstance()
            self.block_instance = temp_model.from_map(m['BlockInstance'])
        if m.get('Buffer') is not None:
            self.buffer = m.get('Buffer')
        if m.get('EndCast') is not None:
            self.end_cast = m.get('EndCast')
        if m.get('ExpTime') is not None:
            self.exp_time = m.get('ExpTime')
        if m.get('FinishStatus') is not None:
            self.finish_status = m.get('FinishStatus')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('InGroupId') is not None:
            self.in_group_id = m.get('InGroupId')
        if m.get('LastInstance') is not None:
            temp_model = GetBaselineStatusResponseBodyDataLastInstance()
            self.last_instance = temp_model.from_map(m['LastInstance'])
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SlaTime') is not None:
            self.sla_time = m.get('SlaTime')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetBaselineStatusResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The details of the baseline instance.
        self.data = data  # type: GetBaselineStatusResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetBaselineStatusResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetBaselineStatusResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetBaselineStatusResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetBaselineStatusResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetBaselineStatusResponse, self).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=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 = GetBaselineStatusResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetBusinessRequest(TeaModel):
    def __init__(self, business_id=None, project_id=None, project_identifier=None):
        # The ID of the workflow. You can call the [ListBusiness](~~173945~~) operation to query the ID.
        self.business_id = business_id  # type: long
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID. You must specify either this parameter or ProjectIdentifier to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Settings panel to obtain the name. You must specify either this parameter or ProjectId to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBusinessRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class GetBusinessResponseBodyData(TeaModel):
    def __init__(self, business_id=None, business_name=None, description=None, owner=None, project_id=None,
                 use_type=None):
        # The ID of the workflow.
        self.business_id = business_id  # type: long
        # The name of the workflow.
        self.business_name = business_name  # type: str
        # The description of the workflow.
        self.description = description  # type: str
        # The Alibaba Cloud account ID of the workflow owner.
        self.owner = owner  # type: str
        # The ID of the workspace to which the workflow belongs.
        self.project_id = project_id  # type: str
        # The module to which the workflow belongs. Valid values: NORMAL and MANUAL_BIZ.
        self.use_type = use_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetBusinessResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.business_name is not None:
            result['BusinessName'] = self.business_name
        if self.description is not None:
            result['Description'] = self.description
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.use_type is not None:
            result['UseType'] = self.use_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('BusinessName') is not None:
            self.business_name = m.get('BusinessName')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('UseType') is not None:
            self.use_type = m.get('UseType')
        return self


class GetBusinessResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The details of the workflow.
        self.data = data  # type: GetBusinessResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetBusinessResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetBusinessResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetBusinessResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetBusinessResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetBusinessResponse, self).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=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 = GetBusinessResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDDLJobStatusRequest(TeaModel):
    def __init__(self, task_id=None):
        # The ID of the DDL task.
        self.task_id = task_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDDLJobStatusRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        return self


class GetDDLJobStatusResponseBodyData(TeaModel):
    def __init__(self, content=None, next_task_id=None, status=None, task_id=None):
        # The content of the task.
        self.content = content  # type: str
        # The ID of the ongoing task. If no value is returned for this parameter, all subtasks are complete.
        self.next_task_id = next_task_id  # type: str
        # The status of the task
        self.status = status  # type: str
        # The ID of the task.
        self.task_id = task_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDDLJobStatusResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.next_task_id is not None:
            result['NextTaskId'] = self.next_task_id
        if self.status is not None:
            result['Status'] = self.status
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('NextTaskId') is not None:
            self.next_task_id = m.get('NextTaskId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        return self


class GetDDLJobStatusResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None):
        # The details of the task.
        self.data = data  # type: GetDDLJobStatusResponseBodyData
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetDDLJobStatusResponseBody, self).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=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetDDLJobStatusResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetDDLJobStatusResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDDLJobStatusResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDDLJobStatusResponse, self).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=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 = GetDDLJobStatusResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDIAlarmRuleRequest(TeaModel):
    def __init__(self, dialarm_rule_id=None):
        self.dialarm_rule_id = dialarm_rule_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIAlarmRuleRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dialarm_rule_id is not None:
            result['DIAlarmRuleId'] = self.dialarm_rule_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIAlarmRuleId') is not None:
            self.dialarm_rule_id = m.get('DIAlarmRuleId')
        return self


class GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettingsNotificationChannels(TeaModel):
    def __init__(self, channels=None, severity=None):
        self.channels = channels  # type: list[str]
        self.severity = severity  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettingsNotificationChannels, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.channels is not None:
            result['Channels'] = self.channels
        if self.severity is not None:
            result['Severity'] = self.severity
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Channels') is not None:
            self.channels = m.get('Channels')
        if m.get('Severity') is not None:
            self.severity = m.get('Severity')
        return self


class GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettingsNotificationReceivers(TeaModel):
    def __init__(self, receiver_type=None, receiver_values=None):
        self.receiver_type = receiver_type  # type: str
        self.receiver_values = receiver_values  # type: list[str]

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettingsNotificationReceivers, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.receiver_type is not None:
            result['ReceiverType'] = self.receiver_type
        if self.receiver_values is not None:
            result['ReceiverValues'] = self.receiver_values
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ReceiverType') is not None:
            self.receiver_type = m.get('ReceiverType')
        if m.get('ReceiverValues') is not None:
            self.receiver_values = m.get('ReceiverValues')
        return self


class GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettings(TeaModel):
    def __init__(self, inhibition_interval=None, notification_channels=None, notification_receivers=None):
        self.inhibition_interval = inhibition_interval  # type: int
        self.notification_channels = notification_channels  # type: list[GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettingsNotificationChannels]
        self.notification_receivers = notification_receivers  # type: list[GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettingsNotificationReceivers]

    def validate(self):
        if self.notification_channels:
            for k in self.notification_channels:
                if k:
                    k.validate()
        if self.notification_receivers:
            for k in self.notification_receivers:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.inhibition_interval is not None:
            result['InhibitionInterval'] = self.inhibition_interval
        result['NotificationChannels'] = []
        if self.notification_channels is not None:
            for k in self.notification_channels:
                result['NotificationChannels'].append(k.to_map() if k else None)
        result['NotificationReceivers'] = []
        if self.notification_receivers is not None:
            for k in self.notification_receivers:
                result['NotificationReceivers'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InhibitionInterval') is not None:
            self.inhibition_interval = m.get('InhibitionInterval')
        self.notification_channels = []
        if m.get('NotificationChannels') is not None:
            for k in m.get('NotificationChannels'):
                temp_model = GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettingsNotificationChannels()
                self.notification_channels.append(temp_model.from_map(k))
        self.notification_receivers = []
        if m.get('NotificationReceivers') is not None:
            for k in m.get('NotificationReceivers'):
                temp_model = GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettingsNotificationReceivers()
                self.notification_receivers.append(temp_model.from_map(k))
        return self


class GetDIAlarmRuleResponseBodyDIAlarmRuleTriggerConditions(TeaModel):
    def __init__(self, duration=None, severity=None, threshold=None):
        self.duration = duration  # type: long
        self.severity = severity  # type: str
        self.threshold = threshold  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIAlarmRuleResponseBodyDIAlarmRuleTriggerConditions, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.duration is not None:
            result['Duration'] = self.duration
        if self.severity is not None:
            result['Severity'] = self.severity
        if self.threshold is not None:
            result['Threshold'] = self.threshold
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Duration') is not None:
            self.duration = m.get('Duration')
        if m.get('Severity') is not None:
            self.severity = m.get('Severity')
        if m.get('Threshold') is not None:
            self.threshold = m.get('Threshold')
        return self


class GetDIAlarmRuleResponseBodyDIAlarmRule(TeaModel):
    def __init__(self, created_time=None, created_uid=None, dialarm_rule_id=None, dijob_id=None, description=None,
                 enabled=None, metric_type=None, notification_settings=None, trigger_conditions=None, updated_time=None,
                 updated_uid=None):
        self.created_time = created_time  # type: long
        self.created_uid = created_uid  # type: str
        self.dialarm_rule_id = dialarm_rule_id  # type: long
        self.dijob_id = dijob_id  # type: long
        self.description = description  # type: str
        self.enabled = enabled  # type: bool
        self.metric_type = metric_type  # type: str
        self.notification_settings = notification_settings  # type: GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettings
        self.trigger_conditions = trigger_conditions  # type: list[GetDIAlarmRuleResponseBodyDIAlarmRuleTriggerConditions]
        self.updated_time = updated_time  # type: long
        self.updated_uid = updated_uid  # type: str

    def validate(self):
        if self.notification_settings:
            self.notification_settings.validate()
        if self.trigger_conditions:
            for k in self.trigger_conditions:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDIAlarmRuleResponseBodyDIAlarmRule, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.created_uid is not None:
            result['CreatedUid'] = self.created_uid
        if self.dialarm_rule_id is not None:
            result['DIAlarmRuleId'] = self.dialarm_rule_id
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.description is not None:
            result['Description'] = self.description
        if self.enabled is not None:
            result['Enabled'] = self.enabled
        if self.metric_type is not None:
            result['MetricType'] = self.metric_type
        if self.notification_settings is not None:
            result['NotificationSettings'] = self.notification_settings.to_map()
        result['TriggerConditions'] = []
        if self.trigger_conditions is not None:
            for k in self.trigger_conditions:
                result['TriggerConditions'].append(k.to_map() if k else None)
        if self.updated_time is not None:
            result['UpdatedTime'] = self.updated_time
        if self.updated_uid is not None:
            result['UpdatedUid'] = self.updated_uid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('CreatedUid') is not None:
            self.created_uid = m.get('CreatedUid')
        if m.get('DIAlarmRuleId') is not None:
            self.dialarm_rule_id = m.get('DIAlarmRuleId')
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Enabled') is not None:
            self.enabled = m.get('Enabled')
        if m.get('MetricType') is not None:
            self.metric_type = m.get('MetricType')
        if m.get('NotificationSettings') is not None:
            temp_model = GetDIAlarmRuleResponseBodyDIAlarmRuleNotificationSettings()
            self.notification_settings = temp_model.from_map(m['NotificationSettings'])
        self.trigger_conditions = []
        if m.get('TriggerConditions') is not None:
            for k in m.get('TriggerConditions'):
                temp_model = GetDIAlarmRuleResponseBodyDIAlarmRuleTriggerConditions()
                self.trigger_conditions.append(temp_model.from_map(k))
        if m.get('UpdatedTime') is not None:
            self.updated_time = m.get('UpdatedTime')
        if m.get('UpdatedUid') is not None:
            self.updated_uid = m.get('UpdatedUid')
        return self


class GetDIAlarmRuleResponseBody(TeaModel):
    def __init__(self, dialarm_rule=None, request_id=None):
        self.dialarm_rule = dialarm_rule  # type: GetDIAlarmRuleResponseBodyDIAlarmRule
        self.request_id = request_id  # type: str

    def validate(self):
        if self.dialarm_rule:
            self.dialarm_rule.validate()

    def to_map(self):
        _map = super(GetDIAlarmRuleResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dialarm_rule is not None:
            result['DIAlarmRule'] = self.dialarm_rule.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIAlarmRule') is not None:
            temp_model = GetDIAlarmRuleResponseBodyDIAlarmRule()
            self.dialarm_rule = temp_model.from_map(m['DIAlarmRule'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetDIAlarmRuleResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDIAlarmRuleResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDIAlarmRuleResponse, self).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=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 = GetDIAlarmRuleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDIJobRequest(TeaModel):
    def __init__(self, dijob_id=None, with_details=None):
        self.dijob_id = dijob_id  # type: long
        self.with_details = with_details  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIJobRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.with_details is not None:
            result['WithDetails'] = self.with_details
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('WithDetails') is not None:
            self.with_details = m.get('WithDetails')
        return self


class GetDIJobResponseBodyDataDestinationDataSourceSettings(TeaModel):
    def __init__(self, data_source_name=None, data_source_properties=None):
        self.data_source_name = data_source_name  # type: str
        self.data_source_properties = data_source_properties  # type: dict[str, str]

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataDestinationDataSourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data_source_name is not None:
            result['DataSourceName'] = self.data_source_name
        if self.data_source_properties is not None:
            result['DataSourceProperties'] = self.data_source_properties
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DataSourceName') is not None:
            self.data_source_name = m.get('DataSourceName')
        if m.get('DataSourceProperties') is not None:
            self.data_source_properties = m.get('DataSourceProperties')
        return self


class GetDIJobResponseBodyDataJobSettingsColumnDataTypeSettings(TeaModel):
    def __init__(self, destination_data_type=None, source_data_type=None):
        self.destination_data_type = destination_data_type  # type: str
        self.source_data_type = source_data_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataJobSettingsColumnDataTypeSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.destination_data_type is not None:
            result['DestinationDataType'] = self.destination_data_type
        if self.source_data_type is not None:
            result['SourceDataType'] = self.source_data_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DestinationDataType') is not None:
            self.destination_data_type = m.get('DestinationDataType')
        if m.get('SourceDataType') is not None:
            self.source_data_type = m.get('SourceDataType')
        return self


class GetDIJobResponseBodyDataJobSettingsDdlHandlingSettings(TeaModel):
    def __init__(self, action=None, type=None):
        self.action = action  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataJobSettingsDdlHandlingSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.action is not None:
            result['Action'] = self.action
        if self.type is not None:
            result['Type'] = self.type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Action') is not None:
            self.action = m.get('Action')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class GetDIJobResponseBodyDataJobSettingsRuntimeSettings(TeaModel):
    def __init__(self, name=None, value=None):
        self.name = name  # type: str
        self.value = value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataJobSettingsRuntimeSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.name is not None:
            result['Name'] = self.name
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class GetDIJobResponseBodyDataJobSettings(TeaModel):
    def __init__(self, column_data_type_settings=None, ddl_handling_settings=None, runtime_settings=None):
        self.column_data_type_settings = column_data_type_settings  # type: list[GetDIJobResponseBodyDataJobSettingsColumnDataTypeSettings]
        self.ddl_handling_settings = ddl_handling_settings  # type: list[GetDIJobResponseBodyDataJobSettingsDdlHandlingSettings]
        self.runtime_settings = runtime_settings  # type: list[GetDIJobResponseBodyDataJobSettingsRuntimeSettings]

    def validate(self):
        if self.column_data_type_settings:
            for k in self.column_data_type_settings:
                if k:
                    k.validate()
        if self.ddl_handling_settings:
            for k in self.ddl_handling_settings:
                if k:
                    k.validate()
        if self.runtime_settings:
            for k in self.runtime_settings:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataJobSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ColumnDataTypeSettings'] = []
        if self.column_data_type_settings is not None:
            for k in self.column_data_type_settings:
                result['ColumnDataTypeSettings'].append(k.to_map() if k else None)
        result['DdlHandlingSettings'] = []
        if self.ddl_handling_settings is not None:
            for k in self.ddl_handling_settings:
                result['DdlHandlingSettings'].append(k.to_map() if k else None)
        result['RuntimeSettings'] = []
        if self.runtime_settings is not None:
            for k in self.runtime_settings:
                result['RuntimeSettings'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.column_data_type_settings = []
        if m.get('ColumnDataTypeSettings') is not None:
            for k in m.get('ColumnDataTypeSettings'):
                temp_model = GetDIJobResponseBodyDataJobSettingsColumnDataTypeSettings()
                self.column_data_type_settings.append(temp_model.from_map(k))
        self.ddl_handling_settings = []
        if m.get('DdlHandlingSettings') is not None:
            for k in m.get('DdlHandlingSettings'):
                temp_model = GetDIJobResponseBodyDataJobSettingsDdlHandlingSettings()
                self.ddl_handling_settings.append(temp_model.from_map(k))
        self.runtime_settings = []
        if m.get('RuntimeSettings') is not None:
            for k in m.get('RuntimeSettings'):
                temp_model = GetDIJobResponseBodyDataJobSettingsRuntimeSettings()
                self.runtime_settings.append(temp_model.from_map(k))
        return self


class GetDIJobResponseBodyDataResourceSettingsOfflineResourceSettings(TeaModel):
    def __init__(self, resource_group_identifier=None):
        self.resource_group_identifier = resource_group_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataResourceSettingsOfflineResourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.resource_group_identifier is not None:
            result['ResourceGroupIdentifier'] = self.resource_group_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ResourceGroupIdentifier') is not None:
            self.resource_group_identifier = m.get('ResourceGroupIdentifier')
        return self


class GetDIJobResponseBodyDataResourceSettingsRealtimeResourceSettings(TeaModel):
    def __init__(self, resource_group_identifier=None):
        self.resource_group_identifier = resource_group_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataResourceSettingsRealtimeResourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.resource_group_identifier is not None:
            result['ResourceGroupIdentifier'] = self.resource_group_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ResourceGroupIdentifier') is not None:
            self.resource_group_identifier = m.get('ResourceGroupIdentifier')
        return self


class GetDIJobResponseBodyDataResourceSettings(TeaModel):
    def __init__(self, offline_resource_settings=None, realtime_resource_settings=None):
        self.offline_resource_settings = offline_resource_settings  # type: GetDIJobResponseBodyDataResourceSettingsOfflineResourceSettings
        self.realtime_resource_settings = realtime_resource_settings  # type: GetDIJobResponseBodyDataResourceSettingsRealtimeResourceSettings

    def validate(self):
        if self.offline_resource_settings:
            self.offline_resource_settings.validate()
        if self.realtime_resource_settings:
            self.realtime_resource_settings.validate()

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataResourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.offline_resource_settings is not None:
            result['OfflineResourceSettings'] = self.offline_resource_settings.to_map()
        if self.realtime_resource_settings is not None:
            result['RealtimeResourceSettings'] = self.realtime_resource_settings.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('OfflineResourceSettings') is not None:
            temp_model = GetDIJobResponseBodyDataResourceSettingsOfflineResourceSettings()
            self.offline_resource_settings = temp_model.from_map(m['OfflineResourceSettings'])
        if m.get('RealtimeResourceSettings') is not None:
            temp_model = GetDIJobResponseBodyDataResourceSettingsRealtimeResourceSettings()
            self.realtime_resource_settings = temp_model.from_map(m['RealtimeResourceSettings'])
        return self


class GetDIJobResponseBodyDataSourceDataSourceSettings(TeaModel):
    def __init__(self, data_source_name=None, data_source_properties=None):
        self.data_source_name = data_source_name  # type: str
        self.data_source_properties = data_source_properties  # type: dict[str, str]

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataSourceDataSourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data_source_name is not None:
            result['DataSourceName'] = self.data_source_name
        if self.data_source_properties is not None:
            result['DataSourceProperties'] = self.data_source_properties
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DataSourceName') is not None:
            self.data_source_name = m.get('DataSourceName')
        if m.get('DataSourceProperties') is not None:
            self.data_source_properties = m.get('DataSourceProperties')
        return self


class GetDIJobResponseBodyDataTableMappingsSourceObjectSelectionRules(TeaModel):
    def __init__(self, expression=None, object_type=None):
        self.expression = expression  # type: str
        self.object_type = object_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataTableMappingsSourceObjectSelectionRules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.expression is not None:
            result['Expression'] = self.expression
        if self.object_type is not None:
            result['ObjectType'] = self.object_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Expression') is not None:
            self.expression = m.get('Expression')
        if m.get('ObjectType') is not None:
            self.object_type = m.get('ObjectType')
        return self


class GetDIJobResponseBodyDataTableMappingsTransformationRules(TeaModel):
    def __init__(self, rule_action_type=None, rule_name=None, rule_target_type=None):
        self.rule_action_type = rule_action_type  # type: str
        self.rule_name = rule_name  # type: str
        self.rule_target_type = rule_target_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataTableMappingsTransformationRules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.rule_action_type is not None:
            result['RuleActionType'] = self.rule_action_type
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        if self.rule_target_type is not None:
            result['RuleTargetType'] = self.rule_target_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RuleActionType') is not None:
            self.rule_action_type = m.get('RuleActionType')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        if m.get('RuleTargetType') is not None:
            self.rule_target_type = m.get('RuleTargetType')
        return self


class GetDIJobResponseBodyDataTableMappings(TeaModel):
    def __init__(self, source_object_selection_rules=None, transformation_rules=None):
        self.source_object_selection_rules = source_object_selection_rules  # type: list[GetDIJobResponseBodyDataTableMappingsSourceObjectSelectionRules]
        self.transformation_rules = transformation_rules  # type: list[GetDIJobResponseBodyDataTableMappingsTransformationRules]

    def validate(self):
        if self.source_object_selection_rules:
            for k in self.source_object_selection_rules:
                if k:
                    k.validate()
        if self.transformation_rules:
            for k in self.transformation_rules:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataTableMappings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['SourceObjectSelectionRules'] = []
        if self.source_object_selection_rules is not None:
            for k in self.source_object_selection_rules:
                result['SourceObjectSelectionRules'].append(k.to_map() if k else None)
        result['TransformationRules'] = []
        if self.transformation_rules is not None:
            for k in self.transformation_rules:
                result['TransformationRules'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.source_object_selection_rules = []
        if m.get('SourceObjectSelectionRules') is not None:
            for k in m.get('SourceObjectSelectionRules'):
                temp_model = GetDIJobResponseBodyDataTableMappingsSourceObjectSelectionRules()
                self.source_object_selection_rules.append(temp_model.from_map(k))
        self.transformation_rules = []
        if m.get('TransformationRules') is not None:
            for k in m.get('TransformationRules'):
                temp_model = GetDIJobResponseBodyDataTableMappingsTransformationRules()
                self.transformation_rules.append(temp_model.from_map(k))
        return self


class GetDIJobResponseBodyDataTransformationRules(TeaModel):
    def __init__(self, rule_action_type=None, rule_expression=None, rule_name=None, rule_target_type=None):
        self.rule_action_type = rule_action_type  # type: str
        self.rule_expression = rule_expression  # type: str
        self.rule_name = rule_name  # type: str
        self.rule_target_type = rule_target_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDIJobResponseBodyDataTransformationRules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.rule_action_type is not None:
            result['RuleActionType'] = self.rule_action_type
        if self.rule_expression is not None:
            result['RuleExpression'] = self.rule_expression
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        if self.rule_target_type is not None:
            result['RuleTargetType'] = self.rule_target_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RuleActionType') is not None:
            self.rule_action_type = m.get('RuleActionType')
        if m.get('RuleExpression') is not None:
            self.rule_expression = m.get('RuleExpression')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        if m.get('RuleTargetType') is not None:
            self.rule_target_type = m.get('RuleTargetType')
        return self


class GetDIJobResponseBodyData(TeaModel):
    def __init__(self, created_time=None, created_uid=None, dijob_id=None, description=None,
                 destination_data_source_settings=None, destination_data_source_type=None, error_message=None, job_name=None, job_settings=None,
                 job_status=None, migration_type=None, project_id=None, resource_settings=None, run_stats=None,
                 source_data_source_settings=None, source_data_source_type=None, started_time=None, started_uid=None, table_mappings=None,
                 transformation_rules=None, updated_time=None, updated_uid=None):
        self.created_time = created_time  # type: long
        self.created_uid = created_uid  # type: str
        self.dijob_id = dijob_id  # type: long
        self.description = description  # type: str
        self.destination_data_source_settings = destination_data_source_settings  # type: list[GetDIJobResponseBodyDataDestinationDataSourceSettings]
        self.destination_data_source_type = destination_data_source_type  # type: str
        self.error_message = error_message  # type: str
        self.job_name = job_name  # type: str
        self.job_settings = job_settings  # type: GetDIJobResponseBodyDataJobSettings
        self.job_status = job_status  # type: str
        self.migration_type = migration_type  # type: str
        self.project_id = project_id  # type: long
        self.resource_settings = resource_settings  # type: GetDIJobResponseBodyDataResourceSettings
        self.run_stats = run_stats  # type: dict[str, str]
        self.source_data_source_settings = source_data_source_settings  # type: list[GetDIJobResponseBodyDataSourceDataSourceSettings]
        self.source_data_source_type = source_data_source_type  # type: str
        self.started_time = started_time  # type: long
        self.started_uid = started_uid  # type: str
        self.table_mappings = table_mappings  # type: list[GetDIJobResponseBodyDataTableMappings]
        self.transformation_rules = transformation_rules  # type: list[GetDIJobResponseBodyDataTransformationRules]
        self.updated_time = updated_time  # type: long
        self.updated_uid = updated_uid  # type: str

    def validate(self):
        if self.destination_data_source_settings:
            for k in self.destination_data_source_settings:
                if k:
                    k.validate()
        if self.job_settings:
            self.job_settings.validate()
        if self.resource_settings:
            self.resource_settings.validate()
        if self.source_data_source_settings:
            for k in self.source_data_source_settings:
                if k:
                    k.validate()
        if self.table_mappings:
            for k in self.table_mappings:
                if k:
                    k.validate()
        if self.transformation_rules:
            for k in self.transformation_rules:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDIJobResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.created_uid is not None:
            result['CreatedUid'] = self.created_uid
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.description is not None:
            result['Description'] = self.description
        result['DestinationDataSourceSettings'] = []
        if self.destination_data_source_settings is not None:
            for k in self.destination_data_source_settings:
                result['DestinationDataSourceSettings'].append(k.to_map() if k else None)
        if self.destination_data_source_type is not None:
            result['DestinationDataSourceType'] = self.destination_data_source_type
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.job_name is not None:
            result['JobName'] = self.job_name
        if self.job_settings is not None:
            result['JobSettings'] = self.job_settings.to_map()
        if self.job_status is not None:
            result['JobStatus'] = self.job_status
        if self.migration_type is not None:
            result['MigrationType'] = self.migration_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.resource_settings is not None:
            result['ResourceSettings'] = self.resource_settings.to_map()
        if self.run_stats is not None:
            result['RunStats'] = self.run_stats
        result['SourceDataSourceSettings'] = []
        if self.source_data_source_settings is not None:
            for k in self.source_data_source_settings:
                result['SourceDataSourceSettings'].append(k.to_map() if k else None)
        if self.source_data_source_type is not None:
            result['SourceDataSourceType'] = self.source_data_source_type
        if self.started_time is not None:
            result['StartedTime'] = self.started_time
        if self.started_uid is not None:
            result['StartedUid'] = self.started_uid
        result['TableMappings'] = []
        if self.table_mappings is not None:
            for k in self.table_mappings:
                result['TableMappings'].append(k.to_map() if k else None)
        result['TransformationRules'] = []
        if self.transformation_rules is not None:
            for k in self.transformation_rules:
                result['TransformationRules'].append(k.to_map() if k else None)
        if self.updated_time is not None:
            result['UpdatedTime'] = self.updated_time
        if self.updated_uid is not None:
            result['UpdatedUid'] = self.updated_uid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('CreatedUid') is not None:
            self.created_uid = m.get('CreatedUid')
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        self.destination_data_source_settings = []
        if m.get('DestinationDataSourceSettings') is not None:
            for k in m.get('DestinationDataSourceSettings'):
                temp_model = GetDIJobResponseBodyDataDestinationDataSourceSettings()
                self.destination_data_source_settings.append(temp_model.from_map(k))
        if m.get('DestinationDataSourceType') is not None:
            self.destination_data_source_type = m.get('DestinationDataSourceType')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('JobName') is not None:
            self.job_name = m.get('JobName')
        if m.get('JobSettings') is not None:
            temp_model = GetDIJobResponseBodyDataJobSettings()
            self.job_settings = temp_model.from_map(m['JobSettings'])
        if m.get('JobStatus') is not None:
            self.job_status = m.get('JobStatus')
        if m.get('MigrationType') is not None:
            self.migration_type = m.get('MigrationType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ResourceSettings') is not None:
            temp_model = GetDIJobResponseBodyDataResourceSettings()
            self.resource_settings = temp_model.from_map(m['ResourceSettings'])
        if m.get('RunStats') is not None:
            self.run_stats = m.get('RunStats')
        self.source_data_source_settings = []
        if m.get('SourceDataSourceSettings') is not None:
            for k in m.get('SourceDataSourceSettings'):
                temp_model = GetDIJobResponseBodyDataSourceDataSourceSettings()
                self.source_data_source_settings.append(temp_model.from_map(k))
        if m.get('SourceDataSourceType') is not None:
            self.source_data_source_type = m.get('SourceDataSourceType')
        if m.get('StartedTime') is not None:
            self.started_time = m.get('StartedTime')
        if m.get('StartedUid') is not None:
            self.started_uid = m.get('StartedUid')
        self.table_mappings = []
        if m.get('TableMappings') is not None:
            for k in m.get('TableMappings'):
                temp_model = GetDIJobResponseBodyDataTableMappings()
                self.table_mappings.append(temp_model.from_map(k))
        self.transformation_rules = []
        if m.get('TransformationRules') is not None:
            for k in m.get('TransformationRules'):
                temp_model = GetDIJobResponseBodyDataTransformationRules()
                self.transformation_rules.append(temp_model.from_map(k))
        if m.get('UpdatedTime') is not None:
            self.updated_time = m.get('UpdatedTime')
        if m.get('UpdatedUid') is not None:
            self.updated_uid = m.get('UpdatedUid')
        return self


class GetDIJobResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None):
        self.data = data  # type: GetDIJobResponseBodyData
        self.request_id = request_id  # type: str

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetDIJobResponseBody, self).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=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetDIJobResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetDIJobResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDIJobResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDIJobResponse, self).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=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 = GetDIJobResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDISyncInstanceInfoRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, task_type=None):
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.file_id = file_id  # type: long
        # The type of the object that you want to query. Valid values:
        # 
        # *   DI_REALTIME: real-time synchronization node
        # *   DI_SOLUTION: data synchronization solution
        self.project_id = project_id  # type: long
        # *   If you set the TaskType parameter to DI_REALTIME, set the FileId parameter to the ID of the real-time synchronization node that you want to query.
        # *   If you set the TaskType parameter to DI_SOLUTION, set the FileId parameter to the ID of the data synchronization solution that you want to query.
        # 
        # You can call the [ListFiles](~~173942~~) operation to obtain the ID of the real-time synchronization node or data synchronization solution.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDISyncInstanceInfoRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class GetDISyncInstanceInfoResponseBodyDataSolutionInfoStepDetail(TeaModel):
    def __init__(self, info=None, status=None, step_id=None, step_name=None):
        self.info = info  # type: str
        # The ID of the step in the data synchronization solution.
        self.status = status  # type: str
        # The name of the step in the data synchronization solution.
        self.step_id = step_id  # type: long
        # The information of the data synchronization solution.
        self.step_name = step_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDISyncInstanceInfoResponseBodyDataSolutionInfoStepDetail, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.info is not None:
            result['Info'] = self.info
        if self.status is not None:
            result['Status'] = self.status
        if self.step_id is not None:
            result['StepId'] = self.step_id
        if self.step_name is not None:
            result['StepName'] = self.step_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Info') is not None:
            self.info = m.get('Info')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('StepId') is not None:
            self.step_id = m.get('StepId')
        if m.get('StepName') is not None:
            self.step_name = m.get('StepName')
        return self


class GetDISyncInstanceInfoResponseBodyDataSolutionInfo(TeaModel):
    def __init__(self, creator_name=None, id=None, status=None, step_detail=None):
        # The step details of the synchronization solution.
        self.creator_name = creator_name  # type: str
        # The creator of the data synchronization solution.
        self.id = id  # type: long
        # The ID of the data synchronization solution.
        self.status = status  # type: str
        # The status of the step in the data synchronization solution.
        self.step_detail = step_detail  # type: list[GetDISyncInstanceInfoResponseBodyDataSolutionInfoStepDetail]

    def validate(self):
        if self.step_detail:
            for k in self.step_detail:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDISyncInstanceInfoResponseBodyDataSolutionInfo, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.creator_name is not None:
            result['CreatorName'] = self.creator_name
        if self.id is not None:
            result['Id'] = self.id
        if self.status is not None:
            result['Status'] = self.status
        result['StepDetail'] = []
        if self.step_detail is not None:
            for k in self.step_detail:
                result['StepDetail'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreatorName') is not None:
            self.creator_name = m.get('CreatorName')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        self.step_detail = []
        if m.get('StepDetail') is not None:
            for k in m.get('StepDetail'):
                temp_model = GetDISyncInstanceInfoResponseBodyDataSolutionInfoStepDetail()
                self.step_detail.append(temp_model.from_map(k))
        return self


class GetDISyncInstanceInfoResponseBodyData(TeaModel):
    def __init__(self, message=None, name=None, solution_info=None, status=None):
        # *   If the TaskType parameter is set to DI_REALTIME, the Name parameter indicates the name of the real-time synchronization node.
        # *   If the TaskType parameter is set to DI_SOLITION, the value null is returned.
        self.message = message  # type: str
        # *   If the TaskType parameter is set to DI_REALTIME, the value null is returned.
        # *   If the TaskType parameter is set to DI_SOLITION, the SolutionInfo parameter indicates the details of the data synchronization solution.
        self.name = name  # type: str
        # The status of the data synchronization solution.
        self.solution_info = solution_info  # type: GetDISyncInstanceInfoResponseBodyDataSolutionInfo
        # The cause of the failure to obtain the status of the real-time synchronization node or data synchronization solution. If the status of the real-time synchronization node or data synchronization solution is obtained, the value null is returned.
        self.status = status  # type: str

    def validate(self):
        if self.solution_info:
            self.solution_info.validate()

    def to_map(self):
        _map = super(GetDISyncInstanceInfoResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.name is not None:
            result['Name'] = self.name
        if self.solution_info is not None:
            result['SolutionInfo'] = self.solution_info.to_map()
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('SolutionInfo') is not None:
            temp_model = GetDISyncInstanceInfoResponseBodyDataSolutionInfo()
            self.solution_info = temp_model.from_map(m['SolutionInfo'])
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetDISyncInstanceInfoResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # *   If the TaskType parameter is set to DI_REALTIME, the Status parameter indicates the status of the real-time synchronization node. Valid values: PAUSE, NORUN, RUN, KILLING, and WAIT.
        # *   If the TaskType parameter is set to DI_SOLITION, the Status parameter indicates the status of the data synchronization solution. Valid values: success and fail.
        self.data = data  # type: GetDISyncInstanceInfoResponseBodyData
        # The status of the real-time synchronization node or data synchronization solution.
        self.request_id = request_id  # type: str
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetDISyncInstanceInfoResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetDISyncInstanceInfoResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetDISyncInstanceInfoResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDISyncInstanceInfoResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDISyncInstanceInfoResponse, self).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=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 = GetDISyncInstanceInfoResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDISyncTaskRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, task_type=None):
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.file_id = file_id  # type: long
        # The type of the object that you want to query. Valid values:
        # 
        # *   DI_REALTIME: real-time synchronization node
        # *   DI_SOLUTION: data synchronization solution
        self.project_id = project_id  # type: long
        # *   If you set the TaskType parameter to DI_REALTIME, set the FileId parameter to the ID of the real-time synchronization node that you want to query.
        # *   If you set the TaskType parameter to DI_SOLUTION, set the FileId parameter to the ID of the data synchronization solution that you want to query.
        # 
        # You can call the [ListFiles](~~173942~~) operation to query the ID of the real-time synchronization node or data synchronization solution.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDISyncTaskRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class GetDISyncTaskResponseBodyDataSolutionDetail(TeaModel):
    def __init__(self, creator_name=None, id=None, name=None, process_content=None, process_extra=None,
                 project_id=None, source_type=None, start_time=None, status=None, submit_time=None, type=None):
        # The ID of the project to which the data synchronization solution belongs.
        self.creator_name = creator_name  # type: str
        self.id = id  # type: long
        # The additional parameters of the data synchronization solution.
        self.name = name  # type: str
        # The name of the data synchronization solution.
        self.process_content = process_content  # type: str
        # The time when the data synchronization solution was committed.
        self.process_extra = process_extra  # type: str
        # The type of the source of the data synchronization solution.
        self.project_id = project_id  # type: long
        # The configuration details of the data synchronization solution.
        self.source_type = source_type  # type: str
        # The creator of the data synchronization solution.
        self.start_time = start_time  # type: str
        # The type of the data synchronization solution.
        self.status = status  # type: str
        # The ID of the data synchronization solution.
        self.submit_time = submit_time  # type: str
        # The start time of the data synchronization solution.
        self.type = type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDISyncTaskResponseBodyDataSolutionDetail, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.creator_name is not None:
            result['CreatorName'] = self.creator_name
        if self.id is not None:
            result['Id'] = self.id
        if self.name is not None:
            result['Name'] = self.name
        if self.process_content is not None:
            result['ProcessContent'] = self.process_content
        if self.process_extra is not None:
            result['ProcessExtra'] = self.process_extra
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.source_type is not None:
            result['SourceType'] = self.source_type
        if self.start_time is not None:
            result['StartTime'] = self.start_time
        if self.status is not None:
            result['Status'] = self.status
        if self.submit_time is not None:
            result['SubmitTime'] = self.submit_time
        if self.type is not None:
            result['Type'] = self.type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreatorName') is not None:
            self.creator_name = m.get('CreatorName')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ProcessContent') is not None:
            self.process_content = m.get('ProcessContent')
        if m.get('ProcessExtra') is not None:
            self.process_extra = m.get('ProcessExtra')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SourceType') is not None:
            self.source_type = m.get('SourceType')
        if m.get('StartTime') is not None:
            self.start_time = m.get('StartTime')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('SubmitTime') is not None:
            self.submit_time = m.get('SubmitTime')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class GetDISyncTaskResponseBodyData(TeaModel):
    def __init__(self, code=None, message=None, solution_detail=None, status=None):
        # Indicates whether the details of the real-time synchronization node or data synchronization solution are obtained. Valid values:
        # 
        # success: The details are obtained.
        # 
        # fail: The details fail to be obtained.
        self.code = code  # type: str
        # *   If the TaskType parameter is set to DI_REALTIME, the value null is returned.
        # *   If the TaskType parameter is set to DI_SOLUTION, the details of the data synchronization solution task are returned.
        self.message = message  # type: str
        # The status of the data synchronization solution. Valid values:
        # 
        # *   0: successful
        # *   1: not running
        # *   2: running
        # *   3: failed
        # *   4: committed
        # *   5: pending manual confirmation
        # *   6: manually confirmed
        # *   7: others
        # *   8: waiting
        # *   9: deleted
        self.solution_detail = solution_detail  # type: GetDISyncTaskResponseBodyDataSolutionDetail
        # The cause of the failure to obtain the details of the real-time synchronization node or data synchronization solution.
        # 
        # If the details of the real-time synchronization node or data synchronization solution are obtained, the value null is returned.
        self.status = status  # type: str

    def validate(self):
        if self.solution_detail:
            self.solution_detail.validate()

    def to_map(self):
        _map = super(GetDISyncTaskResponseBodyData, self).to_map()
        if _map is not None:
            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.solution_detail is not None:
            result['SolutionDetail'] = self.solution_detail.to_map()
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=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('SolutionDetail') is not None:
            temp_model = GetDISyncTaskResponseBodyDataSolutionDetail()
            self.solution_detail = temp_model.from_map(m['SolutionDetail'])
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetDISyncTaskResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # *   If the TaskType parameter is set to DI_REALTIME, the details of the real-time synchronization node are returned.
        # *   If the TaskType parameter is set to DI_SOLUTION, the value null is returned.
        self.data = data  # type: GetDISyncTaskResponseBodyData
        # The details of the real-time synchronization node or data synchronization solution.
        self.request_id = request_id  # type: str
        # The ID of the request. You can query logs and troubleshoot issues based on the ID.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetDISyncTaskResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetDISyncTaskResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetDISyncTaskResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDISyncTaskResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDISyncTaskResponse, self).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=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 = GetDISyncTaskResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDagRequest(TeaModel):
    def __init__(self, dag_id=None, project_env=None):
        # The ID of the DAG. You can set this parameter to the value of the DagId parameter returned by the CreateDagComplement, CreateTest, or CreateManualDag operation.
        self.dag_id = dag_id  # type: long
        # The environment type. Valid values: PROD and DEV. The value PROD indicates the production environment. The value DEV indicates the development environment.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDagRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class GetDagResponseBodyData(TeaModel):
    def __init__(self, bizdate=None, create_time=None, create_user=None, dag_id=None, finish_time=None, gmtdate=None,
                 modify_time=None, name=None, op_seq=None, project_id=None, start_time=None, status=None, type=None):
        # The data timestamp.
        self.bizdate = bizdate  # type: long
        # The time at which the DAG was created. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.create_time = create_time  # type: long
        # The user who created the DAG.
        self.create_user = create_user  # type: str
        # The ID of the DAG.
        self.dag_id = dag_id  # type: long
        # The time at which the DAG finished running. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.finish_time = finish_time  # type: long
        # The time at which the DAG was scheduled to run.
        self.gmtdate = gmtdate  # type: long
        # The time at which the DAG was last modified. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.modify_time = modify_time  # type: long
        # The name of the DAG.
        self.name = name  # type: str
        # The sequence number of the operation.
        self.op_seq = op_seq  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The time at which the DAG started to run.
        self.start_time = start_time  # type: long
        # The status of the DAG. Valid values: CREATED, RUNNING, FAILURE, and SUCCESS.
        self.status = status  # type: str
        # The type of the DAG. Valid values: MANUAL, SMOKE_TEST, SUPPLY_DATA, and BUSINESS_PROCESS_DAG.
        self.type = type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDagResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.create_user is not None:
            result['CreateUser'] = self.create_user
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.gmtdate is not None:
            result['Gmtdate'] = self.gmtdate
        if self.modify_time is not None:
            result['ModifyTime'] = self.modify_time
        if self.name is not None:
            result['Name'] = self.name
        if self.op_seq is not None:
            result['OpSeq'] = self.op_seq
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.start_time is not None:
            result['StartTime'] = self.start_time
        if self.status is not None:
            result['Status'] = self.status
        if self.type is not None:
            result['Type'] = self.type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('CreateUser') is not None:
            self.create_user = m.get('CreateUser')
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('Gmtdate') is not None:
            self.gmtdate = m.get('Gmtdate')
        if m.get('ModifyTime') is not None:
            self.modify_time = m.get('ModifyTime')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('OpSeq') is not None:
            self.op_seq = m.get('OpSeq')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('StartTime') is not None:
            self.start_time = m.get('StartTime')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class GetDagResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The details of the DAG.
        self.data = data  # type: GetDagResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to locate logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetDagResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetDagResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetDagResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDagResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDagResponse, self).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=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 = GetDagResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDataServiceApiRequest(TeaModel):
    def __init__(self, api_id=None, project_id=None, tenant_id=None):
        # The ID of the DataService Studio API.
        self.api_id = api_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApiRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class GetDataServiceApiResponseBodyDataRegistrationDetailsRegistrationErrorCodes(TeaModel):
    def __init__(self, error_code=None, error_message=None, error_solution=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The solution used to fix the error.
        self.error_solution = error_solution  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyDataRegistrationDetailsRegistrationErrorCodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.error_solution is not None:
            result['ErrorSolution'] = self.error_solution
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('ErrorSolution') is not None:
            self.error_solution = m.get('ErrorSolution')
        return self


class GetDataServiceApiResponseBodyDataRegistrationDetailsRegistrationRequestParameters(TeaModel):
    def __init__(self, column_name=None, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The name of the associated field. This parameter is supported only if the API is generated in wizard mode.
        self.column_name = column_name  # type: str
        # The default value.
        self.default_value = default_value  # type: str
        # The sample value.
        self.example_value = example_value  # type: str
        # Indicates whether the parameter is required.
        self.is_required_parameter = is_required_parameter  # type: bool
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. The value 0 indicates the STRING data type, the value 1 indicates the INT data type, the value 2 indicates the LONG data type, the value 3 indicates the FLOAT data type, the value 4 indicates the DOUBLE data type, and the value 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str
        # The operator used for the value of the parameter. Valid values:
        # 
        # *   0: indicates that the operator is Equal.
        # *   1: indicates that the operator is Like.
        # *   2: indicates that the operator is Const.
        # *   3: indicates that the operator is In.
        # 
        # APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.parameter_operator = parameter_operator  # type: int
        # The position of the parameter. Valid values:
        # 
        # *   0: indicates that the parameter is in the URL path of the request.
        # *   1: indicates that the parameter is in the Query parameter of the request URL.
        # *   2: indicates that the parameter is in the request header.
        # *   3: indicates that the parameter is in the request body.
        # 
        # APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyDataRegistrationDetailsRegistrationRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class GetDataServiceApiResponseBodyDataRegistrationDetails(TeaModel):
    def __init__(self, failed_result_sample=None, registration_error_codes=None,
                 registration_request_parameters=None, service_content_type=None, service_host=None, service_path=None,
                 service_request_body_description=None, successful_result_sample=None):
        # The sample error response of the API.
        self.failed_result_sample = failed_result_sample  # type: str
        # The error codes returned for the API generated by registration.
        self.registration_error_codes = registration_error_codes  # type: list[GetDataServiceApiResponseBodyDataRegistrationDetailsRegistrationErrorCodes]
        # The request parameters of the API generated by registration.
        self.registration_request_parameters = registration_request_parameters  # type: list[GetDataServiceApiResponseBodyDataRegistrationDetailsRegistrationRequestParameters]
        # The format in which the response of the API request is returned. Valid values:
        # 
        # *   0: indicates the JSON format.
        # *   1: indicates the XML format.
        # 
        # APIs generated in wizard or script mode support the JSON format. APIs generated by registration support the JSON and XML formats.
        self.service_content_type = service_content_type  # type: int
        # The address of the backend service.
        self.service_host = service_host  # type: str
        # The path of the backend service.
        self.service_path = service_path  # type: str
        # The description of the request body initiated to call the backend service.
        self.service_request_body_description = service_request_body_description  # type: str
        # Sample success responses
        self.successful_result_sample = successful_result_sample  # type: str

    def validate(self):
        if self.registration_error_codes:
            for k in self.registration_error_codes:
                if k:
                    k.validate()
        if self.registration_request_parameters:
            for k in self.registration_request_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyDataRegistrationDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.failed_result_sample is not None:
            result['FailedResultSample'] = self.failed_result_sample
        result['RegistrationErrorCodes'] = []
        if self.registration_error_codes is not None:
            for k in self.registration_error_codes:
                result['RegistrationErrorCodes'].append(k.to_map() if k else None)
        result['RegistrationRequestParameters'] = []
        if self.registration_request_parameters is not None:
            for k in self.registration_request_parameters:
                result['RegistrationRequestParameters'].append(k.to_map() if k else None)
        if self.service_content_type is not None:
            result['ServiceContentType'] = self.service_content_type
        if self.service_host is not None:
            result['ServiceHost'] = self.service_host
        if self.service_path is not None:
            result['ServicePath'] = self.service_path
        if self.service_request_body_description is not None:
            result['ServiceRequestBodyDescription'] = self.service_request_body_description
        if self.successful_result_sample is not None:
            result['SuccessfulResultSample'] = self.successful_result_sample
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FailedResultSample') is not None:
            self.failed_result_sample = m.get('FailedResultSample')
        self.registration_error_codes = []
        if m.get('RegistrationErrorCodes') is not None:
            for k in m.get('RegistrationErrorCodes'):
                temp_model = GetDataServiceApiResponseBodyDataRegistrationDetailsRegistrationErrorCodes()
                self.registration_error_codes.append(temp_model.from_map(k))
        self.registration_request_parameters = []
        if m.get('RegistrationRequestParameters') is not None:
            for k in m.get('RegistrationRequestParameters'):
                temp_model = GetDataServiceApiResponseBodyDataRegistrationDetailsRegistrationRequestParameters()
                self.registration_request_parameters.append(temp_model.from_map(k))
        if m.get('ServiceContentType') is not None:
            self.service_content_type = m.get('ServiceContentType')
        if m.get('ServiceHost') is not None:
            self.service_host = m.get('ServiceHost')
        if m.get('ServicePath') is not None:
            self.service_path = m.get('ServicePath')
        if m.get('ServiceRequestBodyDescription') is not None:
            self.service_request_body_description = m.get('ServiceRequestBodyDescription')
        if m.get('SuccessfulResultSample') is not None:
            self.successful_result_sample = m.get('SuccessfulResultSample')
        return self


class GetDataServiceApiResponseBodyDataScriptDetailsScriptConnection(TeaModel):
    def __init__(self, connection_id=None, table_name=None):
        # The ID of the data source.
        self.connection_id = connection_id  # type: long
        # The name of the table in the data source.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyDataScriptDetailsScriptConnection, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_id is not None:
            result['ConnectionId'] = self.connection_id
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionId') is not None:
            self.connection_id = m.get('ConnectionId')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetDataServiceApiResponseBodyDataScriptDetailsScriptRequestParameters(TeaModel):
    def __init__(self, column_name=None, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The name of the associated field. This parameter is supported only if the API is generated in wizard mode.
        self.column_name = column_name  # type: str
        # The default value.
        self.default_value = default_value  # type: str
        # The sample value.
        self.example_value = example_value  # type: str
        # Indicates whether the parameter is required.
        self.is_required_parameter = is_required_parameter  # type: bool
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. The value 0 indicates the STRING data type, the value 1 indicates the INT data type, the value 2 indicates the LONG data type, the value 3 indicates the FLOAT data type, the value 4 indicates the DOUBLE data type, and the value 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str
        # The operator used for the value of the parameter. Valid values: 0, 1, 2, and 3. The value 0 indicates that the operator is Equal, the value 1 indicates that the operator is Like, the value 2 indicates that the operator is Const, and the value 3 indicates that the operator is In. APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.parameter_operator = parameter_operator  # type: int
        # The position of the parameter. Valid values: 0, 1, 2, and 3. The value 0 indicates that the parameter is in the URL path of the request, the value 1 indicates that the parameter is in the Query parameter of the request URL, the value 2 indicates that the parameter is in the request header, and the value 3 indicates that the parameter is in the request body. APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyDataScriptDetailsScriptRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class GetDataServiceApiResponseBodyDataScriptDetailsScriptResponseParameters(TeaModel):
    def __init__(self, column_name=None, example_value=None, parameter_data_type=None, parameter_description=None,
                 parameter_name=None):
        # The name of the associated field. This parameter is supported only if the API is generated in wizard mode.
        self.column_name = column_name  # type: str
        # The sample value.
        self.example_value = example_value  # type: str
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. The value 0 indicates the STRING data type, the value 1 indicates the INT data type, the value 2 indicates the LONG data type, the value 3 indicates the FLOAT data type, the value 4 indicates the DOUBLE data type, and the value 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyDataScriptDetailsScriptResponseParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        return self


class GetDataServiceApiResponseBodyDataScriptDetails(TeaModel):
    def __init__(self, is_paged_response=None, script=None, script_connection=None, script_request_parameters=None,
                 script_response_parameters=None):
        # Indicates whether the entries were returned by page.
        self.is_paged_response = is_paged_response  # type: bool
        # The SQL script.
        self.script = script  # type: str
        # The data source information of the API generated in script mode.
        self.script_connection = script_connection  # type: GetDataServiceApiResponseBodyDataScriptDetailsScriptConnection
        # The request parameters of the API generated in script mode.
        self.script_request_parameters = script_request_parameters  # type: list[GetDataServiceApiResponseBodyDataScriptDetailsScriptRequestParameters]
        # The response parameters of the API generated in script mode.
        self.script_response_parameters = script_response_parameters  # type: list[GetDataServiceApiResponseBodyDataScriptDetailsScriptResponseParameters]

    def validate(self):
        if self.script_connection:
            self.script_connection.validate()
        if self.script_request_parameters:
            for k in self.script_request_parameters:
                if k:
                    k.validate()
        if self.script_response_parameters:
            for k in self.script_response_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyDataScriptDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.is_paged_response is not None:
            result['IsPagedResponse'] = self.is_paged_response
        if self.script is not None:
            result['Script'] = self.script
        if self.script_connection is not None:
            result['ScriptConnection'] = self.script_connection.to_map()
        result['ScriptRequestParameters'] = []
        if self.script_request_parameters is not None:
            for k in self.script_request_parameters:
                result['ScriptRequestParameters'].append(k.to_map() if k else None)
        result['ScriptResponseParameters'] = []
        if self.script_response_parameters is not None:
            for k in self.script_response_parameters:
                result['ScriptResponseParameters'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('IsPagedResponse') is not None:
            self.is_paged_response = m.get('IsPagedResponse')
        if m.get('Script') is not None:
            self.script = m.get('Script')
        if m.get('ScriptConnection') is not None:
            temp_model = GetDataServiceApiResponseBodyDataScriptDetailsScriptConnection()
            self.script_connection = temp_model.from_map(m['ScriptConnection'])
        self.script_request_parameters = []
        if m.get('ScriptRequestParameters') is not None:
            for k in m.get('ScriptRequestParameters'):
                temp_model = GetDataServiceApiResponseBodyDataScriptDetailsScriptRequestParameters()
                self.script_request_parameters.append(temp_model.from_map(k))
        self.script_response_parameters = []
        if m.get('ScriptResponseParameters') is not None:
            for k in m.get('ScriptResponseParameters'):
                temp_model = GetDataServiceApiResponseBodyDataScriptDetailsScriptResponseParameters()
                self.script_response_parameters.append(temp_model.from_map(k))
        return self


class GetDataServiceApiResponseBodyDataWizardDetailsWizardConnection(TeaModel):
    def __init__(self, connection_id=None, table_name=None):
        # The ID of the data source.
        self.connection_id = connection_id  # type: long
        # The name of the table in the data source.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyDataWizardDetailsWizardConnection, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_id is not None:
            result['ConnectionId'] = self.connection_id
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionId') is not None:
            self.connection_id = m.get('ConnectionId')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetDataServiceApiResponseBodyDataWizardDetailsWizardRequestParameters(TeaModel):
    def __init__(self, column_name=None, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The name of the associated field. This parameter is supported only if the API is generated in wizard mode.
        self.column_name = column_name  # type: str
        # The default value.
        self.default_value = default_value  # type: str
        # The sample value.
        self.example_value = example_value  # type: str
        # Indicates whether the parameter is required.
        self.is_required_parameter = is_required_parameter  # type: bool
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. The value 0 indicates the STRING data type, the value 1 indicates the INT data type, the value 2 indicates the LONG data type, the value 3 indicates the FLOAT data type, the value 4 indicates the DOUBLE data type, and the value 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str
        # The operator used for the value of the parameter. Valid values: 0, 1, 2, and 3. The value 0 indicates that the operator is Equal, the value 1 indicates that the operator is Like, the value 2 indicates that the operator is Const, and the value 3 indicates that the operator is In. APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.parameter_operator = parameter_operator  # type: int
        # The position of the parameter. Valid values: 0, 1, 2, and 3. The value 0 indicates that the parameter is in the URL path of the request, the value 1 indicates that the parameter is in the Query parameter of the request URL, the value 2 indicates that the parameter is in the request header, and the value 3 indicates that the parameter is in the request body. APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyDataWizardDetailsWizardRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class GetDataServiceApiResponseBodyDataWizardDetailsWizardResponseParameters(TeaModel):
    def __init__(self, column_name=None, example_value=None, parameter_data_type=None, parameter_description=None,
                 parameter_name=None):
        # The name of the associated field. This parameter is supported only if the API is generated in wizard mode.
        self.column_name = column_name  # type: str
        # The sample value.
        self.example_value = example_value  # type: str
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. The value 0 indicates the STRING data type, the value 1 indicates the INT data type, the value 2 indicates the LONG data type, the value 3 indicates the FLOAT data type, the value 4 indicates the DOUBLE data type, and the value 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyDataWizardDetailsWizardResponseParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        return self


class GetDataServiceApiResponseBodyDataWizardDetails(TeaModel):
    def __init__(self, is_paged_response=None, wizard_connection=None, wizard_request_parameters=None,
                 wizard_response_parameters=None):
        # Indicates whether the entries were returned by page.
        self.is_paged_response = is_paged_response  # type: bool
        # The data source information of the API generated in wizard mode.
        self.wizard_connection = wizard_connection  # type: GetDataServiceApiResponseBodyDataWizardDetailsWizardConnection
        # The request parameters of the API generated in wizard mode.
        self.wizard_request_parameters = wizard_request_parameters  # type: list[GetDataServiceApiResponseBodyDataWizardDetailsWizardRequestParameters]
        # The response parameters of the API generated in wizard mode.
        self.wizard_response_parameters = wizard_response_parameters  # type: list[GetDataServiceApiResponseBodyDataWizardDetailsWizardResponseParameters]

    def validate(self):
        if self.wizard_connection:
            self.wizard_connection.validate()
        if self.wizard_request_parameters:
            for k in self.wizard_request_parameters:
                if k:
                    k.validate()
        if self.wizard_response_parameters:
            for k in self.wizard_response_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyDataWizardDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.is_paged_response is not None:
            result['IsPagedResponse'] = self.is_paged_response
        if self.wizard_connection is not None:
            result['WizardConnection'] = self.wizard_connection.to_map()
        result['WizardRequestParameters'] = []
        if self.wizard_request_parameters is not None:
            for k in self.wizard_request_parameters:
                result['WizardRequestParameters'].append(k.to_map() if k else None)
        result['WizardResponseParameters'] = []
        if self.wizard_response_parameters is not None:
            for k in self.wizard_response_parameters:
                result['WizardResponseParameters'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('IsPagedResponse') is not None:
            self.is_paged_response = m.get('IsPagedResponse')
        if m.get('WizardConnection') is not None:
            temp_model = GetDataServiceApiResponseBodyDataWizardDetailsWizardConnection()
            self.wizard_connection = temp_model.from_map(m['WizardConnection'])
        self.wizard_request_parameters = []
        if m.get('WizardRequestParameters') is not None:
            for k in m.get('WizardRequestParameters'):
                temp_model = GetDataServiceApiResponseBodyDataWizardDetailsWizardRequestParameters()
                self.wizard_request_parameters.append(temp_model.from_map(k))
        self.wizard_response_parameters = []
        if m.get('WizardResponseParameters') is not None:
            for k in m.get('WizardResponseParameters'):
                temp_model = GetDataServiceApiResponseBodyDataWizardDetailsWizardResponseParameters()
                self.wizard_response_parameters.append(temp_model.from_map(k))
        return self


class GetDataServiceApiResponseBodyData(TeaModel):
    def __init__(self, api_id=None, api_mode=None, api_name=None, api_path=None, created_time=None, creator_id=None,
                 description=None, folder_id=None, group_id=None, modified_time=None, operator_id=None, project_id=None,
                 protocols=None, registration_details=None, request_method=None, response_content_type=None,
                 script_details=None, status=None, tenant_id=None, timeout=None, visible_range=None, wizard_details=None):
        # The ID of the DataService Studio API.
        self.api_id = api_id  # type: long
        # The type of the API. Valid values: 0, 1, and 2. The value 0 indicates that the API is generated in wizard mode. The value 1 indicates that the API is generated in script mode. The value 2 indicates that the API is generated by registration.
        self.api_mode = api_mode  # type: int
        # The name of the API.
        self.api_name = api_name  # type: str
        # The path of the API.
        self.api_path = api_path  # type: str
        # The creation time.
        self.created_time = created_time  # type: str
        # The ID of the Alibaba Cloud account used by the creator of the API.
        self.creator_id = creator_id  # type: str
        # The description.
        self.description = description  # type: str
        # The ID of the folder.
        self.folder_id = folder_id  # type: long
        # The ID of the group.
        self.group_id = group_id  # type: str
        # The time when the API was last modified.
        self.modified_time = modified_time  # type: str
        # The ID of the Alibaba Cloud account used by the user who last modified the API.
        self.operator_id = operator_id  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The list of fields.
        self.protocols = protocols  # type: list[int]
        # The details of the API generated by registration. This parameter is returned only if the API is generated by registration.
        self.registration_details = registration_details  # type: GetDataServiceApiResponseBodyDataRegistrationDetails
        # The request method of the API. Valid values: 0, 1, 2, and 3. The value 0 indicates the GET method, the value 1 indicates the POST method, the value 2 indicates the PUT method, and the value 3 indicates the DELETE method. APIs generated in wizard or script mode support the GET and POST methods. APIs generated by registration support the GET, POST, PUT, and DELETE methods.
        self.request_method = request_method  # type: int
        # The format in which the response of the API request is returned. Valid values: 0 and 1. The value 0 indicates the JSON format. The value 1 indicates the XML format. APIs generated in wizard or script mode support the JSON format. APIs generated by registration support the JSON and XML formats.
        self.response_content_type = response_content_type  # type: int
        # The details of the API generated in script mode. This parameter is returned only if the API is generated in script mode.
        self.script_details = script_details  # type: GetDataServiceApiResponseBodyDataScriptDetails
        # The status of the API. Valid values: 0 and 1. The value 0 indicates that the API is not published. The value 1 indicates that the API is published.
        self.status = status  # type: int
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long
        # The timeout period of the API request. Unit: milliseconds.
        self.timeout = timeout  # type: int
        # The scope in which the API is visible. Valid values: 0 and 1. The value 0 indicates that the API is visible to the members in a specific workspace. The value 1 indicates that the API is visible only to the API creator.
        self.visible_range = visible_range  # type: int
        # The details of the API generated in wizard mode. This parameter is returned only if the API is generated in wizard mode.
        self.wizard_details = wizard_details  # type: GetDataServiceApiResponseBodyDataWizardDetails

    def validate(self):
        if self.registration_details:
            self.registration_details.validate()
        if self.script_details:
            self.script_details.validate()
        if self.wizard_details:
            self.wizard_details.validate()

    def to_map(self):
        _map = super(GetDataServiceApiResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.api_mode is not None:
            result['ApiMode'] = self.api_mode
        if self.api_name is not None:
            result['ApiName'] = self.api_name
        if self.api_path is not None:
            result['ApiPath'] = self.api_path
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.description is not None:
            result['Description'] = self.description
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.operator_id is not None:
            result['OperatorId'] = self.operator_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.protocols is not None:
            result['Protocols'] = self.protocols
        if self.registration_details is not None:
            result['RegistrationDetails'] = self.registration_details.to_map()
        if self.request_method is not None:
            result['RequestMethod'] = self.request_method
        if self.response_content_type is not None:
            result['ResponseContentType'] = self.response_content_type
        if self.script_details is not None:
            result['ScriptDetails'] = self.script_details.to_map()
        if self.status is not None:
            result['Status'] = self.status
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.timeout is not None:
            result['Timeout'] = self.timeout
        if self.visible_range is not None:
            result['VisibleRange'] = self.visible_range
        if self.wizard_details is not None:
            result['WizardDetails'] = self.wizard_details.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ApiMode') is not None:
            self.api_mode = m.get('ApiMode')
        if m.get('ApiName') is not None:
            self.api_name = m.get('ApiName')
        if m.get('ApiPath') is not None:
            self.api_path = m.get('ApiPath')
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('OperatorId') is not None:
            self.operator_id = m.get('OperatorId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Protocols') is not None:
            self.protocols = m.get('Protocols')
        if m.get('RegistrationDetails') is not None:
            temp_model = GetDataServiceApiResponseBodyDataRegistrationDetails()
            self.registration_details = temp_model.from_map(m['RegistrationDetails'])
        if m.get('RequestMethod') is not None:
            self.request_method = m.get('RequestMethod')
        if m.get('ResponseContentType') is not None:
            self.response_content_type = m.get('ResponseContentType')
        if m.get('ScriptDetails') is not None:
            temp_model = GetDataServiceApiResponseBodyDataScriptDetails()
            self.script_details = temp_model.from_map(m['ScriptDetails'])
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('Timeout') is not None:
            self.timeout = m.get('Timeout')
        if m.get('VisibleRange') is not None:
            self.visible_range = m.get('VisibleRange')
        if m.get('WizardDetails') is not None:
            temp_model = GetDataServiceApiResponseBodyDataWizardDetails()
            self.wizard_details = temp_model.from_map(m['WizardDetails'])
        return self


class GetDataServiceApiResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The data returned.
        self.data = data  # type: GetDataServiceApiResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetDataServiceApiResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetDataServiceApiResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetDataServiceApiResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDataServiceApiResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDataServiceApiResponse, self).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=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 = GetDataServiceApiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDataServiceApiTestRequest(TeaModel):
    def __init__(self, test_id=None):
        self.test_id = test_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApiTestRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.test_id is not None:
            result['TestId'] = self.test_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TestId') is not None:
            self.test_id = m.get('TestId')
        return self


class GetDataServiceApiTestResponseBodyData(TeaModel):
    def __init__(self, api_id=None, cost_time=None, debug_info=None, nodes_debug_info=None, param_map=None,
                 ret_code=None, ret_result=None, status=None):
        self.api_id = api_id  # type: long
        self.cost_time = cost_time  # type: str
        self.debug_info = debug_info  # type: str
        self.nodes_debug_info = nodes_debug_info  # type: str
        self.param_map = param_map  # type: str
        self.ret_code = ret_code  # type: long
        self.ret_result = ret_result  # type: str
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApiTestResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.cost_time is not None:
            result['CostTime'] = self.cost_time
        if self.debug_info is not None:
            result['DebugInfo'] = self.debug_info
        if self.nodes_debug_info is not None:
            result['NodesDebugInfo'] = self.nodes_debug_info
        if self.param_map is not None:
            result['ParamMap'] = self.param_map
        if self.ret_code is not None:
            result['RetCode'] = self.ret_code
        if self.ret_result is not None:
            result['RetResult'] = self.ret_result
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('CostTime') is not None:
            self.cost_time = m.get('CostTime')
        if m.get('DebugInfo') is not None:
            self.debug_info = m.get('DebugInfo')
        if m.get('NodesDebugInfo') is not None:
            self.nodes_debug_info = m.get('NodesDebugInfo')
        if m.get('ParamMap') is not None:
            self.param_map = m.get('ParamMap')
        if m.get('RetCode') is not None:
            self.ret_code = m.get('RetCode')
        if m.get('RetResult') is not None:
            self.ret_result = m.get('RetResult')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetDataServiceApiTestResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None):
        self.data = data  # type: GetDataServiceApiTestResponseBodyData
        self.request_id = request_id  # type: str

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetDataServiceApiTestResponseBody, self).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=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetDataServiceApiTestResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetDataServiceApiTestResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDataServiceApiTestResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDataServiceApiTestResponse, self).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=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 = GetDataServiceApiTestResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDataServiceApplicationRequest(TeaModel):
    def __init__(self, application_id=None, project_id=None, tenant_id=None):
        # The ID of the application. You can view the information about the application in the API Gateway console.
        self.application_id = application_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApplicationRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.application_id is not None:
            result['ApplicationId'] = self.application_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApplicationId') is not None:
            self.application_id = m.get('ApplicationId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class GetDataServiceApplicationResponseBodyData(TeaModel):
    def __init__(self, application_code=None, application_id=None, application_key=None, application_name=None,
                 application_secret=None, project_id=None):
        # The AppCode for simple authentication. You can select simple authentication or signature authentication when you call an API operation.
        self.application_code = application_code  # type: str
        # The ID of the application.
        self.application_id = application_id  # type: long
        # The AppKey for signature authentication. You can select simple authentication or signature authentication when you call an API operation.
        self.application_key = application_key  # type: str
        # The name of the application.
        self.application_name = application_name  # type: str
        # The AppSecret for signature authentication. You can select simple authentication or signature authentication when you call an API operation.
        self.application_secret = application_secret  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceApplicationResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.application_code is not None:
            result['ApplicationCode'] = self.application_code
        if self.application_id is not None:
            result['ApplicationId'] = self.application_id
        if self.application_key is not None:
            result['ApplicationKey'] = self.application_key
        if self.application_name is not None:
            result['ApplicationName'] = self.application_name
        if self.application_secret is not None:
            result['ApplicationSecret'] = self.application_secret
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApplicationCode') is not None:
            self.application_code = m.get('ApplicationCode')
        if m.get('ApplicationId') is not None:
            self.application_id = m.get('ApplicationId')
        if m.get('ApplicationKey') is not None:
            self.application_key = m.get('ApplicationKey')
        if m.get('ApplicationName') is not None:
            self.application_name = m.get('ApplicationName')
        if m.get('ApplicationSecret') is not None:
            self.application_secret = m.get('ApplicationSecret')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetDataServiceApplicationResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The details of the application.
        self.data = data  # type: GetDataServiceApplicationResponseBodyData
        # The error code.
        self.error_code = error_code  # type: str
        # The error message.
        self.error_message = error_message  # type: str
        # The HTTP status code.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetDataServiceApplicationResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetDataServiceApplicationResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetDataServiceApplicationResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDataServiceApplicationResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDataServiceApplicationResponse, self).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=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 = GetDataServiceApplicationResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDataServiceFolderRequest(TeaModel):
    def __init__(self, folder_id=None, project_id=None, tenant_id=None):
        # The ID of the folder.
        self.folder_id = folder_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceFolderRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class GetDataServiceFolderResponseBodyFolder(TeaModel):
    def __init__(self, created_time=None, folder_id=None, folder_name=None, group_id=None, modified_time=None,
                 parent_id=None, project_id=None, tenant_id=None):
        # The time when the folder was created.
        self.created_time = created_time  # type: str
        # The ID of the folder.
        self.folder_id = folder_id  # type: long
        # The name of the folder.
        self.folder_name = folder_name  # type: str
        # The ID of the business process to which the folder belongs.
        self.group_id = group_id  # type: str
        # The time when the folder was last modified.
        self.modified_time = modified_time  # type: str
        # The ID of the parent folder. The ID of the root folder in a business process is 0, and the ID of a folder created by a user in a business process is greater than 0.
        self.parent_id = parent_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceFolderResponseBodyFolder, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.folder_name is not None:
            result['FolderName'] = self.folder_name
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.parent_id is not None:
            result['ParentId'] = self.parent_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('FolderName') is not None:
            self.folder_name = m.get('FolderName')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('ParentId') is not None:
            self.parent_id = m.get('ParentId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class GetDataServiceFolderResponseBody(TeaModel):
    def __init__(self, folder=None, request_id=None):
        # The details of the folder.
        self.folder = folder  # type: GetDataServiceFolderResponseBodyFolder
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.folder:
            self.folder.validate()

    def to_map(self):
        _map = super(GetDataServiceFolderResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder is not None:
            result['Folder'] = self.folder.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Folder') is not None:
            temp_model = GetDataServiceFolderResponseBodyFolder()
            self.folder = temp_model.from_map(m['Folder'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetDataServiceFolderResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDataServiceFolderResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDataServiceFolderResponse, self).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=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 = GetDataServiceFolderResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDataServiceGroupRequest(TeaModel):
    def __init__(self, group_id=None, project_id=None, tenant_id=None):
        # The ID of the business process.
        self.group_id = group_id  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceGroupRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class GetDataServiceGroupResponseBodyGroup(TeaModel):
    def __init__(self, api_gateway_group_id=None, created_time=None, creator_id=None, description=None,
                 group_id=None, group_name=None, modified_time=None, project_id=None, tenant_id=None):
        # The ID of the API group that is associated with the business process in the API Gateway console.
        self.api_gateway_group_id = api_gateway_group_id  # type: str
        # The time when the business process was created.
        self.created_time = created_time  # type: str
        # The user identifier (UID) of the creator of the business process. The value of this parameter may be empty for creators of some existing business processes.
        self.creator_id = creator_id  # type: str
        # The description of the business process.
        self.description = description  # type: str
        # The ID of the business process.
        self.group_id = group_id  # type: str
        # The name of the business process.
        self.group_name = group_name  # type: str
        # The time when the business process was last modified.
        self.modified_time = modified_time  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServiceGroupResponseBodyGroup, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_gateway_group_id is not None:
            result['ApiGatewayGroupId'] = self.api_gateway_group_id
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.description is not None:
            result['Description'] = self.description
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.group_name is not None:
            result['GroupName'] = self.group_name
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiGatewayGroupId') is not None:
            self.api_gateway_group_id = m.get('ApiGatewayGroupId')
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('GroupName') is not None:
            self.group_name = m.get('GroupName')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class GetDataServiceGroupResponseBody(TeaModel):
    def __init__(self, group=None, request_id=None):
        # The details of the business process.
        self.group = group  # type: GetDataServiceGroupResponseBodyGroup
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.group:
            self.group.validate()

    def to_map(self):
        _map = super(GetDataServiceGroupResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.group is not None:
            result['Group'] = self.group.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Group') is not None:
            temp_model = GetDataServiceGroupResponseBodyGroup()
            self.group = temp_model.from_map(m['Group'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetDataServiceGroupResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDataServiceGroupResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDataServiceGroupResponse, self).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=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 = GetDataServiceGroupResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDataServicePublishedApiRequest(TeaModel):
    def __init__(self, api_id=None, project_id=None, tenant_id=None):
        # The ID of the API.
        self.api_id = api_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServicePublishedApiRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class GetDataServicePublishedApiResponseBodyDataRegistrationDetailsRegistrationErrorCodes(TeaModel):
    def __init__(self, error_code=None, error_message=None, error_solution=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The solution used to fix the error.
        self.error_solution = error_solution  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataRegistrationDetailsRegistrationErrorCodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.error_solution is not None:
            result['ErrorSolution'] = self.error_solution
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('ErrorSolution') is not None:
            self.error_solution = m.get('ErrorSolution')
        return self


class GetDataServicePublishedApiResponseBodyDataRegistrationDetailsRegistrationRequestParameters(TeaModel):
    def __init__(self, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The default value.
        self.default_value = default_value  # type: str
        # The sample value.
        self.example_value = example_value  # type: str
        # Indicates whether the parameter is required.
        self.is_required_parameter = is_required_parameter  # type: bool
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. The value 0 indicates the STRING data type, the value 1 indicates the INT data type, the value 2 indicates the LONG data type, the value 3 indicates the FLOAT data type, the value 4 indicates the DOUBLE data type, and the value 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str
        # The operator used for the value of the parameter. Valid values: 0, 1, 2, and 3. The value 0 indicates that the operator is Equal, the value 1 indicates that the operator is Like, the value 2 indicates that the operator is Const, and the value 3 indicates that the operator is In. APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.parameter_operator = parameter_operator  # type: int
        # The position of the parameter. Valid values: 0, 1, 2, and 3. The value 0 indicates that the parameter is in the URL path of the request, the value 1 indicates that the parameter is in the Query parameter of the request URL, the value 2 indicates that the parameter is in the request header, and the value 3 indicates that the parameter is in the request body. APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataRegistrationDetailsRegistrationRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class GetDataServicePublishedApiResponseBodyDataRegistrationDetails(TeaModel):
    def __init__(self, failed_result_sample=None, registration_error_codes=None,
                 registration_request_parameters=None, service_content_type=None, service_host=None, service_path=None,
                 service_request_body_description=None, successful_result_sample=None):
        # The sample error response of the API.
        self.failed_result_sample = failed_result_sample  # type: str
        # The error codes returned for the API generated by registration.
        self.registration_error_codes = registration_error_codes  # type: list[GetDataServicePublishedApiResponseBodyDataRegistrationDetailsRegistrationErrorCodes]
        # The request parameters of the API generated by registration.
        self.registration_request_parameters = registration_request_parameters  # type: list[GetDataServicePublishedApiResponseBodyDataRegistrationDetailsRegistrationRequestParameters]
        # The format in which the response of the API request is returned. Valid values: 0 and 1. The value 0 indicates the JSON format. The value 1 indicates the XML format. APIs generated in wizard or script mode support the JSON format. APIs generated by registration support the JSON and XML formats.
        self.service_content_type = service_content_type  # type: int
        # The address of the backend service.
        self.service_host = service_host  # type: str
        # The path of the backend service.
        self.service_path = service_path  # type: str
        # The description of the request body initiated to call the backend service.
        self.service_request_body_description = service_request_body_description  # type: str
        # The sample success response of the API.
        self.successful_result_sample = successful_result_sample  # type: str

    def validate(self):
        if self.registration_error_codes:
            for k in self.registration_error_codes:
                if k:
                    k.validate()
        if self.registration_request_parameters:
            for k in self.registration_request_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataRegistrationDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.failed_result_sample is not None:
            result['FailedResultSample'] = self.failed_result_sample
        result['RegistrationErrorCodes'] = []
        if self.registration_error_codes is not None:
            for k in self.registration_error_codes:
                result['RegistrationErrorCodes'].append(k.to_map() if k else None)
        result['RegistrationRequestParameters'] = []
        if self.registration_request_parameters is not None:
            for k in self.registration_request_parameters:
                result['RegistrationRequestParameters'].append(k.to_map() if k else None)
        if self.service_content_type is not None:
            result['ServiceContentType'] = self.service_content_type
        if self.service_host is not None:
            result['ServiceHost'] = self.service_host
        if self.service_path is not None:
            result['ServicePath'] = self.service_path
        if self.service_request_body_description is not None:
            result['ServiceRequestBodyDescription'] = self.service_request_body_description
        if self.successful_result_sample is not None:
            result['SuccessfulResultSample'] = self.successful_result_sample
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FailedResultSample') is not None:
            self.failed_result_sample = m.get('FailedResultSample')
        self.registration_error_codes = []
        if m.get('RegistrationErrorCodes') is not None:
            for k in m.get('RegistrationErrorCodes'):
                temp_model = GetDataServicePublishedApiResponseBodyDataRegistrationDetailsRegistrationErrorCodes()
                self.registration_error_codes.append(temp_model.from_map(k))
        self.registration_request_parameters = []
        if m.get('RegistrationRequestParameters') is not None:
            for k in m.get('RegistrationRequestParameters'):
                temp_model = GetDataServicePublishedApiResponseBodyDataRegistrationDetailsRegistrationRequestParameters()
                self.registration_request_parameters.append(temp_model.from_map(k))
        if m.get('ServiceContentType') is not None:
            self.service_content_type = m.get('ServiceContentType')
        if m.get('ServiceHost') is not None:
            self.service_host = m.get('ServiceHost')
        if m.get('ServicePath') is not None:
            self.service_path = m.get('ServicePath')
        if m.get('ServiceRequestBodyDescription') is not None:
            self.service_request_body_description = m.get('ServiceRequestBodyDescription')
        if m.get('SuccessfulResultSample') is not None:
            self.successful_result_sample = m.get('SuccessfulResultSample')
        return self


class GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptConnection(TeaModel):
    def __init__(self, connection_id=None, table_name=None):
        # The ID of the data source.
        self.connection_id = connection_id  # type: long
        # The name of the table in the data source.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptConnection, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_id is not None:
            result['ConnectionId'] = self.connection_id
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionId') is not None:
            self.connection_id = m.get('ConnectionId')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptErrorCodes(TeaModel):
    def __init__(self, error_code=None, error_message=None, error_solution=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The solution used to fix the error.
        self.error_solution = error_solution  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptErrorCodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.error_solution is not None:
            result['ErrorSolution'] = self.error_solution
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('ErrorSolution') is not None:
            self.error_solution = m.get('ErrorSolution')
        return self


class GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptRequestParameters(TeaModel):
    def __init__(self, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The default value.
        self.default_value = default_value  # type: str
        # The sample value.
        self.example_value = example_value  # type: str
        # Indicates whether the parameter is required.
        self.is_required_parameter = is_required_parameter  # type: bool
        # The data type of the parameter. Valid values:
        # 
        # *   0: indicates the STRING data type.
        # *   1: indicates the INT data type.
        # *   2: indicates the LONG data type.
        # *   3: indicates the FLOAT data type.
        # *   4: indicates the DOUBLE data type.
        # *   5: indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str
        # The operator used for the value of the parameter. Valid values:
        # 
        # *   0: indicates that the operator is Equal.
        # *   1: indicates that the operator is Like.
        # *   2: indicates that the operator is Const.
        # *   3: indicates that the operator is In.
        # 
        # APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.parameter_operator = parameter_operator  # type: int
        # The position of the parameter. Valid values:
        # 
        # *   0: indicates that the parameter is in the URL path of the request.
        # *   1: indicates that the parameter is in the Query parameter of the request URL.
        # *   2: indicates that the parameter is in the request header.
        # *   3: indicates that the parameter is in the request body.
        # 
        # APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptResponseParameters(TeaModel):
    def __init__(self, example_value=None, parameter_data_type=None, parameter_description=None,
                 parameter_name=None):
        # The sample value.
        self.example_value = example_value  # type: str
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. The value 0 indicates the STRING data type, the value 1 indicates the INT data type, the value 2 indicates the LONG data type, the value 3 indicates the FLOAT data type, the value 4 indicates the DOUBLE data type, and the value 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptResponseParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        return self


class GetDataServicePublishedApiResponseBodyDataScriptDetails(TeaModel):
    def __init__(self, failed_result_sample=None, is_paged_response=None, script=None, script_connection=None,
                 script_error_codes=None, script_request_parameters=None, script_response_parameters=None,
                 successful_result_sample=None):
        # The sample error response of the API.
        self.failed_result_sample = failed_result_sample  # type: str
        # Indicates whether the entries were returned by page.
        self.is_paged_response = is_paged_response  # type: bool
        # The SQL script.
        self.script = script  # type: str
        # The data source information of the API generated in script mode.
        self.script_connection = script_connection  # type: GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptConnection
        # The error codes returned for the API generated in script mode.
        self.script_error_codes = script_error_codes  # type: list[GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptErrorCodes]
        # The request parameters of the API generated in script mode.
        self.script_request_parameters = script_request_parameters  # type: list[GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptRequestParameters]
        # The response parameters of the API generated in script mode.
        self.script_response_parameters = script_response_parameters  # type: list[GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptResponseParameters]
        # The sample success response of the API.
        self.successful_result_sample = successful_result_sample  # type: str

    def validate(self):
        if self.script_connection:
            self.script_connection.validate()
        if self.script_error_codes:
            for k in self.script_error_codes:
                if k:
                    k.validate()
        if self.script_request_parameters:
            for k in self.script_request_parameters:
                if k:
                    k.validate()
        if self.script_response_parameters:
            for k in self.script_response_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataScriptDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.failed_result_sample is not None:
            result['FailedResultSample'] = self.failed_result_sample
        if self.is_paged_response is not None:
            result['IsPagedResponse'] = self.is_paged_response
        if self.script is not None:
            result['Script'] = self.script
        if self.script_connection is not None:
            result['ScriptConnection'] = self.script_connection.to_map()
        result['ScriptErrorCodes'] = []
        if self.script_error_codes is not None:
            for k in self.script_error_codes:
                result['ScriptErrorCodes'].append(k.to_map() if k else None)
        result['ScriptRequestParameters'] = []
        if self.script_request_parameters is not None:
            for k in self.script_request_parameters:
                result['ScriptRequestParameters'].append(k.to_map() if k else None)
        result['ScriptResponseParameters'] = []
        if self.script_response_parameters is not None:
            for k in self.script_response_parameters:
                result['ScriptResponseParameters'].append(k.to_map() if k else None)
        if self.successful_result_sample is not None:
            result['SuccessfulResultSample'] = self.successful_result_sample
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FailedResultSample') is not None:
            self.failed_result_sample = m.get('FailedResultSample')
        if m.get('IsPagedResponse') is not None:
            self.is_paged_response = m.get('IsPagedResponse')
        if m.get('Script') is not None:
            self.script = m.get('Script')
        if m.get('ScriptConnection') is not None:
            temp_model = GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptConnection()
            self.script_connection = temp_model.from_map(m['ScriptConnection'])
        self.script_error_codes = []
        if m.get('ScriptErrorCodes') is not None:
            for k in m.get('ScriptErrorCodes'):
                temp_model = GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptErrorCodes()
                self.script_error_codes.append(temp_model.from_map(k))
        self.script_request_parameters = []
        if m.get('ScriptRequestParameters') is not None:
            for k in m.get('ScriptRequestParameters'):
                temp_model = GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptRequestParameters()
                self.script_request_parameters.append(temp_model.from_map(k))
        self.script_response_parameters = []
        if m.get('ScriptResponseParameters') is not None:
            for k in m.get('ScriptResponseParameters'):
                temp_model = GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptResponseParameters()
                self.script_response_parameters.append(temp_model.from_map(k))
        if m.get('SuccessfulResultSample') is not None:
            self.successful_result_sample = m.get('SuccessfulResultSample')
        return self


class GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardConnection(TeaModel):
    def __init__(self, connection_id=None, table_name=None):
        # The ID of the data source.
        self.connection_id = connection_id  # type: long
        # The name of the table in the data source.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardConnection, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_id is not None:
            result['ConnectionId'] = self.connection_id
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionId') is not None:
            self.connection_id = m.get('ConnectionId')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardErrorCodes(TeaModel):
    def __init__(self, error_code=None, error_message=None, error_solution=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The solution used to fix the error.
        self.error_solution = error_solution  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardErrorCodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.error_solution is not None:
            result['ErrorSolution'] = self.error_solution
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('ErrorSolution') is not None:
            self.error_solution = m.get('ErrorSolution')
        return self


class GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardRequestParameters(TeaModel):
    def __init__(self, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The default value.
        self.default_value = default_value  # type: str
        # The sample value.
        self.example_value = example_value  # type: str
        # Indicates whether the parameter is required.
        self.is_required_parameter = is_required_parameter  # type: bool
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. The value 0 indicates the STRING data type, the value 1 indicates the INT data type, the value 2 indicates the LONG data type, the value 3 indicates the FLOAT data type, the value 4 indicates the DOUBLE data type, and the value 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str
        # The operator used for the value of the parameter. Valid values: 0, 1, 2, and 3. The value 0 indicates that the operator is Equal, the value 1 indicates that the operator is Like, the value 2 indicates that the operator is Const, and the value 3 indicates that the operator is In. APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.parameter_operator = parameter_operator  # type: int
        # The position of the parameter. Valid values: 0, 1, 2, and 3. The value 0 indicates that the parameter is in the URL path of the request, the value 1 indicates that the parameter is in the Query parameter of the request URL, the value 2 indicates that the parameter is in the request header, and the value 3 indicates that the parameter is in the request body. APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardResponseParameters(TeaModel):
    def __init__(self, example_value=None, parameter_data_type=None, parameter_description=None,
                 parameter_name=None):
        # The sample value.
        self.example_value = example_value  # type: str
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. The value 0 indicates the STRING data type, the value 1 indicates the INT data type, the value 2 indicates the LONG data type, the value 3 indicates the FLOAT data type, the value 4 indicates the DOUBLE data type, and the value 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardResponseParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        return self


class GetDataServicePublishedApiResponseBodyDataWizardDetails(TeaModel):
    def __init__(self, failed_result_sample=None, is_paged_response=None, successful_result_sample=None,
                 wizard_connection=None, wizard_error_codes=None, wizard_request_parameters=None, wizard_response_parameters=None):
        # The sample error response of the API.
        self.failed_result_sample = failed_result_sample  # type: str
        # Indicates whether the entries were returned by page.
        self.is_paged_response = is_paged_response  # type: bool
        # The sample success response of the API.
        self.successful_result_sample = successful_result_sample  # type: str
        # The data source information of the API generated in wizard mode.
        self.wizard_connection = wizard_connection  # type: GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardConnection
        # The error codes returned for the API generated in wizard mode.
        self.wizard_error_codes = wizard_error_codes  # type: list[GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardErrorCodes]
        # The request parameters of the API generated in wizard mode.
        self.wizard_request_parameters = wizard_request_parameters  # type: list[GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardRequestParameters]
        # The response parameters of the API generated in wizard mode.
        self.wizard_response_parameters = wizard_response_parameters  # type: list[GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardResponseParameters]

    def validate(self):
        if self.wizard_connection:
            self.wizard_connection.validate()
        if self.wizard_error_codes:
            for k in self.wizard_error_codes:
                if k:
                    k.validate()
        if self.wizard_request_parameters:
            for k in self.wizard_request_parameters:
                if k:
                    k.validate()
        if self.wizard_response_parameters:
            for k in self.wizard_response_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyDataWizardDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.failed_result_sample is not None:
            result['FailedResultSample'] = self.failed_result_sample
        if self.is_paged_response is not None:
            result['IsPagedResponse'] = self.is_paged_response
        if self.successful_result_sample is not None:
            result['SuccessfulResultSample'] = self.successful_result_sample
        if self.wizard_connection is not None:
            result['WizardConnection'] = self.wizard_connection.to_map()
        result['WizardErrorCodes'] = []
        if self.wizard_error_codes is not None:
            for k in self.wizard_error_codes:
                result['WizardErrorCodes'].append(k.to_map() if k else None)
        result['WizardRequestParameters'] = []
        if self.wizard_request_parameters is not None:
            for k in self.wizard_request_parameters:
                result['WizardRequestParameters'].append(k.to_map() if k else None)
        result['WizardResponseParameters'] = []
        if self.wizard_response_parameters is not None:
            for k in self.wizard_response_parameters:
                result['WizardResponseParameters'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FailedResultSample') is not None:
            self.failed_result_sample = m.get('FailedResultSample')
        if m.get('IsPagedResponse') is not None:
            self.is_paged_response = m.get('IsPagedResponse')
        if m.get('SuccessfulResultSample') is not None:
            self.successful_result_sample = m.get('SuccessfulResultSample')
        if m.get('WizardConnection') is not None:
            temp_model = GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardConnection()
            self.wizard_connection = temp_model.from_map(m['WizardConnection'])
        self.wizard_error_codes = []
        if m.get('WizardErrorCodes') is not None:
            for k in m.get('WizardErrorCodes'):
                temp_model = GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardErrorCodes()
                self.wizard_error_codes.append(temp_model.from_map(k))
        self.wizard_request_parameters = []
        if m.get('WizardRequestParameters') is not None:
            for k in m.get('WizardRequestParameters'):
                temp_model = GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardRequestParameters()
                self.wizard_request_parameters.append(temp_model.from_map(k))
        self.wizard_response_parameters = []
        if m.get('WizardResponseParameters') is not None:
            for k in m.get('WizardResponseParameters'):
                temp_model = GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardResponseParameters()
                self.wizard_response_parameters.append(temp_model.from_map(k))
        return self


class GetDataServicePublishedApiResponseBodyData(TeaModel):
    def __init__(self, api_id=None, api_mode=None, api_name=None, api_path=None, created_time=None, creator_id=None,
                 description=None, group_id=None, modified_time=None, operator_id=None, project_id=None, protocols=None,
                 registration_details=None, request_method=None, response_content_type=None, script_details=None, status=None,
                 tenant_id=None, timeout=None, visible_range=None, wizard_details=None):
        # The ID of the DataService Studio API.
        self.api_id = api_id  # type: long
        # The type of the API. Valid values: 0, 1, and 2. The value 0 indicates that the API is generated in wizard mode. The value 1 indicates that the API is generated in script mode. The value 2 indicates that the API is generated by registration.
        self.api_mode = api_mode  # type: int
        # The name of the API.
        self.api_name = api_name  # type: str
        # The path of the API.
        self.api_path = api_path  # type: str
        # The creation time.
        self.created_time = created_time  # type: str
        # The ID of the Alibaba Cloud account used by the creator of the API.
        self.creator_id = creator_id  # type: str
        # The description.
        self.description = description  # type: str
        # The ID of the group.
        self.group_id = group_id  # type: str
        # The time when the API was last modified.
        self.modified_time = modified_time  # type: str
        # The ID of the Alibaba Cloud account used by the user who last modified the API.
        self.operator_id = operator_id  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The list of fields.
        self.protocols = protocols  # type: list[int]
        # The details of the API generated by registration. This parameter is returned only if the API is generated by registration.
        self.registration_details = registration_details  # type: GetDataServicePublishedApiResponseBodyDataRegistrationDetails
        # The request method of the API. Valid values: 0, 1, 2, and 3. The value 0 indicates the GET method, the value 1 indicates the POST method, the value 2 indicates the PUT method, and the value 3 indicates the DELETE method. APIs generated in wizard or script mode support the GET and POST methods. APIs generated by registration support the GET, POST, PUT, and DELETE methods.
        self.request_method = request_method  # type: int
        # The format in which the response of the API request is returned. Valid values: 0 and 1. The value 0 indicates the JSON format. The value 1 indicates the XML format. APIs generated in wizard or script mode support the JSON format. APIs generated by registration support the JSON and XML formats.
        self.response_content_type = response_content_type  # type: int
        # The details of the API generated in script mode. This parameter is returned only if the API is generated in script mode.
        self.script_details = script_details  # type: GetDataServicePublishedApiResponseBodyDataScriptDetails
        # The status of the API. Valid values: 0 and 1. The value 0 indicates that the API is not published. The value 1 indicates that the API is published.
        self.status = status  # type: int
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long
        # The timeout period of the API request. Unit: milliseconds.
        self.timeout = timeout  # type: int
        # The scope in which the API is visible. Valid values: 0 and 1. The value 0 indicates that the API is visible to the members in a specific workspace. The value 1 indicates that the API is visible only to the API creator.
        self.visible_range = visible_range  # type: int
        # The details of the API generated in wizard mode. This parameter is returned only if the API is generated in wizard mode.
        self.wizard_details = wizard_details  # type: GetDataServicePublishedApiResponseBodyDataWizardDetails

    def validate(self):
        if self.registration_details:
            self.registration_details.validate()
        if self.script_details:
            self.script_details.validate()
        if self.wizard_details:
            self.wizard_details.validate()

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.api_mode is not None:
            result['ApiMode'] = self.api_mode
        if self.api_name is not None:
            result['ApiName'] = self.api_name
        if self.api_path is not None:
            result['ApiPath'] = self.api_path
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.description is not None:
            result['Description'] = self.description
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.operator_id is not None:
            result['OperatorId'] = self.operator_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.protocols is not None:
            result['Protocols'] = self.protocols
        if self.registration_details is not None:
            result['RegistrationDetails'] = self.registration_details.to_map()
        if self.request_method is not None:
            result['RequestMethod'] = self.request_method
        if self.response_content_type is not None:
            result['ResponseContentType'] = self.response_content_type
        if self.script_details is not None:
            result['ScriptDetails'] = self.script_details.to_map()
        if self.status is not None:
            result['Status'] = self.status
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.timeout is not None:
            result['Timeout'] = self.timeout
        if self.visible_range is not None:
            result['VisibleRange'] = self.visible_range
        if self.wizard_details is not None:
            result['WizardDetails'] = self.wizard_details.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ApiMode') is not None:
            self.api_mode = m.get('ApiMode')
        if m.get('ApiName') is not None:
            self.api_name = m.get('ApiName')
        if m.get('ApiPath') is not None:
            self.api_path = m.get('ApiPath')
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('OperatorId') is not None:
            self.operator_id = m.get('OperatorId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Protocols') is not None:
            self.protocols = m.get('Protocols')
        if m.get('RegistrationDetails') is not None:
            temp_model = GetDataServicePublishedApiResponseBodyDataRegistrationDetails()
            self.registration_details = temp_model.from_map(m['RegistrationDetails'])
        if m.get('RequestMethod') is not None:
            self.request_method = m.get('RequestMethod')
        if m.get('ResponseContentType') is not None:
            self.response_content_type = m.get('ResponseContentType')
        if m.get('ScriptDetails') is not None:
            temp_model = GetDataServicePublishedApiResponseBodyDataScriptDetails()
            self.script_details = temp_model.from_map(m['ScriptDetails'])
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('Timeout') is not None:
            self.timeout = m.get('Timeout')
        if m.get('VisibleRange') is not None:
            self.visible_range = m.get('VisibleRange')
        if m.get('WizardDetails') is not None:
            temp_model = GetDataServicePublishedApiResponseBodyDataWizardDetails()
            self.wizard_details = temp_model.from_map(m['WizardDetails'])
        return self


class GetDataServicePublishedApiResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The latest information of the API in the published state.
        self.data = data  # type: GetDataServicePublishedApiResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetDataServicePublishedApiResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetDataServicePublishedApiResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDataServicePublishedApiResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDataServicePublishedApiResponse, self).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=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 = GetDataServicePublishedApiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDataSourceMetaRequest(TeaModel):
    def __init__(self, datasource_name=None, env_type=None, page_number=None, page_size=None, project_id=None):
        # The number of the page to return.
        self.datasource_name = datasource_name  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.env_type = env_type  # type: str
        # The number of entries to return on each page.
        self.page_number = page_number  # type: long
        # The environment to which the data source belongs. Valid values:
        # 
        # *   0: development environment
        # *   1: production environment
        self.page_size = page_size  # type: long
        # The name of the data source.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataSourceMetaRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.datasource_name is not None:
            result['DatasourceName'] = self.datasource_name
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DatasourceName') is not None:
            self.datasource_name = m.get('DatasourceName')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetDataSourceMetaResponseBodyData(TeaModel):
    def __init__(self, message=None, meta=None, status=None):
        # The returned metadata of the data source. The returned metadata is in the JSON format.
        # 
        # `{"dbTables":[{"dbName":"testdb","schema":[{"tableInfos":[{"dbName":"testdb","enable":true,"table":"table1","tableName":"table1"}]},{"tableInfos":[{"dbName":"testdb","enable":true,"table":"table2","tableName":"table2"}]}]}]}`
        # 
        # Parameter description:
        # 
        # *   dbName: the name of the database in which the data source resides.
        # *   schema: the schema of the database.
        # *   enable: indicates whether the database is available. A value of true indicates that the database is available. A value of false indicates that the database is unavailable.
        # *   tableName: the name of the table in the database.
        # *   tableInfos: the information about the table in the database.
        self.message = message  # type: str
        self.meta = meta  # type: str
        # The reason why the metadata of the data source failed to be retrieved. If the metadata of the data source was retrieved, this parameter is left empty.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDataSourceMetaResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.meta is not None:
            result['Meta'] = self.meta
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Meta') is not None:
            self.meta = m.get('Meta')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetDataSourceMetaResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # Indicates whether the metadata of the data source was retrieved. Valid values:
        # 
        # *   success: The metadata of the data source was retrieved.
        # *   fail: The metadata of the data source failed to be retrieved. You can troubleshoot issues based on the Message parameter.
        self.data = data  # type: GetDataSourceMetaResponseBodyData
        # The information about the query operation.
        self.request_id = request_id  # type: str
        # The unique ID of the request. You can query logs and troubleshoot issues based on the unique ID.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetDataSourceMetaResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetDataSourceMetaResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetDataSourceMetaResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDataSourceMetaResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDataSourceMetaResponse, self).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=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 = GetDataSourceMetaResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDeploymentRequest(TeaModel):
    def __init__(self, deployment_id=None, project_id=None, project_identifier=None):
        # The ID of the deployment task. A deployment task ID is generated when you call the [SubmitFile](~~173944~~) or [DeployFile](~~173956~~) operation.
        self.deployment_id = deployment_id  # type: long
        # The ID of the DataWorks workspace. You can click the Workspace Manage icon in the upper-right corner of the DataStudio page to go to the Workspace Management page and view the workspace ID.
        self.project_id = project_id  # type: long
        # The GUID of the DataWorks workspace. You can view the GUID in the upper part of the DataStudio page. You can also select another GUID to switch to another workspace.
        # 
        # You must specify either this parameter or the ProjectId parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDeploymentRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.deployment_id is not None:
            result['DeploymentId'] = self.deployment_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DeploymentId') is not None:
            self.deployment_id = m.get('DeploymentId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class GetDeploymentResponseBodyDataDeployedItems(TeaModel):
    def __init__(self, file_id=None, file_version=None, status=None):
        self.file_id = file_id  # type: long
        self.file_version = file_version  # type: long
        self.status = status  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDeploymentResponseBodyDataDeployedItems, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.file_version is not None:
            result['FileVersion'] = self.file_version
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('FileVersion') is not None:
            self.file_version = m.get('FileVersion')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetDeploymentResponseBodyDataDeployment(TeaModel):
    def __init__(self, checking_status=None, create_time=None, creator_id=None, error_message=None,
                 execute_time=None, from_environment=None, handler_id=None, name=None, status=None, to_environment=None):
        # The check status of one or more files in the deployment task. If the value of the ToEnvironment parameter is 1, the files can be deployed to the production environment only when the value of the Status parameter is 1 and the CheckingStatus parameter is empty. Valid values:
        # 
        # *   7: The file failed the check.
        # *   8: The file is being checked.
        self.checking_status = checking_status  # type: int
        # The time when the deployment task was created. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.create_time = create_time  # type: long
        # The ID of the Alibaba Cloud account used by the user who created the deployment task.
        self.creator_id = creator_id  # type: str
        # The error message that was returned when the deployment task failed. In this case, the value of the Status parameter is 2.
        self.error_message = error_message  # type: str
        # The time when the deployment task was run. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.execute_time = execute_time  # type: long
        # The environment in which the deployment task was run. Valid values: 0 and 1. A value of 0 indicates the on-premises environment. A value of 1 indicates the development environment.
        self.from_environment = from_environment  # type: int
        # The ID of the Alibaba Cloud account used by the user who ran the deployment task.
        self.handler_id = handler_id  # type: str
        # The name of the deployment task. The value is the same as the name of the specific deployment task that is displayed on the Release Package page in the Deploy module.
        self.name = name  # type: str
        # The status of the deployment task. Valid values: 0, 1, and 2. A value of 0 indicates that the task is ready. A value of 1 indicates that the task was successful. A value of 2 indicates that the task failed.
        self.status = status  # type: int
        # The environment to which the file was deployed. Valid values: 1 and 2. A value of 1 indicates the development environment. A value of 2 indicates the production environment.
        self.to_environment = to_environment  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetDeploymentResponseBodyDataDeployment, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.checking_status is not None:
            result['CheckingStatus'] = self.checking_status
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.execute_time is not None:
            result['ExecuteTime'] = self.execute_time
        if self.from_environment is not None:
            result['FromEnvironment'] = self.from_environment
        if self.handler_id is not None:
            result['HandlerId'] = self.handler_id
        if self.name is not None:
            result['Name'] = self.name
        if self.status is not None:
            result['Status'] = self.status
        if self.to_environment is not None:
            result['ToEnvironment'] = self.to_environment
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CheckingStatus') is not None:
            self.checking_status = m.get('CheckingStatus')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('ExecuteTime') is not None:
            self.execute_time = m.get('ExecuteTime')
        if m.get('FromEnvironment') is not None:
            self.from_environment = m.get('FromEnvironment')
        if m.get('HandlerId') is not None:
            self.handler_id = m.get('HandlerId')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('ToEnvironment') is not None:
            self.to_environment = m.get('ToEnvironment')
        return self


class GetDeploymentResponseBodyData(TeaModel):
    def __init__(self, deployed_items=None, deployment=None):
        self.deployed_items = deployed_items  # type: list[GetDeploymentResponseBodyDataDeployedItems]
        # The details of the deployment task.
        self.deployment = deployment  # type: GetDeploymentResponseBodyDataDeployment

    def validate(self):
        if self.deployed_items:
            for k in self.deployed_items:
                if k:
                    k.validate()
        if self.deployment:
            self.deployment.validate()

    def to_map(self):
        _map = super(GetDeploymentResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DeployedItems'] = []
        if self.deployed_items is not None:
            for k in self.deployed_items:
                result['DeployedItems'].append(k.to_map() if k else None)
        if self.deployment is not None:
            result['Deployment'] = self.deployment.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.deployed_items = []
        if m.get('DeployedItems') is not None:
            for k in m.get('DeployedItems'):
                temp_model = GetDeploymentResponseBodyDataDeployedItems()
                self.deployed_items.append(temp_model.from_map(k))
        if m.get('Deployment') is not None:
            temp_model = GetDeploymentResponseBodyDataDeployment()
            self.deployment = temp_model.from_map(m['Deployment'])
        return self


class GetDeploymentResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The data about the deployment task.
        self.data = data  # type: GetDeploymentResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can troubleshoot errors based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetDeploymentResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetDeploymentResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetDeploymentResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetDeploymentResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetDeploymentResponse, self).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=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 = GetDeploymentResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetExtensionRequest(TeaModel):
    def __init__(self, extension_code=None):
        # The unique code of the extension.
        self.extension_code = extension_code  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetExtensionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.extension_code is not None:
            result['ExtensionCode'] = self.extension_code
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ExtensionCode') is not None:
            self.extension_code = m.get('ExtensionCode')
        return self


class GetExtensionResponseBodyExtensionBindEventList(TeaModel):
    def __init__(self, event_code=None, event_name=None):
        # The code of the extension point event.
        self.event_code = event_code  # type: str
        # The name of the extension point event.
        self.event_name = event_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetExtensionResponseBodyExtensionBindEventList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.event_code is not None:
            result['EventCode'] = self.event_code
        if self.event_name is not None:
            result['EventName'] = self.event_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EventCode') is not None:
            self.event_code = m.get('EventCode')
        if m.get('EventName') is not None:
            self.event_name = m.get('EventName')
        return self


class GetExtensionResponseBodyExtensionEventCategoryList(TeaModel):
    def __init__(self, category_code=None, category_name=None):
        # The code of the event type.
        self.category_code = category_code  # type: str
        # The name of the event type.
        self.category_name = category_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetExtensionResponseBodyExtensionEventCategoryList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.category_code is not None:
            result['CategoryCode'] = self.category_code
        if self.category_name is not None:
            result['CategoryName'] = self.category_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CategoryCode') is not None:
            self.category_code = m.get('CategoryCode')
        if m.get('CategoryName') is not None:
            self.category_name = m.get('CategoryName')
        return self


class GetExtensionResponseBodyExtension(TeaModel):
    def __init__(self, bind_event_list=None, detail_url=None, event_category_list=None, extension_code=None,
                 extension_desc=None, extension_name=None, help_doc_url=None, option_setting=None, parameter_setting=None,
                 project_testing=None, status=None):
        # The extension point events.
        self.bind_event_list = bind_event_list  # type: list[GetExtensionResponseBodyExtensionBindEventList]
        # The URL of the help document about the extension. You can visit the URL for the details of the extension.
        self.detail_url = detail_url  # type: str
        # The types of the events.
        self.event_category_list = event_category_list  # type: list[GetExtensionResponseBodyExtensionEventCategoryList]
        # The unique code of the extension.
        self.extension_code = extension_code  # type: str
        # The description of the extension.
        self.extension_desc = extension_desc  # type: str
        # The name of the extension.
        self.extension_name = extension_name  # type: str
        # The URL of the help document about the extension.
        self.help_doc_url = help_doc_url  # type: str
        # The option settings of the extension.
        self.option_setting = option_setting  # type: str
        # The parameter settings of the extension. For more information, visit https://www.alibabacloud.com/help/en/dataworks/latest/set-extension-parameters.
        self.parameter_setting = parameter_setting  # type: str
        # The workspace for testing. If the extension is in the testing state, the extension can be used only in the workspace for testing.
        self.project_testing = project_testing  # type: long
        # The state of the extension. 0: testing. 1: publishing. 3: disabled. 4: approving. 5: approved. 6: approval failed.
        self.status = status  # type: int

    def validate(self):
        if self.bind_event_list:
            for k in self.bind_event_list:
                if k:
                    k.validate()
        if self.event_category_list:
            for k in self.event_category_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetExtensionResponseBodyExtension, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['BindEventList'] = []
        if self.bind_event_list is not None:
            for k in self.bind_event_list:
                result['BindEventList'].append(k.to_map() if k else None)
        if self.detail_url is not None:
            result['DetailUrl'] = self.detail_url
        result['EventCategoryList'] = []
        if self.event_category_list is not None:
            for k in self.event_category_list:
                result['EventCategoryList'].append(k.to_map() if k else None)
        if self.extension_code is not None:
            result['ExtensionCode'] = self.extension_code
        if self.extension_desc is not None:
            result['ExtensionDesc'] = self.extension_desc
        if self.extension_name is not None:
            result['ExtensionName'] = self.extension_name
        if self.help_doc_url is not None:
            result['HelpDocUrl'] = self.help_doc_url
        if self.option_setting is not None:
            result['OptionSetting'] = self.option_setting
        if self.parameter_setting is not None:
            result['ParameterSetting'] = self.parameter_setting
        if self.project_testing is not None:
            result['ProjectTesting'] = self.project_testing
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.bind_event_list = []
        if m.get('BindEventList') is not None:
            for k in m.get('BindEventList'):
                temp_model = GetExtensionResponseBodyExtensionBindEventList()
                self.bind_event_list.append(temp_model.from_map(k))
        if m.get('DetailUrl') is not None:
            self.detail_url = m.get('DetailUrl')
        self.event_category_list = []
        if m.get('EventCategoryList') is not None:
            for k in m.get('EventCategoryList'):
                temp_model = GetExtensionResponseBodyExtensionEventCategoryList()
                self.event_category_list.append(temp_model.from_map(k))
        if m.get('ExtensionCode') is not None:
            self.extension_code = m.get('ExtensionCode')
        if m.get('ExtensionDesc') is not None:
            self.extension_desc = m.get('ExtensionDesc')
        if m.get('ExtensionName') is not None:
            self.extension_name = m.get('ExtensionName')
        if m.get('HelpDocUrl') is not None:
            self.help_doc_url = m.get('HelpDocUrl')
        if m.get('OptionSetting') is not None:
            self.option_setting = m.get('OptionSetting')
        if m.get('ParameterSetting') is not None:
            self.parameter_setting = m.get('ParameterSetting')
        if m.get('ProjectTesting') is not None:
            self.project_testing = m.get('ProjectTesting')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetExtensionResponseBody(TeaModel):
    def __init__(self, extension=None, request_id=None):
        # The details of the extension.
        self.extension = extension  # type: GetExtensionResponseBodyExtension
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.extension:
            self.extension.validate()

    def to_map(self):
        _map = super(GetExtensionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.extension is not None:
            result['Extension'] = self.extension.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Extension') is not None:
            temp_model = GetExtensionResponseBodyExtension()
            self.extension = temp_model.from_map(m['Extension'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetExtensionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetExtensionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetExtensionResponse, self).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=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 = GetExtensionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetFileRequest(TeaModel):
    def __init__(self, file_id=None, node_id=None, project_id=None, project_identifier=None):
        # The ID of the file. You can call the [ListFiles](~~173942~~) operation to obtain the ID.
        self.file_id = file_id  # type: long
        # The ID of the node that is scheduled. You can call the [ListFiles](~~173942~~) operation to obtain the node ID.
        self.node_id = node_id  # type: long
        # The ID of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace ID.
        # 
        # You must configure this parameter or the ProjectIdentifier parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace name.
        # 
        # You must configure this parameter or the ProjectId parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFileRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class GetFileResponseBodyDataFile(TeaModel):
    def __init__(self, advanced_settings=None, auto_parsing=None, biz_id=None, business_id=None, commit_status=None,
                 connection_name=None, content=None, create_time=None, create_user=None, current_version=None, deleted_status=None,
                 file_description=None, file_folder_id=None, file_id=None, file_name=None, file_type=None, is_max_compute=None,
                 last_edit_time=None, last_edit_user=None, node_id=None, owner=None, parent_id=None, use_type=None):
        # The advanced configurations of the node.
        # 
        # This parameter is valid only for an EMR Spark Streaming node or an EMR Streaming SQL node. This parameter corresponds to the Advanced Settings tab of the node in the [DataWorks console](https://workbench.data.aliyun.com/console).
        # 
        # This parameter is configured in the JSON format.
        self.advanced_settings = advanced_settings  # type: str
        # Indicates whether the automatic parsing feature is enabled for the file. Valid values:
        # 
        # *   true: The automatic parsing feature is enabled for the file.
        # *   false: The automatic parsing feature is not enabled for the file.
        # 
        # This parameter corresponds to the Analyze Code parameter that is displayed after Same Cycle is selected in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.auto_parsing = auto_parsing  # type: bool
        # The ID of the workflow to which the file belongs. This parameter is deprecated and replaced by the BusinessId parameter.
        self.biz_id = biz_id  # type: long
        # The ID of the workflow to which the file belongs.
        self.business_id = business_id  # type: long
        # Indicates whether the latest code in the file is committed. Valid values: 0 and 1. The value 0 indicates that the latest code in the file is not committed. The value 1 indicates that the latest code in the file is committed.
        self.commit_status = commit_status  # type: int
        # The ID of the compute engine instance that is used to run the node that corresponds to the file.
        self.connection_name = connection_name  # type: str
        # The code in the file.
        self.content = content  # type: str
        # The time when the file was created. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.create_time = create_time  # type: long
        # The ID of the Alibaba Cloud account used to create the file.
        self.create_user = create_user  # type: str
        # The latest version number of the file.
        self.current_version = current_version  # type: int
        # The status of the file. Valid values:
        # 
        # *   NORMAL: The file is not deleted.
        # *   RECYCLE_BIN: The file is stored in the recycle bin.
        # *   DELETED: The file is deleted.
        self.deleted_status = deleted_status  # type: str
        # The description of the file.
        self.file_description = file_description  # type: str
        # The ID of the folder to which the file belongs.
        self.file_folder_id = file_folder_id  # type: str
        self.file_id = file_id  # type: long
        # The name of the file.
        self.file_name = file_name  # type: str
        # The type of the code for the file. Valid values: 6 (Shell), 10 (ODPS SQL), 11 (ODPS MR), 23 (Data Integration), 24 (ODPS Script), 99 (zero load), 221 (PyODPS 2), 225 (ODPS Spark), 227 (EMR Hive), 228 (EMR Spark), 229 (EMR Spark SQL), 230 (EMR MR), 239 (OSS object inspection), 257 (EMR Shell), 258 (EMR Spark Shell), 259 (EMR Presto), 260 (EMR Impala), 900 (real-time synchronization), 1089 (cross-tenant collaboration), 1091 (Hologres development), 1093 (Hologres SQL), 1100 (assignment), and 1221 (PyODPS 3).
        self.file_type = file_type  # type: int
        # Indicates whether the file needs to be uploaded to MaxCompute.
        # 
        # This parameter is returned only if the file is a MaxCompute resource file.
        self.is_max_compute = is_max_compute  # type: bool
        # The time when the file was last modified. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.last_edit_time = last_edit_time  # type: long
        # The ID of the Alibaba Cloud account used to last modify the file.
        self.last_edit_user = last_edit_user  # type: str
        # The ID of the auto triggered node that is generated in the scheduling system after the file is committed.
        self.node_id = node_id  # type: long
        # The ID of the Alibaba Cloud account used by the file owner.
        self.owner = owner  # type: str
        # The ID of the node group file to which the current file belongs. This parameter is returned only if the current file is an inner file of the node group file.
        self.parent_id = parent_id  # type: long
        # The module to which the file belongs. Valid values:
        # 
        # *   NORMAL: The file is used for DataStudio.
        # *   MANUAL: The file is used for a manually triggered node.
        # *   MANUAL_BIZ: The file is used for a manually triggered workflow.
        # *   SKIP: The file is used for a dry-run DataStudio node.
        # *   ADHOCQUERY: The file is used for an ad hoc query.
        # *   COMPONENT: The file is used for a snippet.
        self.use_type = use_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFileResponseBodyDataFile, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.advanced_settings is not None:
            result['AdvancedSettings'] = self.advanced_settings
        if self.auto_parsing is not None:
            result['AutoParsing'] = self.auto_parsing
        if self.biz_id is not None:
            result['BizId'] = self.biz_id
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.commit_status is not None:
            result['CommitStatus'] = self.commit_status
        if self.connection_name is not None:
            result['ConnectionName'] = self.connection_name
        if self.content is not None:
            result['Content'] = self.content
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.create_user is not None:
            result['CreateUser'] = self.create_user
        if self.current_version is not None:
            result['CurrentVersion'] = self.current_version
        if self.deleted_status is not None:
            result['DeletedStatus'] = self.deleted_status
        if self.file_description is not None:
            result['FileDescription'] = self.file_description
        if self.file_folder_id is not None:
            result['FileFolderId'] = self.file_folder_id
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.file_name is not None:
            result['FileName'] = self.file_name
        if self.file_type is not None:
            result['FileType'] = self.file_type
        if self.is_max_compute is not None:
            result['IsMaxCompute'] = self.is_max_compute
        if self.last_edit_time is not None:
            result['LastEditTime'] = self.last_edit_time
        if self.last_edit_user is not None:
            result['LastEditUser'] = self.last_edit_user
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.parent_id is not None:
            result['ParentId'] = self.parent_id
        if self.use_type is not None:
            result['UseType'] = self.use_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AdvancedSettings') is not None:
            self.advanced_settings = m.get('AdvancedSettings')
        if m.get('AutoParsing') is not None:
            self.auto_parsing = m.get('AutoParsing')
        if m.get('BizId') is not None:
            self.biz_id = m.get('BizId')
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('CommitStatus') is not None:
            self.commit_status = m.get('CommitStatus')
        if m.get('ConnectionName') is not None:
            self.connection_name = m.get('ConnectionName')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('CreateUser') is not None:
            self.create_user = m.get('CreateUser')
        if m.get('CurrentVersion') is not None:
            self.current_version = m.get('CurrentVersion')
        if m.get('DeletedStatus') is not None:
            self.deleted_status = m.get('DeletedStatus')
        if m.get('FileDescription') is not None:
            self.file_description = m.get('FileDescription')
        if m.get('FileFolderId') is not None:
            self.file_folder_id = m.get('FileFolderId')
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('FileName') is not None:
            self.file_name = m.get('FileName')
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        if m.get('IsMaxCompute') is not None:
            self.is_max_compute = m.get('IsMaxCompute')
        if m.get('LastEditTime') is not None:
            self.last_edit_time = m.get('LastEditTime')
        if m.get('LastEditUser') is not None:
            self.last_edit_user = m.get('LastEditUser')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ParentId') is not None:
            self.parent_id = m.get('ParentId')
        if m.get('UseType') is not None:
            self.use_type = m.get('UseType')
        return self


class GetFileResponseBodyDataNodeConfigurationInputList(TeaModel):
    def __init__(self, input=None, parse_type=None):
        # The output name of the parent file on which the current file depends.
        # 
        # This parameter corresponds to the Output Name parameter under Parent Nodes after Same Cycle is selected in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.input = input  # type: str
        # The mode of the configuration file dependency. Valid values:
        # 
        # *   MANUAL: Scheduling dependencies are manually configured.
        # *   AUTO: Scheduling dependencies are automatically parsed.
        self.parse_type = parse_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFileResponseBodyDataNodeConfigurationInputList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.input is not None:
            result['Input'] = self.input
        if self.parse_type is not None:
            result['ParseType'] = self.parse_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Input') is not None:
            self.input = m.get('Input')
        if m.get('ParseType') is not None:
            self.parse_type = m.get('ParseType')
        return self


class GetFileResponseBodyDataNodeConfigurationInputParameters(TeaModel):
    def __init__(self, parameter_name=None, value_source=None):
        # The name of the input parameter of the node. In the code, you can use the ${...} method to reference the input parameter of the node.
        # 
        # This parameter corresponds to the Parameter Name parameter in the Input Parameters table in the Input and Output Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.parameter_name = parameter_name  # type: str
        # The value source of the input parameter of the node.
        # 
        # This parameter corresponds to the Value Source parameter in the Input Parameters table in the Input and Output Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.value_source = value_source  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFileResponseBodyDataNodeConfigurationInputParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.value_source is not None:
            result['ValueSource'] = self.value_source
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ValueSource') is not None:
            self.value_source = m.get('ValueSource')
        return self


class GetFileResponseBodyDataNodeConfigurationOutputList(TeaModel):
    def __init__(self, output=None, ref_table_name=None):
        # The output name of the current file.
        # 
        # This parameter corresponds to the Output Name parameter under Output after Same Cycle is selected in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.output = output  # type: str
        # The output table name of the current file.
        # 
        # This parameter corresponds to the Output Table Name parameter under Output after Same Cycle is selected in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.ref_table_name = ref_table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFileResponseBodyDataNodeConfigurationOutputList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.output is not None:
            result['Output'] = self.output
        if self.ref_table_name is not None:
            result['RefTableName'] = self.ref_table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Output') is not None:
            self.output = m.get('Output')
        if m.get('RefTableName') is not None:
            self.ref_table_name = m.get('RefTableName')
        return self


class GetFileResponseBodyDataNodeConfigurationOutputParameters(TeaModel):
    def __init__(self, description=None, parameter_name=None, type=None, value=None):
        # The description of the output parameter of the node.
        self.description = description  # type: str
        # The name of the output parameter of the node.
        # 
        # This parameter corresponds to the Parameter Name parameter in the Output Parameters table in the Input and Output Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.parameter_name = parameter_name  # type: str
        # The type of the output parameter of the node. Valid values:
        # 
        # *   1: indicates a constant.
        # *   2: indicates a variable.
        # *   3: indicates a pass-through variable.
        # 
        # This parameter corresponds to the Type parameter in the Output Parameters table in the Input and Output Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.type = type  # type: str
        # The value of the output parameter of the node.
        # 
        # This parameter corresponds to the Value parameter in the Output Parameters table in the Input and Output Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.value = value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFileResponseBodyDataNodeConfigurationOutputParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.type is not None:
            result['Type'] = self.type
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class GetFileResponseBodyDataNodeConfiguration(TeaModel):
    def __init__(self, auto_rerun_interval_millis=None, auto_rerun_times=None, cron_express=None, cycle_type=None,
                 dependent_node_id_list=None, dependent_type=None, end_effect_date=None, input_list=None, input_parameters=None,
                 output_list=None, output_parameters=None, para_value=None, rerun_mode=None, resource_group_id=None,
                 scheduler_type=None, start_effect_date=None, start_immediately=None, stop=None):
        # The interval between automatic reruns after an error occurs. Unit: milliseconds.
        # 
        # This parameter corresponds to the Rerun Interval parameter that is displayed after the Auto Rerun upon Error check box is selected in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        # 
        # The interval that you specify in the DataWorks console is measured in minutes. Pay attention to the conversion between the units of time when you call the operation.
        self.auto_rerun_interval_millis = auto_rerun_interval_millis  # type: int
        # The number of automatic reruns that are allowed after an error occurs.
        self.auto_rerun_times = auto_rerun_times  # type: int
        # The CRON expression that represents the periodic scheduling policy of the node.
        self.cron_express = cron_express  # type: str
        # The type of the scheduling cycle. Valid values: NOT_DAY and DAY. The value NOT_DAY indicates that the node is scheduled to run by minute or hour. The value DAY indicates that the node is scheduled to run by day, week, or month.
        # 
        # This parameter corresponds to the Scheduling Cycle parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.cycle_type = cycle_type  # type: str
        # The ID of the node on which the node corresponding to the file depends when the DependentType parameter is set to USER_DEFINE. Multiple IDs are separated by commas (,).
        # 
        # The value of this parameter is equivalent to the ID of the node that you specified after you select Previous Cycle and set Depend On to Other Nodes in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.dependent_node_id_list = dependent_node_id_list  # type: str
        # The type of the cross-cycle scheduling dependency of the node. Valid values:
        # 
        # *   SELF: The instance generated for the node in the current cycle depends on the instance generated for the node in the previous cycle.
        # *   CHILD: The instance generated for the node in the current cycle depends on the instances generated for the descendant nodes at the nearest level of the node in the previous cycle.
        # *   USER_DEFINE: The instance generated for the node in the current cycle depends on the instances generated for one or more specified nodes in the previous cycle.
        # *   NONE: No cross-cycle scheduling dependency type is selected for the node.
        self.dependent_type = dependent_type  # type: str
        # The end time of automatic scheduling. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        # 
        # This parameter corresponds to the Validity Period parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.end_effect_date = end_effect_date  # type: long
        # The output names of the parent files on which the current file depends.
        self.input_list = input_list  # type: list[GetFileResponseBodyDataNodeConfigurationInputList]
        # Input parameters of the node.
        # 
        # This parameter corresponds to the Input Parameters table in the Input and Output Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.input_parameters = input_parameters  # type: list[GetFileResponseBodyDataNodeConfigurationInputParameters]
        # The output names of the current file.
        # 
        # This parameter corresponds to the Output Name parameter under Output after Same Cycle is selected in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.output_list = output_list  # type: list[GetFileResponseBodyDataNodeConfigurationOutputList]
        # Output parameters of the node.
        # 
        # This parameter corresponds to the Output Parameters table in the Input and Output Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.output_parameters = output_parameters  # type: list[GetFileResponseBodyDataNodeConfigurationOutputParameters]
        # The scheduling parameters of the node.
        # 
        # This parameter corresponds to the Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console). For more information about the configurations of the scheduling parameters, see [Configure scheduling parameters](~~137548~~).
        self.para_value = para_value  # type: str
        # Indicates whether the node that corresponds to the file can be rerun. Valid values:
        # 
        # *   ALL_ALLOWED: The node can be rerun regardless of whether it is successfully run or fails to run.
        # *   FAILURE_ALLOWED: The node can be rerun only after it fails to run.
        # *   ALL_DENIED: The node cannot be rerun regardless of whether it is successfully run or fails to run.
        # 
        # This parameter corresponds to the Rerun parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.rerun_mode = rerun_mode  # type: str
        # The ID of the resource group that is used to run the node. You can call the [ListResourceGroups](~~173913~~) operation to query the available resource groups in the workspace.
        self.resource_group_id = resource_group_id  # type: long
        # The scheduling type of the node. Valid values:
        # 
        # *   NORMAL: The node is an auto triggered node.
        # *   MANUAL: The node is a manually triggered node. Manually triggered nodes cannot be automatically triggered. They correspond to the nodes in the Manually Triggered Workflows pane.
        # *   PAUSE: The node is a paused node.
        # *   SKIP: The node is a dry-run node. Dry-run nodes are started as scheduled but the system sets the status of the nodes to successful when it starts to run them.
        self.scheduler_type = scheduler_type  # type: str
        # The start time of automatic scheduling. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        # 
        # This parameter corresponds to the Validity Period parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.start_effect_date = start_effect_date  # type: long
        # Indicates whether a node is immediately run after the node is deployed to the production environment.
        # 
        # This parameter is valid only for an EMR Spark Streaming node or an EMR Streaming SQL node. This parameter corresponds to the Start Method parameter in the Schedule section of the Configure tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.start_immediately = start_immediately  # type: bool
        # Indicates whether the scheduling for the node is suspended Valid values:
        # 
        # *   true: The scheduling for the node is suspended.
        # *   false: The scheduling for the node is not suspended.
        # 
        # This parameter corresponds to the Recurrence parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.stop = stop  # type: bool

    def validate(self):
        if self.input_list:
            for k in self.input_list:
                if k:
                    k.validate()
        if self.input_parameters:
            for k in self.input_parameters:
                if k:
                    k.validate()
        if self.output_list:
            for k in self.output_list:
                if k:
                    k.validate()
        if self.output_parameters:
            for k in self.output_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetFileResponseBodyDataNodeConfiguration, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.auto_rerun_interval_millis is not None:
            result['AutoRerunIntervalMillis'] = self.auto_rerun_interval_millis
        if self.auto_rerun_times is not None:
            result['AutoRerunTimes'] = self.auto_rerun_times
        if self.cron_express is not None:
            result['CronExpress'] = self.cron_express
        if self.cycle_type is not None:
            result['CycleType'] = self.cycle_type
        if self.dependent_node_id_list is not None:
            result['DependentNodeIdList'] = self.dependent_node_id_list
        if self.dependent_type is not None:
            result['DependentType'] = self.dependent_type
        if self.end_effect_date is not None:
            result['EndEffectDate'] = self.end_effect_date
        result['InputList'] = []
        if self.input_list is not None:
            for k in self.input_list:
                result['InputList'].append(k.to_map() if k else None)
        result['InputParameters'] = []
        if self.input_parameters is not None:
            for k in self.input_parameters:
                result['InputParameters'].append(k.to_map() if k else None)
        result['OutputList'] = []
        if self.output_list is not None:
            for k in self.output_list:
                result['OutputList'].append(k.to_map() if k else None)
        result['OutputParameters'] = []
        if self.output_parameters is not None:
            for k in self.output_parameters:
                result['OutputParameters'].append(k.to_map() if k else None)
        if self.para_value is not None:
            result['ParaValue'] = self.para_value
        if self.rerun_mode is not None:
            result['RerunMode'] = self.rerun_mode
        if self.resource_group_id is not None:
            result['ResourceGroupId'] = self.resource_group_id
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        if self.start_effect_date is not None:
            result['StartEffectDate'] = self.start_effect_date
        if self.start_immediately is not None:
            result['StartImmediately'] = self.start_immediately
        if self.stop is not None:
            result['Stop'] = self.stop
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AutoRerunIntervalMillis') is not None:
            self.auto_rerun_interval_millis = m.get('AutoRerunIntervalMillis')
        if m.get('AutoRerunTimes') is not None:
            self.auto_rerun_times = m.get('AutoRerunTimes')
        if m.get('CronExpress') is not None:
            self.cron_express = m.get('CronExpress')
        if m.get('CycleType') is not None:
            self.cycle_type = m.get('CycleType')
        if m.get('DependentNodeIdList') is not None:
            self.dependent_node_id_list = m.get('DependentNodeIdList')
        if m.get('DependentType') is not None:
            self.dependent_type = m.get('DependentType')
        if m.get('EndEffectDate') is not None:
            self.end_effect_date = m.get('EndEffectDate')
        self.input_list = []
        if m.get('InputList') is not None:
            for k in m.get('InputList'):
                temp_model = GetFileResponseBodyDataNodeConfigurationInputList()
                self.input_list.append(temp_model.from_map(k))
        self.input_parameters = []
        if m.get('InputParameters') is not None:
            for k in m.get('InputParameters'):
                temp_model = GetFileResponseBodyDataNodeConfigurationInputParameters()
                self.input_parameters.append(temp_model.from_map(k))
        self.output_list = []
        if m.get('OutputList') is not None:
            for k in m.get('OutputList'):
                temp_model = GetFileResponseBodyDataNodeConfigurationOutputList()
                self.output_list.append(temp_model.from_map(k))
        self.output_parameters = []
        if m.get('OutputParameters') is not None:
            for k in m.get('OutputParameters'):
                temp_model = GetFileResponseBodyDataNodeConfigurationOutputParameters()
                self.output_parameters.append(temp_model.from_map(k))
        if m.get('ParaValue') is not None:
            self.para_value = m.get('ParaValue')
        if m.get('RerunMode') is not None:
            self.rerun_mode = m.get('RerunMode')
        if m.get('ResourceGroupId') is not None:
            self.resource_group_id = m.get('ResourceGroupId')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        if m.get('StartEffectDate') is not None:
            self.start_effect_date = m.get('StartEffectDate')
        if m.get('StartImmediately') is not None:
            self.start_immediately = m.get('StartImmediately')
        if m.get('Stop') is not None:
            self.stop = m.get('Stop')
        return self


class GetFileResponseBodyData(TeaModel):
    def __init__(self, file=None, node_configuration=None):
        # The basic information about the file.
        self.file = file  # type: GetFileResponseBodyDataFile
        # The scheduling configurations of the file.
        self.node_configuration = node_configuration  # type: GetFileResponseBodyDataNodeConfiguration

    def validate(self):
        if self.file:
            self.file.validate()
        if self.node_configuration:
            self.node_configuration.validate()

    def to_map(self):
        _map = super(GetFileResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file is not None:
            result['File'] = self.file.to_map()
        if self.node_configuration is not None:
            result['NodeConfiguration'] = self.node_configuration.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('File') is not None:
            temp_model = GetFileResponseBodyDataFile()
            self.file = temp_model.from_map(m['File'])
        if m.get('NodeConfiguration') is not None:
            temp_model = GetFileResponseBodyDataNodeConfiguration()
            self.node_configuration = temp_model.from_map(m['NodeConfiguration'])
        return self


class GetFileResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The details of the file.
        self.data = data  # type: GetFileResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetFileResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetFileResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetFileResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetFileResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetFileResponse, self).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=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 = GetFileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetFileTypeStatisticRequest(TeaModel):
    def __init__(self, project_env=None, project_id=None):
        # The environment of the workspace. Valid values: PROD and DEV. The value PROD indicates the production environment. The value DEV indicates the development environment.
        self.project_env = project_env  # type: str
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFileTypeStatisticRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetFileTypeStatisticResponseBodyProgramTypeAndCounts(TeaModel):
    def __init__(self, count=None, program_type=None):
        # The number of nodes.
        self.count = count  # type: int
        # The type of the node.
        # 
        # Valid values:
        # 
        # 6 (Shell node), 10 (ODPS SQL node), 11 (ODPS MR node), 23 (Data Integration node), 24 (ODPS Script node), 99 (zero load node), 221 (PyODPS 2 node), 225 (ODPS Spark node), 227 (EMR Hive node), 228 (EMR Spark node), 229 (EMR Spark SQL node), 230 (EMR MR node), 239 (OSS object inspection node), 257 (EMR Shell node), 258 (EMR Spark Shell node), 259 (EMR Presto node), 260 (EMR Impala node), 900 (real-time data synchronization node), 1089 (cross-tenant collaboration node), 1091 (Hologres development node), 1093 (Hologres SQL node), 1100 (assignment node), and 1221 (PyODPS 3 node).
        self.program_type = program_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFileTypeStatisticResponseBodyProgramTypeAndCounts, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        return self


class GetFileTypeStatisticResponseBody(TeaModel):
    def __init__(self, program_type_and_counts=None, request_id=None):
        # An array of node types and quantity.
        self.program_type_and_counts = program_type_and_counts  # type: list[GetFileTypeStatisticResponseBodyProgramTypeAndCounts]
        # The ID of the request. You can use the ID to locate logs and troubleshoot issues.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.program_type_and_counts:
            for k in self.program_type_and_counts:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetFileTypeStatisticResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ProgramTypeAndCounts'] = []
        if self.program_type_and_counts is not None:
            for k in self.program_type_and_counts:
                result['ProgramTypeAndCounts'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.program_type_and_counts = []
        if m.get('ProgramTypeAndCounts') is not None:
            for k in m.get('ProgramTypeAndCounts'):
                temp_model = GetFileTypeStatisticResponseBodyProgramTypeAndCounts()
                self.program_type_and_counts.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetFileTypeStatisticResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetFileTypeStatisticResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetFileTypeStatisticResponse, self).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=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 = GetFileTypeStatisticResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetFileVersionRequest(TeaModel):
    def __init__(self, file_id=None, file_version=None, project_id=None, project_identifier=None):
        # The ID of the file. You can call the [ListFiles](~~173942~~) operation to query the ID.
        self.file_id = file_id  # type: long
        # The file version whose details you want to query.
        self.file_version = file_version  # type: int
        # The ID of the DataWorks workspace. You can click the Workspace Manage icon in the upper-right corner of the DataStudio page to go to the Workspace Management page and view the workspace ID.
        self.project_id = project_id  # type: long
        # The unique identifier of the DataWorks workspace. You can click the identifier in the upper-left corner of the DataStudio page to switch to another workspace.
        # 
        # You must specify either this parameter or ProjectId to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFileVersionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.file_version is not None:
            result['FileVersion'] = self.file_version
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('FileVersion') is not None:
            self.file_version = m.get('FileVersion')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class GetFileVersionResponseBodyData(TeaModel):
    def __init__(self, change_type=None, comment=None, commit_time=None, commit_user=None, file_content=None,
                 file_name=None, file_property_content=None, file_version=None, is_current_prod=None, node_content=None,
                 node_id=None, status=None, use_type=None):
        # The change type of the file version. Valid values: CREATE, UPDATE, and DELETE.
        self.change_type = change_type  # type: str
        # The description of the file version.
        self.comment = comment  # type: str
        # The time when the version was generated. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.commit_time = commit_time  # type: long
        # The ID of the Alibaba Cloud account that is used to create the file version.
        self.commit_user = commit_user  # type: str
        # The file code.
        self.file_content = file_content  # type: str
        # The file name.
        self.file_name = file_name  # type: str
        # The basic information about the file.
        self.file_property_content = file_property_content  # type: str
        # The file version.
        self.file_version = file_version  # type: int
        # Indicates whether the version is the latest version in the production environment.
        self.is_current_prod = is_current_prod  # type: bool
        # The scheduling configurations of the node that corresponds to the file version.
        self.node_content = node_content  # type: str
        # The ID of the node that corresponds to the file version.
        self.node_id = node_id  # type: long
        # The status of the file version. Valid values: COMMITTING, COMMITTED, CHECK_OK, PACKAGED, DEPLOYING, DEPLOYED, and CANCELLED. The value CHECK_OK is equivalent to the value COMMITTED.
        self.status = status  # type: str
        # The functional module to which the file belongs. Valid values: NORMAL, MANUAL, MANUAL_BIZ, SKIP, ADHOCQUERY, and COMPONENT. The value NORMAL indicates DataStudio. The value MANUAL indicates a manually triggered node. The value MANUAL_BIZ indicates a manually triggered workflow. The value SKIP indicates a dry-run DataStudio node. The value ADHOCQUERY indicates an ad hoc query. The value COMPONENT indicates snippets.
        self.use_type = use_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFileVersionResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.change_type is not None:
            result['ChangeType'] = self.change_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.commit_time is not None:
            result['CommitTime'] = self.commit_time
        if self.commit_user is not None:
            result['CommitUser'] = self.commit_user
        if self.file_content is not None:
            result['FileContent'] = self.file_content
        if self.file_name is not None:
            result['FileName'] = self.file_name
        if self.file_property_content is not None:
            result['FilePropertyContent'] = self.file_property_content
        if self.file_version is not None:
            result['FileVersion'] = self.file_version
        if self.is_current_prod is not None:
            result['IsCurrentProd'] = self.is_current_prod
        if self.node_content is not None:
            result['NodeContent'] = self.node_content
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.status is not None:
            result['Status'] = self.status
        if self.use_type is not None:
            result['UseType'] = self.use_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ChangeType') is not None:
            self.change_type = m.get('ChangeType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CommitTime') is not None:
            self.commit_time = m.get('CommitTime')
        if m.get('CommitUser') is not None:
            self.commit_user = m.get('CommitUser')
        if m.get('FileContent') is not None:
            self.file_content = m.get('FileContent')
        if m.get('FileName') is not None:
            self.file_name = m.get('FileName')
        if m.get('FilePropertyContent') is not None:
            self.file_property_content = m.get('FilePropertyContent')
        if m.get('FileVersion') is not None:
            self.file_version = m.get('FileVersion')
        if m.get('IsCurrentProd') is not None:
            self.is_current_prod = m.get('IsCurrentProd')
        if m.get('NodeContent') is not None:
            self.node_content = m.get('NodeContent')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('UseType') is not None:
            self.use_type = m.get('UseType')
        return self


class GetFileVersionResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The details of the file version.
        self.data = data  # type: GetFileVersionResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetFileVersionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetFileVersionResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetFileVersionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetFileVersionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetFileVersionResponse, self).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=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 = GetFileVersionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetFolderRequest(TeaModel):
    def __init__(self, folder_id=None, folder_path=None, project_id=None, project_identifier=None):
        # The ID of the folder. You can call the [ListFolders](~~173955~~) operation to query the ID.
        # 
        # You must specify either this parameter or the FolderPath parameter.
        self.folder_id = folder_id  # type: str
        # The path of the folder. You can call the [ListFolders](~~173955~~) operation to query the path.
        # 
        # You must specify either this parameter or the FolderId parameter.
        self.folder_path = folder_path  # type: str
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID. You must specify either this parameter or ProjectIdentifier to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Settings panel to obtain the name. You must specify either this parameter or ProjectId to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFolderRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.folder_path is not None:
            result['FolderPath'] = self.folder_path
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('FolderPath') is not None:
            self.folder_path = m.get('FolderPath')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class GetFolderResponseBodyData(TeaModel):
    def __init__(self, folder_id=None, folder_path=None):
        # The ID of the folder.
        self.folder_id = folder_id  # type: str
        # The path of the folder.
        self.folder_path = folder_path  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetFolderResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.folder_path is not None:
            result['FolderPath'] = self.folder_path
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('FolderPath') is not None:
            self.folder_path = m.get('FolderPath')
        return self


class GetFolderResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The details of the folder.
        self.data = data  # type: GetFolderResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetFolderResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetFolderResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetFolderResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetFolderResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetFolderResponse, self).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=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 = GetFolderResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetIDEEventDetailRequest(TeaModel):
    def __init__(self, message_id=None, project_id=None):
        # The ID of the message. You can obtain the ID from the received message when the extension point event is triggered.
        self.message_id = message_id  # type: str
        # The ID of the workspace. You can obtain the ID from the message.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetIDEEventDetailRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message_id is not None:
            result['MessageId'] = self.message_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('MessageId') is not None:
            self.message_id = m.get('MessageId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetIDEEventDetailResponseBodyEventDetailCommittedFileFilePropertyContent(TeaModel):
    def __init__(self, business_id=None, current_version=None, data_source_name=None, folder_id=None, owner=None,
                 parent_file_id=None):
        # The ID of the workflow to which the file belongs.
        self.business_id = business_id  # type: long
        # The latest version number of the file.
        self.current_version = current_version  # type: long
        # The name of the compute engine instance with which the file is associated.
        self.data_source_name = data_source_name  # type: str
        # The ID of the folder to which the file belongs. You can call the [GetFolder](~~173952~~) operation to query the details of the file based on the folder ID.
        self.folder_id = folder_id  # type: str
        # The owner of the file.
        self.owner = owner  # type: str
        # The ID of the do-while node or for-each node that corresponds to the file.
        self.parent_file_id = parent_file_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetIDEEventDetailResponseBodyEventDetailCommittedFileFilePropertyContent, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.current_version is not None:
            result['CurrentVersion'] = self.current_version
        if self.data_source_name is not None:
            result['DataSourceName'] = self.data_source_name
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.parent_file_id is not None:
            result['ParentFileId'] = self.parent_file_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('CurrentVersion') is not None:
            self.current_version = m.get('CurrentVersion')
        if m.get('DataSourceName') is not None:
            self.data_source_name = m.get('DataSourceName')
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ParentFileId') is not None:
            self.parent_file_id = m.get('ParentFileId')
        return self


class GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfigurationInputList(TeaModel):
    def __init__(self, input=None, parse_type=None):
        # The output names of the parent files on which the current file depends.
        # 
        # This parameter is equivalent to the Output Name parameter under Parent Nodes in the Dependencies section of the Properties panel in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.input = input  # type: str
        # The mode of the configuration file dependency. Valid values:
        # 
        # *   MANUAL: The scheduling dependencies are manually configured.
        # *   AUTO: The scheduling dependencies are automatically parsed.
        self.parse_type = parse_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfigurationInputList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.input is not None:
            result['Input'] = self.input
        if self.parse_type is not None:
            result['ParseType'] = self.parse_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Input') is not None:
            self.input = m.get('Input')
        if m.get('ParseType') is not None:
            self.parse_type = m.get('ParseType')
        return self


class GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfigurationOutputList(TeaModel):
    def __init__(self, output=None, ref_table_name=None):
        # The output name of the current file.
        # 
        # This parameter is equivalent to the Output Name parameter under Output in the Dependencies section of the Properties panel in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.output = output  # type: str
        # The output table name of the current file.
        # 
        # This parameter is equivalent to the Output Table Name parameter under Output in the Dependencies section of the Properties panel in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.ref_table_name = ref_table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfigurationOutputList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.output is not None:
            result['Output'] = self.output
        if self.ref_table_name is not None:
            result['RefTableName'] = self.ref_table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Output') is not None:
            self.output = m.get('Output')
        if m.get('RefTableName') is not None:
            self.ref_table_name = m.get('RefTableName')
        return self


class GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfiguration(TeaModel):
    def __init__(self, auto_rerun_interval_millis=None, auto_rerun_times=None, cron_express=None, cycle_type=None,
                 dependent_node_id_list=None, dependent_type=None, input_list=None, output_list=None, para_value=None, rerun_mode=None,
                 resource_group_id=None, scheduler_type=None):
        # The interval at which the node corresponding to the file is rerun. Unit: milliseconds.
        self.auto_rerun_interval_millis = auto_rerun_interval_millis  # type: long
        # The number of times that the node corresponding to the file can be rerun.
        self.auto_rerun_times = auto_rerun_times  # type: long
        # The CRON expression that is used to schedule the node corresponding to the file.
        self.cron_express = cron_express  # type: str
        # The type of the scheduling cycle of the node that corresponds to the file. Valid values: NOT_DAY and DAY. A value of NOT_DAY indicates that the node is scheduled to run by minute or hour. A value of DAY indicates that the node is scheduled to run by day, week, or month.
        # 
        # This parameter is equivalent to the Scheduling Cycle parameter in the Schedule section of the Properties panel in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.cycle_type = cycle_type  # type: str
        # The IDs of the nodes on which the node corresponding to the file depends when the DependentType parameter is set to USER_DEFINE. Multiple IDs are separated by commas (,).
        # 
        # This parameter is equivalent to the field that appears after Previous Cycle is selected and the Depend On parameter is set to Other Nodes in the Dependencies section of the Properties panel in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.dependent_node_id_list = dependent_node_id_list  # type: str
        # The type of the cross-cycle scheduling dependency of the node that corresponds to the file. Valid values:
        # 
        # *   SELF: The instance generated for the node in the current cycle depends on the instance generated for the node in the previous cycle.
        # *   CHILD: The instance generated for the node in the current cycle depends on the instances generated for the descendant nodes at the nearest level of the node in the previous cycle.
        # *   USER_DEFINE: The instance generated for the node in the current cycle depends on the instances generated for one or more specified nodes in the previous cycle.
        # *   NONE: No cross-cycle scheduling dependency type is selected for the node.
        self.dependent_type = dependent_type  # type: str
        # The output names of the parent files on which the current file depends.
        self.input_list = input_list  # type: list[GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfigurationInputList]
        # The output names of the current file.
        # 
        # This parameter is equivalent to the Output Name parameter under Output in the Dependencies section of the Properties panel in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.output_list = output_list  # type: list[GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfigurationOutputList]
        # The scheduling parameters.
        # 
        # This parameter is equivalent to the configuration of the scheduling parameters in the Parameters section of the Properties panel in the [DataWorks console](https://workbench.data.aliyun.com/console). For more information, see [Configure scheduling parameters](~~137548~~).
        self.para_value = para_value  # type: str
        # Indicates whether the node can be rerun. Valid values:
        # 
        # *   ALL_ALLOWED: The node can be rerun regardless of whether it is successfully run or fails to run.
        # *   FAILURE_ALLOWED: The node can be rerun only after it fails to run.
        # *   ALL_DENIED: The node cannot be rerun regardless of whether it is successfully run or fails to run.
        # 
        # This parameter is equivalent to the Rerun parameter in the Schedule section of the Properties panel in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.rerun_mode = rerun_mode  # type: str
        # The ID of the resource group that is used to run the node that corresponds to the file. You can call the [ListResourceGroups](~~173913~~) operation to query the available resource groups in the workspace.
        self.resource_group_id = resource_group_id  # type: long
        # The scheduling type of the node. Valid values:
        # 
        # *   NORMAL: The node is an auto triggered node.
        # *   MANUAL: The node is a manually triggered node. Manually triggered nodes cannot be automatically triggered. They correspond to the nodes in the Manually Triggered Workflows pane.
        # *   PAUSE: The node is a paused node.
        # *   SKIP: The node is a dry-run node. Dry-run nodes are started as scheduled but the system sets the status of the nodes to successful when it starts to run them.
        self.scheduler_type = scheduler_type  # type: str

    def validate(self):
        if self.input_list:
            for k in self.input_list:
                if k:
                    k.validate()
        if self.output_list:
            for k in self.output_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfiguration, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.auto_rerun_interval_millis is not None:
            result['AutoRerunIntervalMillis'] = self.auto_rerun_interval_millis
        if self.auto_rerun_times is not None:
            result['AutoRerunTimes'] = self.auto_rerun_times
        if self.cron_express is not None:
            result['CronExpress'] = self.cron_express
        if self.cycle_type is not None:
            result['CycleType'] = self.cycle_type
        if self.dependent_node_id_list is not None:
            result['DependentNodeIdList'] = self.dependent_node_id_list
        if self.dependent_type is not None:
            result['DependentType'] = self.dependent_type
        result['InputList'] = []
        if self.input_list is not None:
            for k in self.input_list:
                result['InputList'].append(k.to_map() if k else None)
        result['OutputList'] = []
        if self.output_list is not None:
            for k in self.output_list:
                result['OutputList'].append(k.to_map() if k else None)
        if self.para_value is not None:
            result['ParaValue'] = self.para_value
        if self.rerun_mode is not None:
            result['RerunMode'] = self.rerun_mode
        if self.resource_group_id is not None:
            result['ResourceGroupId'] = self.resource_group_id
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AutoRerunIntervalMillis') is not None:
            self.auto_rerun_interval_millis = m.get('AutoRerunIntervalMillis')
        if m.get('AutoRerunTimes') is not None:
            self.auto_rerun_times = m.get('AutoRerunTimes')
        if m.get('CronExpress') is not None:
            self.cron_express = m.get('CronExpress')
        if m.get('CycleType') is not None:
            self.cycle_type = m.get('CycleType')
        if m.get('DependentNodeIdList') is not None:
            self.dependent_node_id_list = m.get('DependentNodeIdList')
        if m.get('DependentType') is not None:
            self.dependent_type = m.get('DependentType')
        self.input_list = []
        if m.get('InputList') is not None:
            for k in m.get('InputList'):
                temp_model = GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfigurationInputList()
                self.input_list.append(temp_model.from_map(k))
        self.output_list = []
        if m.get('OutputList') is not None:
            for k in m.get('OutputList'):
                temp_model = GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfigurationOutputList()
                self.output_list.append(temp_model.from_map(k))
        if m.get('ParaValue') is not None:
            self.para_value = m.get('ParaValue')
        if m.get('RerunMode') is not None:
            self.rerun_mode = m.get('RerunMode')
        if m.get('ResourceGroupId') is not None:
            self.resource_group_id = m.get('ResourceGroupId')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        return self


class GetIDEEventDetailResponseBodyEventDetailCommittedFile(TeaModel):
    def __init__(self, change_type=None, comment=None, committor=None, content=None, file_id=None, file_name=None,
                 file_property_content=None, file_type=None, node_configuration=None, node_id=None, use_type=None):
        # The type of the change to the file of the current version. Valid values: CREATE, UPDATE, and DELETE.
        self.change_type = change_type  # type: str
        # The description of the file version.
        self.comment = comment  # type: str
        # The ID of the Alibaba Cloud account that is used to create the file of the current version.
        self.committor = committor  # type: str
        # The code in the file of the current version.
        self.content = content  # type: str
        # The ID of the file.
        self.file_id = file_id  # type: long
        # The name of the file.
        self.file_name = file_name  # type: str
        # The details of the file.
        self.file_property_content = file_property_content  # type: GetIDEEventDetailResponseBodyEventDetailCommittedFileFilePropertyContent
        # The type of the code in the file. Examples: 6 (Shell), 10 (ODPS SQL), 11 (ODPS MR), 23 (Data Integration), 24 (ODPS Script), 99 (zero load), 221 (PyODPS 2), 225 (ODPS Spark), 227 (EMR Hive), 228 (EMR Spark), 229 (EMR Spark SQL), 230 (EMR MR), 239 (OSS object inspection), 257 (EMR Shell), 258 (EMR Spark Shell), 259 (EMR Presto), 260 (EMR Impala), 900 (real-time sync), 1089 (cross-tenant collaboration), 1091 (Hologres development), 1093 (Hologres SQL), 1100 (assignment), and 1221 (PyODPS 3).
        self.file_type = file_type  # type: long
        # The scheduling properties of the node that corresponds to the file.
        self.node_configuration = node_configuration  # type: GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfiguration
        # The ID of the node that is scheduled.
        self.node_id = node_id  # type: long
        # The module to which the file belongs. Valid values:
        # 
        # *   NORMAL: The file is used for DataStudio.
        # *   MANUAL: The file is used for a manually triggered node.
        # *   MANUAL_BIZ: The file is used for a manually triggered workflow.
        # *   SKIP: The file is used for a dry-run DataStudio node.
        # *   ADHOCQUERY: The file is used for an ad hoc query.
        # *   COMPONENT: The file is used for a snippet.
        self.use_type = use_type  # type: str

    def validate(self):
        if self.file_property_content:
            self.file_property_content.validate()
        if self.node_configuration:
            self.node_configuration.validate()

    def to_map(self):
        _map = super(GetIDEEventDetailResponseBodyEventDetailCommittedFile, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.change_type is not None:
            result['ChangeType'] = self.change_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.committor is not None:
            result['Committor'] = self.committor
        if self.content is not None:
            result['Content'] = self.content
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.file_name is not None:
            result['FileName'] = self.file_name
        if self.file_property_content is not None:
            result['FilePropertyContent'] = self.file_property_content.to_map()
        if self.file_type is not None:
            result['FileType'] = self.file_type
        if self.node_configuration is not None:
            result['NodeConfiguration'] = self.node_configuration.to_map()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.use_type is not None:
            result['UseType'] = self.use_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ChangeType') is not None:
            self.change_type = m.get('ChangeType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('Committor') is not None:
            self.committor = m.get('Committor')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('FileName') is not None:
            self.file_name = m.get('FileName')
        if m.get('FilePropertyContent') is not None:
            temp_model = GetIDEEventDetailResponseBodyEventDetailCommittedFileFilePropertyContent()
            self.file_property_content = temp_model.from_map(m['FilePropertyContent'])
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        if m.get('NodeConfiguration') is not None:
            temp_model = GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfiguration()
            self.node_configuration = temp_model.from_map(m['NodeConfiguration'])
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('UseType') is not None:
            self.use_type = m.get('UseType')
        return self


class GetIDEEventDetailResponseBodyEventDetailDeletedFile(TeaModel):
    def __init__(self, business_id=None, content=None, current_version=None, data_source_name=None, file_id=None,
                 file_name=None, file_type=None, folder_id=None, node_id=None, owner=None, parent_file_id=None, use_type=None):
        # The ID of the workflow to which the file belongs.
        self.business_id = business_id  # type: long
        # The code in the file of the current version.
        self.content = content  # type: str
        # The latest version number of the file.
        self.current_version = current_version  # type: long
        # The name of the compute engine instance with which the file is associated.
        self.data_source_name = data_source_name  # type: str
        # The ID of the file.
        self.file_id = file_id  # type: long
        # The name of the file.
        self.file_name = file_name  # type: str
        # The type of the code in the file. Examples: 6 (Shell), 10 (ODPS SQL), 11 (ODPS MR), 23 (Data Integration), 24 (ODPS Script), 99 (zero load), 221 (PyODPS 2), 225 (ODPS Spark), 227 (EMR Hive), 228 (EMR Spark), 229 (EMR Spark SQL), 230 (EMR MR), 239 (OSS object inspection), 257 (EMR Shell), 258 (EMR Spark Shell), 259 (EMR Presto), 260 (EMR Impala), 900 (real-time sync), 1089 (cross-tenant collaboration), 1091 (Hologres development), 1093 (Hologres SQL), 1100 (assignment), and 1221 (PyODPS 3).
        self.file_type = file_type  # type: long
        # The ID of the folder to which the file belongs. You can call the [GetFolder](~~173952~~) operation to query the details of the file based on the folder ID.
        self.folder_id = folder_id  # type: str
        # The ID of the node that is scheduled.
        self.node_id = node_id  # type: long
        # The owner of the file.
        self.owner = owner  # type: str
        # The ID of the do-while node or for-each node that corresponds to the file.
        self.parent_file_id = parent_file_id  # type: long
        # The module to which the file belongs. Valid values:
        # 
        # *   NORMAL: The file is used for DataStudio.
        # *   MANUAL: The file is used for a manually triggered node.
        # *   MANUAL_BIZ: The file is used for a manually triggered workflow.
        # *   SKIP: The file is used for a dry-run DataStudio node.
        # *   ADHOCQUERY: The file is used for an ad hoc query.
        # *   COMPONENT: The file is used for a snippet.
        self.use_type = use_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetIDEEventDetailResponseBodyEventDetailDeletedFile, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.content is not None:
            result['Content'] = self.content
        if self.current_version is not None:
            result['CurrentVersion'] = self.current_version
        if self.data_source_name is not None:
            result['DataSourceName'] = self.data_source_name
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.file_name is not None:
            result['FileName'] = self.file_name
        if self.file_type is not None:
            result['FileType'] = self.file_type
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.parent_file_id is not None:
            result['ParentFileId'] = self.parent_file_id
        if self.use_type is not None:
            result['UseType'] = self.use_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('CurrentVersion') is not None:
            self.current_version = m.get('CurrentVersion')
        if m.get('DataSourceName') is not None:
            self.data_source_name = m.get('DataSourceName')
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('FileName') is not None:
            self.file_name = m.get('FileName')
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ParentFileId') is not None:
            self.parent_file_id = m.get('ParentFileId')
        if m.get('UseType') is not None:
            self.use_type = m.get('UseType')
        return self


class GetIDEEventDetailResponseBodyEventDetailFileExecutionCommand(TeaModel):
    def __init__(self, content=None, data_source_name=None, file_id=None, file_type=None):
        # The code in the file of the current version.
        self.content = content  # type: str
        # The name of the compute engine instance with which the file is associated.
        self.data_source_name = data_source_name  # type: str
        # The ID of the file.
        self.file_id = file_id  # type: long
        # The type of the code in the file. Examples: 6 (Shell), 10 (ODPS SQL), 11 (ODPS MR), 23 (Data Integration), 24 (ODPS Script), 99 (zero load), 221 (PyODPS 2), 225 (ODPS Spark), 227 (EMR Hive), 228 (EMR Spark), 229 (EMR Spark SQL), 230 (EMR MR), 239 (OSS object inspection), 257 (EMR Shell), 258 (EMR Spark Shell), 259 (EMR Presto), 260 (EMR Impala), 900 (real-time sync), 1089 (cross-tenant collaboration), 1091 (Hologres development), 1093 (Hologres SQL), 1100 (assignment), and 1221 (PyODPS 3).
        self.file_type = file_type  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetIDEEventDetailResponseBodyEventDetailFileExecutionCommand, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.data_source_name is not None:
            result['DataSourceName'] = self.data_source_name
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.file_type is not None:
            result['FileType'] = self.file_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('DataSourceName') is not None:
            self.data_source_name = m.get('DataSourceName')
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        return self


class GetIDEEventDetailResponseBodyEventDetailTableModelColumns(TeaModel):
    def __init__(self, column_name=None, column_type=None, comment=None, is_partition_column=None):
        # The name of the column.
        self.column_name = column_name  # type: str
        # The data type of the column.
        self.column_type = column_type  # type: str
        # The remarks of the column.
        self.comment = comment  # type: str
        # Indicates whether the column is a partition key column. Valid values:
        # 
        # - true: The column is a partition key column.
        # - false: The column is not a partition key column.
        self.is_partition_column = is_partition_column  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetIDEEventDetailResponseBodyEventDetailTableModelColumns, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.column_type is not None:
            result['ColumnType'] = self.column_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.is_partition_column is not None:
            result['IsPartitionColumn'] = self.is_partition_column
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('ColumnType') is not None:
            self.column_type = m.get('ColumnType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('IsPartitionColumn') is not None:
            self.is_partition_column = m.get('IsPartitionColumn')
        return self


class GetIDEEventDetailResponseBodyEventDetailTableModel(TeaModel):
    def __init__(self, columns=None, comment=None, data_source_name=None, env=None, life_cycle=None, location=None,
                 table_name=None):
        # The columns in the table.
        self.columns = columns  # type: list[GetIDEEventDetailResponseBodyEventDetailTableModelColumns]
        # The description of the table.
        self.comment = comment  # type: str
        # The name of the compute engine instance to which the table belongs.
        self.data_source_name = data_source_name  # type: str
        # The environment in which the table is used. Valid values:
        # 
        # - DEV: development environment
        # - PROD: production environment
        self.env = env  # type: str
        # The lifecycle of the table. Unit: days.
        self.life_cycle = life_cycle  # type: long
        # The path of the table.
        self.location = location  # type: str
        # The name of the table.
        self.table_name = table_name  # type: str

    def validate(self):
        if self.columns:
            for k in self.columns:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetIDEEventDetailResponseBodyEventDetailTableModel, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Columns'] = []
        if self.columns is not None:
            for k in self.columns:
                result['Columns'].append(k.to_map() if k else None)
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.data_source_name is not None:
            result['DataSourceName'] = self.data_source_name
        if self.env is not None:
            result['Env'] = self.env
        if self.life_cycle is not None:
            result['LifeCycle'] = self.life_cycle
        if self.location is not None:
            result['Location'] = self.location
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.columns = []
        if m.get('Columns') is not None:
            for k in m.get('Columns'):
                temp_model = GetIDEEventDetailResponseBodyEventDetailTableModelColumns()
                self.columns.append(temp_model.from_map(k))
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('DataSourceName') is not None:
            self.data_source_name = m.get('DataSourceName')
        if m.get('Env') is not None:
            self.env = m.get('Env')
        if m.get('LifeCycle') is not None:
            self.life_cycle = m.get('LifeCycle')
        if m.get('Location') is not None:
            self.location = m.get('Location')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetIDEEventDetailResponseBodyEventDetail(TeaModel):
    def __init__(self, committed_file=None, deleted_file=None, file_execution_command=None, table_model=None):
        # The data snapshot when the file is committed and deployed.
        # 
        # The value of this parameter is not empty only when the message type is IDE_FILE_SUBMIT_BEFORE or IDE_FILE_DEPLOY_BEFORE.
        self.committed_file = committed_file  # type: GetIDEEventDetailResponseBodyEventDetailCommittedFile
        # The data snapshot when the file is deleted. The value of this parameter is not empty only when the message type is IDE_FILE_DELETE_BEFORE.
        self.deleted_file = deleted_file  # type: GetIDEEventDetailResponseBodyEventDetailDeletedFile
        # The data snapshot when the code in the file is run. The value of this parameter is not empty only when the message type is IDE_FILE_EXECUTE_BEFORE.
        self.file_execution_command = file_execution_command  # type: GetIDEEventDetailResponseBodyEventDetailFileExecutionCommand
        # The data snapshot when the table is committed and deployed. The value of this parameter is not empty only when the message type is IDE_TABLE_SUBMIT_BEFORE or IDE_TABLE_DEPLOY_BEFORE.
        self.table_model = table_model  # type: GetIDEEventDetailResponseBodyEventDetailTableModel

    def validate(self):
        if self.committed_file:
            self.committed_file.validate()
        if self.deleted_file:
            self.deleted_file.validate()
        if self.file_execution_command:
            self.file_execution_command.validate()
        if self.table_model:
            self.table_model.validate()

    def to_map(self):
        _map = super(GetIDEEventDetailResponseBodyEventDetail, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.committed_file is not None:
            result['CommittedFile'] = self.committed_file.to_map()
        if self.deleted_file is not None:
            result['DeletedFile'] = self.deleted_file.to_map()
        if self.file_execution_command is not None:
            result['FileExecutionCommand'] = self.file_execution_command.to_map()
        if self.table_model is not None:
            result['TableModel'] = self.table_model.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CommittedFile') is not None:
            temp_model = GetIDEEventDetailResponseBodyEventDetailCommittedFile()
            self.committed_file = temp_model.from_map(m['CommittedFile'])
        if m.get('DeletedFile') is not None:
            temp_model = GetIDEEventDetailResponseBodyEventDetailDeletedFile()
            self.deleted_file = temp_model.from_map(m['DeletedFile'])
        if m.get('FileExecutionCommand') is not None:
            temp_model = GetIDEEventDetailResponseBodyEventDetailFileExecutionCommand()
            self.file_execution_command = temp_model.from_map(m['FileExecutionCommand'])
        if m.get('TableModel') is not None:
            temp_model = GetIDEEventDetailResponseBodyEventDetailTableModel()
            self.table_model = temp_model.from_map(m['TableModel'])
        return self


class GetIDEEventDetailResponseBody(TeaModel):
    def __init__(self, event_detail=None, request_id=None):
        # The data snapshot that is generated when the extension point event is triggered.
        # 
        # The fields contained in data snapshots vary based on the types of the triggered extension point events. For more information, see the description of the fields.
        self.event_detail = event_detail  # type: GetIDEEventDetailResponseBodyEventDetail
        # The ID of the request. You can troubleshoot errors based on the ID.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.event_detail:
            self.event_detail.validate()

    def to_map(self):
        _map = super(GetIDEEventDetailResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.event_detail is not None:
            result['EventDetail'] = self.event_detail.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EventDetail') is not None:
            temp_model = GetIDEEventDetailResponseBodyEventDetail()
            self.event_detail = temp_model.from_map(m['EventDetail'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetIDEEventDetailResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetIDEEventDetailResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetIDEEventDetailResponse, self).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=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 = GetIDEEventDetailResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetInstanceRequest(TeaModel):
    def __init__(self, instance_id=None, project_env=None):
        # The ID of the instance. You can call the [ListInstances](~~173982~~) operation to query the ID.
        self.instance_id = instance_id  # type: long
        # The environment of the workspace. Valid values: PROD and DEV. The value PROD indicates the production environment, and the value DEV indicates the development environment.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class GetInstanceResponseBodyData(TeaModel):
    def __init__(self, baseline_id=None, begin_running_time=None, begin_wait_res_time=None,
                 begin_wait_time_time=None, bizdate=None, business_id=None, connection=None, create_time=None, create_user=None,
                 cyc_time=None, dag_id=None, dag_type=None, dqc_description=None, dqc_type=None, finish_time=None,
                 instance_id=None, modify_time=None, node_id=None, node_name=None, param_values=None, priority=None,
                 related_flow_id=None, repeat_interval=None, repeatability=None, status=None, task_rerun_time=None, task_type=None):
        # The ID of the baseline.
        self.baseline_id = baseline_id  # type: long
        # The time when the instance started to run.
        self.begin_running_time = begin_running_time  # type: long
        # The time when the instance started to wait for resources.
        self.begin_wait_res_time = begin_wait_res_time  # type: long
        # The time when the instance started to wait to be run.
        self.begin_wait_time_time = begin_wait_time_time  # type: long
        # The data timestamp. In most cases, the value is one day before the date when the instance is run.
        self.bizdate = bizdate  # type: long
        # The ID of the workflow.
        self.business_id = business_id  # type: long
        # The connection string.
        self.connection = connection  # type: str
        # The time when the instance was generated.
        self.create_time = create_time  # type: long
        # The owner of the instance.
        self.create_user = create_user  # type: str
        # The scheduled time of the instance.
        self.cyc_time = cyc_time  # type: long
        # The ID of the workflow.
        self.dag_id = dag_id  # type: long
        # The type of the workflow. Valid values:
        # 
        # *   DAILY: The workflow is used to run auto triggered nodes.
        # *   MANUAL: The workflow is used to run manually triggered nodes.
        # *   SMOKE_TEST: The workflow is used to perform smoke testing.
        # *   SUPPLY_DATA: The workflow is used to backfill data.
        self.dag_type = dag_type  # type: str
        # The table and partition filter expression in Data Quality that are associated with the instance.
        self.dqc_description = dqc_description  # type: str
        # Indicates whether the instance is associated with a monitoring rule in Data Quality. Valid values:
        # 
        # *   0: The instance is associated with a monitoring rule in Data Quality.
        # *   1: The instance is not associated with a monitoring rule in Data Quality.
        self.dqc_type = dqc_type  # type: int
        # The time when the running of the instance was complete.
        self.finish_time = finish_time  # type: long
        # The ID of the instance.
        self.instance_id = instance_id  # type: long
        # The time when the instance was last modified.
        self.modify_time = modify_time  # type: long
        # The ID of the node that generates the instance.
        self.node_id = node_id  # type: long
        # The name of the node that generates the instance.
        self.node_name = node_name  # type: str
        # The values of the parameters related to the node.
        self.param_values = param_values  # type: str
        # The priority of the instance. Valid values: 1, 3, 5, 7, and 8. A great value indicates a high priority. Default value: 1.
        self.priority = priority  # type: int
        # The ID of the workflow to which the node that generates the instance belongs.
        self.related_flow_id = related_flow_id  # type: long
        # The interval at which the node that generates the instance is rerun after the node fails to run. Unit: milliseconds.
        self.repeat_interval = repeat_interval  # type: long
        # Indicates whether the node that generates the instance can be rerun.
        self.repeatability = repeatability  # type: bool
        # The status of the node that generates the instance. Valid values:
        # 
        # *   NOT_RUN: The node is not run.
        # *   WAIT_TIME: The node is waiting for its scheduled time to arrive.
        # *   WAIT_RESOURCE: The node is waiting for resources.
        # *   RUNNING: The node is running.
        # *   CHECKING: Data quality is being checked for the node.
        # *   CHECKING_CONDITION: Branch conditions are being checked for the node.
        # *   FAILURE: The node fails to run.
        # *   SUCCESS: The node is successfully run.
        self.status = status  # type: str
        # The number of times the node that generates the instance can be rerun. This parameter can be left empty, or the value of this parameter can be an integer that is greater than or equal to 0.
        # 
        # *   If this parameter is left empty, the number of rerun times is not specified for the node.
        # *   If the value of this parameter is 0, the node cannot be rerun.
        # *   If the value of this parameter is n (an integer that is greater than 0), the node can be rerun n times. For example, if the value of this parameter is 1, the node can be rerun once. If the value of this parameter is 2, the node can be rerun two times, and so on.
        self.task_rerun_time = task_rerun_time  # type: int
        # The scheduling type of the node that generates the instance. Valid values:
        # 
        # *   NORMAL(0): The node is an auto triggered node. It is run on a regular basis.
        # *   MANUAL(1): The node is a manually triggered node. It is not run on a regular basis.
        # *   PAUSE(2): The node is a frozen node. The scheduling system still runs the node on a regular basis but sets it to FAILURE when the scheduling system starts to run the node.
        # *   SKIP(3): The node is a dry-run node. The scheduling system still runs the node on a regular basis but sets it to SUCCESS when the scheduling system starts to run the node.
        # *   SKIP_UNCHOOSE(4): The node is an unselected node in a temporary workflow. This type of node exists only in temporary workflows. The scheduling system sets the node to SUCCESS when the scheduling system starts to run the node.
        # *   SKIP_CYCLE(5): The node is a node that is scheduled by week or month and is waiting for its scheduled time. The scheduling system still runs the node on a regular basis but sets it to SUCCESS when the scheduling system starts to run the node.
        # *   CONDITION_UNCHOOSE(6): The node is not selected by its ancestor branch node and is run as a dry-run node.
        # *   REALTIME_DEPRECATED(7): The node has instances generated in real time but deprecated. The scheduling system directly sets the node to SUCCESS.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.begin_running_time is not None:
            result['BeginRunningTime'] = self.begin_running_time
        if self.begin_wait_res_time is not None:
            result['BeginWaitResTime'] = self.begin_wait_res_time
        if self.begin_wait_time_time is not None:
            result['BeginWaitTimeTime'] = self.begin_wait_time_time
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.connection is not None:
            result['Connection'] = self.connection
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.create_user is not None:
            result['CreateUser'] = self.create_user
        if self.cyc_time is not None:
            result['CycTime'] = self.cyc_time
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.dag_type is not None:
            result['DagType'] = self.dag_type
        if self.dqc_description is not None:
            result['DqcDescription'] = self.dqc_description
        if self.dqc_type is not None:
            result['DqcType'] = self.dqc_type
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.modify_time is not None:
            result['ModifyTime'] = self.modify_time
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.param_values is not None:
            result['ParamValues'] = self.param_values
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.related_flow_id is not None:
            result['RelatedFlowId'] = self.related_flow_id
        if self.repeat_interval is not None:
            result['RepeatInterval'] = self.repeat_interval
        if self.repeatability is not None:
            result['Repeatability'] = self.repeatability
        if self.status is not None:
            result['Status'] = self.status
        if self.task_rerun_time is not None:
            result['TaskRerunTime'] = self.task_rerun_time
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BeginRunningTime') is not None:
            self.begin_running_time = m.get('BeginRunningTime')
        if m.get('BeginWaitResTime') is not None:
            self.begin_wait_res_time = m.get('BeginWaitResTime')
        if m.get('BeginWaitTimeTime') is not None:
            self.begin_wait_time_time = m.get('BeginWaitTimeTime')
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('Connection') is not None:
            self.connection = m.get('Connection')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('CreateUser') is not None:
            self.create_user = m.get('CreateUser')
        if m.get('CycTime') is not None:
            self.cyc_time = m.get('CycTime')
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('DagType') is not None:
            self.dag_type = m.get('DagType')
        if m.get('DqcDescription') is not None:
            self.dqc_description = m.get('DqcDescription')
        if m.get('DqcType') is not None:
            self.dqc_type = m.get('DqcType')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ModifyTime') is not None:
            self.modify_time = m.get('ModifyTime')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('ParamValues') is not None:
            self.param_values = m.get('ParamValues')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('RelatedFlowId') is not None:
            self.related_flow_id = m.get('RelatedFlowId')
        if m.get('RepeatInterval') is not None:
            self.repeat_interval = m.get('RepeatInterval')
        if m.get('Repeatability') is not None:
            self.repeatability = m.get('Repeatability')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskRerunTime') is not None:
            self.task_rerun_time = m.get('TaskRerunTime')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class GetInstanceResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The details about the instance.
        self.data = data  # type: GetInstanceResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned because the instance fails to be scheduled.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetInstanceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetInstanceResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetInstanceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetInstanceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetInstanceResponse, self).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=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 = GetInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetInstanceConsumeTimeRankRequest(TeaModel):
    def __init__(self, bizdate=None, project_id=None):
        self.bizdate = bizdate  # type: str
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceConsumeTimeRankRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetInstanceConsumeTimeRankResponseBodyInstanceConsumeTimeRankConsumeTimeRank(TeaModel):
    def __init__(self, bizdate=None, consumed=None, instance_id=None, node_id=None, node_name=None, owner=None,
                 prg_type=None):
        self.bizdate = bizdate  # type: long
        self.consumed = consumed  # type: long
        self.instance_id = instance_id  # type: long
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.owner = owner  # type: str
        self.prg_type = prg_type  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceConsumeTimeRankResponseBodyInstanceConsumeTimeRankConsumeTimeRank, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.consumed is not None:
            result['Consumed'] = self.consumed
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.prg_type is not None:
            result['PrgType'] = self.prg_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('Consumed') is not None:
            self.consumed = m.get('Consumed')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PrgType') is not None:
            self.prg_type = m.get('PrgType')
        return self


class GetInstanceConsumeTimeRankResponseBodyInstanceConsumeTimeRank(TeaModel):
    def __init__(self, consume_time_rank=None, update_time=None):
        self.consume_time_rank = consume_time_rank  # type: list[GetInstanceConsumeTimeRankResponseBodyInstanceConsumeTimeRankConsumeTimeRank]
        self.update_time = update_time  # type: long

    def validate(self):
        if self.consume_time_rank:
            for k in self.consume_time_rank:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetInstanceConsumeTimeRankResponseBodyInstanceConsumeTimeRank, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ConsumeTimeRank'] = []
        if self.consume_time_rank is not None:
            for k in self.consume_time_rank:
                result['ConsumeTimeRank'].append(k.to_map() if k else None)
        if self.update_time is not None:
            result['UpdateTime'] = self.update_time
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.consume_time_rank = []
        if m.get('ConsumeTimeRank') is not None:
            for k in m.get('ConsumeTimeRank'):
                temp_model = GetInstanceConsumeTimeRankResponseBodyInstanceConsumeTimeRankConsumeTimeRank()
                self.consume_time_rank.append(temp_model.from_map(k))
        if m.get('UpdateTime') is not None:
            self.update_time = m.get('UpdateTime')
        return self


class GetInstanceConsumeTimeRankResponseBody(TeaModel):
    def __init__(self, instance_consume_time_rank=None, request_id=None):
        self.instance_consume_time_rank = instance_consume_time_rank  # type: GetInstanceConsumeTimeRankResponseBodyInstanceConsumeTimeRank
        self.request_id = request_id  # type: str

    def validate(self):
        if self.instance_consume_time_rank:
            self.instance_consume_time_rank.validate()

    def to_map(self):
        _map = super(GetInstanceConsumeTimeRankResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_consume_time_rank is not None:
            result['InstanceConsumeTimeRank'] = self.instance_consume_time_rank.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceConsumeTimeRank') is not None:
            temp_model = GetInstanceConsumeTimeRankResponseBodyInstanceConsumeTimeRank()
            self.instance_consume_time_rank = temp_model.from_map(m['InstanceConsumeTimeRank'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetInstanceConsumeTimeRankResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetInstanceConsumeTimeRankResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetInstanceConsumeTimeRankResponse, self).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=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 = GetInstanceConsumeTimeRankResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetInstanceCountTrendRequest(TeaModel):
    def __init__(self, begin_date=None, end_date=None, project_id=None):
        self.begin_date = begin_date  # type: str
        self.end_date = end_date  # type: str
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceCountTrendRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.begin_date is not None:
            result['BeginDate'] = self.begin_date
        if self.end_date is not None:
            result['EndDate'] = self.end_date
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BeginDate') is not None:
            self.begin_date = m.get('BeginDate')
        if m.get('EndDate') is not None:
            self.end_date = m.get('EndDate')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetInstanceCountTrendResponseBodyInstanceCounts(TeaModel):
    def __init__(self, count=None, date=None):
        self.count = count  # type: int
        self.date = date  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceCountTrendResponseBodyInstanceCounts, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.date is not None:
            result['Date'] = self.date
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('Date') is not None:
            self.date = m.get('Date')
        return self


class GetInstanceCountTrendResponseBody(TeaModel):
    def __init__(self, instance_counts=None, request_id=None):
        self.instance_counts = instance_counts  # type: list[GetInstanceCountTrendResponseBodyInstanceCounts]
        self.request_id = request_id  # type: str

    def validate(self):
        if self.instance_counts:
            for k in self.instance_counts:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetInstanceCountTrendResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['InstanceCounts'] = []
        if self.instance_counts is not None:
            for k in self.instance_counts:
                result['InstanceCounts'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.instance_counts = []
        if m.get('InstanceCounts') is not None:
            for k in m.get('InstanceCounts'):
                temp_model = GetInstanceCountTrendResponseBodyInstanceCounts()
                self.instance_counts.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetInstanceCountTrendResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetInstanceCountTrendResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetInstanceCountTrendResponse, self).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=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 = GetInstanceCountTrendResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetInstanceErrorRankRequest(TeaModel):
    def __init__(self, project_id=None):
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceErrorRankRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetInstanceErrorRankResponseBodyInstanceErrorRankErrorRank(TeaModel):
    def __init__(self, count=None, node_id=None, node_name=None, owner=None, prg_type=None, project_id=None):
        self.count = count  # type: int
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.owner = owner  # type: str
        self.prg_type = prg_type  # type: int
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceErrorRankResponseBodyInstanceErrorRankErrorRank, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.prg_type is not None:
            result['PrgType'] = self.prg_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PrgType') is not None:
            self.prg_type = m.get('PrgType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetInstanceErrorRankResponseBodyInstanceErrorRank(TeaModel):
    def __init__(self, error_rank=None, update_time=None):
        self.error_rank = error_rank  # type: list[GetInstanceErrorRankResponseBodyInstanceErrorRankErrorRank]
        self.update_time = update_time  # type: long

    def validate(self):
        if self.error_rank:
            for k in self.error_rank:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetInstanceErrorRankResponseBodyInstanceErrorRank, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ErrorRank'] = []
        if self.error_rank is not None:
            for k in self.error_rank:
                result['ErrorRank'].append(k.to_map() if k else None)
        if self.update_time is not None:
            result['UpdateTime'] = self.update_time
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.error_rank = []
        if m.get('ErrorRank') is not None:
            for k in m.get('ErrorRank'):
                temp_model = GetInstanceErrorRankResponseBodyInstanceErrorRankErrorRank()
                self.error_rank.append(temp_model.from_map(k))
        if m.get('UpdateTime') is not None:
            self.update_time = m.get('UpdateTime')
        return self


class GetInstanceErrorRankResponseBody(TeaModel):
    def __init__(self, instance_error_rank=None, request_id=None):
        self.instance_error_rank = instance_error_rank  # type: GetInstanceErrorRankResponseBodyInstanceErrorRank
        self.request_id = request_id  # type: str

    def validate(self):
        if self.instance_error_rank:
            self.instance_error_rank.validate()

    def to_map(self):
        _map = super(GetInstanceErrorRankResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_error_rank is not None:
            result['InstanceErrorRank'] = self.instance_error_rank.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceErrorRank') is not None:
            temp_model = GetInstanceErrorRankResponseBodyInstanceErrorRank()
            self.instance_error_rank = temp_model.from_map(m['InstanceErrorRank'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetInstanceErrorRankResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetInstanceErrorRankResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetInstanceErrorRankResponse, self).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=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 = GetInstanceErrorRankResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetInstanceLogRequest(TeaModel):
    def __init__(self, instance_history_id=None, instance_id=None, project_env=None):
        # The historical record number of the instance. You can call the ListInstanceHistory operation to query the ID.
        self.instance_history_id = instance_history_id  # type: long
        # The ID of the instance.
        self.instance_id = instance_id  # type: long
        # The environment of the workspace. Valid values: PROD and DEV.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceLogRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_history_id is not None:
            result['InstanceHistoryId'] = self.instance_history_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceHistoryId') is not None:
            self.instance_history_id = m.get('InstanceHistoryId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class GetInstanceLogResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The content of the logs.
        self.data = data  # type: str
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceLogResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetInstanceLogResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetInstanceLogResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetInstanceLogResponse, self).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=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 = GetInstanceLogResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetInstanceStatusCountRequest(TeaModel):
    def __init__(self, biz_date=None, project_env=None, project_id=None):
        # The business date of the instance.
        self.biz_date = biz_date  # type: str
        # The running environment in PROD and DEV modes.
        self.project_env = project_env  # type: str
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceStatusCountRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetInstanceStatusCountResponseBodyStatusCount(TeaModel):
    def __init__(self, failure_count=None, not_run_count=None, running_count=None, success_count=None,
                 total_count=None, wait_res_count=None, wait_time_count=None):
        # The number of failed instances.
        self.failure_count = failure_count  # type: int
        # The number of instances that are not running.
        self.not_run_count = not_run_count  # type: int
        # The number of running instances.
        self.running_count = running_count  # type: int
        # The number of successful instances.
        self.success_count = success_count  # type: int
        # The total number of instances.
        self.total_count = total_count  # type: int
        # The number of instances waiting for resources.
        self.wait_res_count = wait_res_count  # type: int
        # The number of instances to be run that meet the conditions.
        self.wait_time_count = wait_time_count  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceStatusCountResponseBodyStatusCount, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.failure_count is not None:
            result['FailureCount'] = self.failure_count
        if self.not_run_count is not None:
            result['NotRunCount'] = self.not_run_count
        if self.running_count is not None:
            result['RunningCount'] = self.running_count
        if self.success_count is not None:
            result['SuccessCount'] = self.success_count
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.wait_res_count is not None:
            result['WaitResCount'] = self.wait_res_count
        if self.wait_time_count is not None:
            result['WaitTimeCount'] = self.wait_time_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FailureCount') is not None:
            self.failure_count = m.get('FailureCount')
        if m.get('NotRunCount') is not None:
            self.not_run_count = m.get('NotRunCount')
        if m.get('RunningCount') is not None:
            self.running_count = m.get('RunningCount')
        if m.get('SuccessCount') is not None:
            self.success_count = m.get('SuccessCount')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('WaitResCount') is not None:
            self.wait_res_count = m.get('WaitResCount')
        if m.get('WaitTimeCount') is not None:
            self.wait_time_count = m.get('WaitTimeCount')
        return self


class GetInstanceStatusCountResponseBody(TeaModel):
    def __init__(self, request_id=None, status_count=None):
        # The request ID, which is used to locate the logs and troubleshoot problems.
        self.request_id = request_id  # type: str
        # The status statistics of the instance.
        self.status_count = status_count  # type: GetInstanceStatusCountResponseBodyStatusCount

    def validate(self):
        if self.status_count:
            self.status_count.validate()

    def to_map(self):
        _map = super(GetInstanceStatusCountResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.status_count is not None:
            result['StatusCount'] = self.status_count.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('StatusCount') is not None:
            temp_model = GetInstanceStatusCountResponseBodyStatusCount()
            self.status_count = temp_model.from_map(m['StatusCount'])
        return self


class GetInstanceStatusCountResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetInstanceStatusCountResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetInstanceStatusCountResponse, self).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=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 = GetInstanceStatusCountResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetInstanceStatusStatisticRequest(TeaModel):
    def __init__(self, biz_date=None, dag_type=None, project_env=None, project_id=None, scheduler_type=None):
        # The date on which the numbers of instances in different states are obtained. Specify the date in the yyyy-MM-dd format.
        self.biz_date = biz_date  # type: str
        # The type of the directed acyclic graph (DAG). Valid values:
        # 
        # *   MANUAL: DAG for a manually triggered workflow
        # *   SMOKE_TEST: DAG for a smoke testing workflow
        # *   SUPPLY_DATA: DAG for a data backfill instance
        # *   BUSINESS_PROCESS_DAG: DAG for a one-time workflow
        self.dag_type = dag_type  # type: str
        # The environment of the workspace. Valid values: PROD and DEV. The value PROD indicates the production environment. The value DEV indicates the development environment.
        self.project_env = project_env  # type: str
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace ID.
        self.project_id = project_id  # type: long
        # The scheduling type of the node. Valid values:
        # 
        # *   NORMAL: auto triggered node
        # *   MANUAL: manually triggered node
        # *   PAUSE: paused node
        # *   SKIP: dry-run node
        self.scheduler_type = scheduler_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceStatusStatisticRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.dag_type is not None:
            result['DagType'] = self.dag_type
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('DagType') is not None:
            self.dag_type = m.get('DagType')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        return self


class GetInstanceStatusStatisticResponseBodyStatusCount(TeaModel):
    def __init__(self, failure_count=None, not_run_count=None, running_count=None, success_count=None,
                 total_count=None, wait_res_count=None, wait_time_count=None):
        # The number of instances that failed to run.
        self.failure_count = failure_count  # type: int
        # The number of instances that are not run.
        self.not_run_count = not_run_count  # type: int
        # The number of instances that are running.
        self.running_count = running_count  # type: int
        # The number of instances that are successfully run.
        self.success_count = success_count  # type: int
        # The total number of instances.
        self.total_count = total_count  # type: int
        # The number of instances that are waiting for resources.
        self.wait_res_count = wait_res_count  # type: int
        # The number of instances that are waiting to run.
        self.wait_time_count = wait_time_count  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetInstanceStatusStatisticResponseBodyStatusCount, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.failure_count is not None:
            result['FailureCount'] = self.failure_count
        if self.not_run_count is not None:
            result['NotRunCount'] = self.not_run_count
        if self.running_count is not None:
            result['RunningCount'] = self.running_count
        if self.success_count is not None:
            result['SuccessCount'] = self.success_count
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        if self.wait_res_count is not None:
            result['WaitResCount'] = self.wait_res_count
        if self.wait_time_count is not None:
            result['WaitTimeCount'] = self.wait_time_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FailureCount') is not None:
            self.failure_count = m.get('FailureCount')
        if m.get('NotRunCount') is not None:
            self.not_run_count = m.get('NotRunCount')
        if m.get('RunningCount') is not None:
            self.running_count = m.get('RunningCount')
        if m.get('SuccessCount') is not None:
            self.success_count = m.get('SuccessCount')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('WaitResCount') is not None:
            self.wait_res_count = m.get('WaitResCount')
        if m.get('WaitTimeCount') is not None:
            self.wait_time_count = m.get('WaitTimeCount')
        return self


class GetInstanceStatusStatisticResponseBody(TeaModel):
    def __init__(self, request_id=None, status_count=None):
        # The ID of the request. You can use the ID to search for logs and troubleshoot issues based on the logs.
        self.request_id = request_id  # type: str
        # The numbers of instances in different states.
        self.status_count = status_count  # type: GetInstanceStatusStatisticResponseBodyStatusCount

    def validate(self):
        if self.status_count:
            self.status_count.validate()

    def to_map(self):
        _map = super(GetInstanceStatusStatisticResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.status_count is not None:
            result['StatusCount'] = self.status_count.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('StatusCount') is not None:
            temp_model = GetInstanceStatusStatisticResponseBodyStatusCount()
            self.status_count = temp_model.from_map(m['StatusCount'])
        return self


class GetInstanceStatusStatisticResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetInstanceStatusStatisticResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetInstanceStatusStatisticResponse, self).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=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 = GetInstanceStatusStatisticResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetManualDagInstancesRequest(TeaModel):
    def __init__(self, dag_id=None, project_env=None, project_name=None):
        self.dag_id = dag_id  # type: str
        self.project_env = project_env  # type: str
        self.project_name = project_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetManualDagInstancesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class GetManualDagInstancesResponseBodyInstances(TeaModel):
    def __init__(self, begin_running_time=None, begin_wait_res_time=None, begin_wait_time_time=None, biz_date=None,
                 create_time=None, create_user=None, cyc_time=None, dag_id=None, dag_type=None, finish_time=None,
                 instance_id=None, modify_time=None, node_id=None, node_name=None, param_values=None, status=None,
                 task_type=None):
        self.begin_running_time = begin_running_time  # type: long
        self.begin_wait_res_time = begin_wait_res_time  # type: long
        self.begin_wait_time_time = begin_wait_time_time  # type: long
        self.biz_date = biz_date  # type: long
        self.create_time = create_time  # type: long
        self.create_user = create_user  # type: str
        self.cyc_time = cyc_time  # type: long
        self.dag_id = dag_id  # type: long
        self.dag_type = dag_type  # type: str
        self.finish_time = finish_time  # type: long
        self.instance_id = instance_id  # type: long
        self.modify_time = modify_time  # type: long
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.param_values = param_values  # type: str
        self.status = status  # type: str
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetManualDagInstancesResponseBodyInstances, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.begin_running_time is not None:
            result['BeginRunningTime'] = self.begin_running_time
        if self.begin_wait_res_time is not None:
            result['BeginWaitResTime'] = self.begin_wait_res_time
        if self.begin_wait_time_time is not None:
            result['BeginWaitTimeTime'] = self.begin_wait_time_time
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.create_user is not None:
            result['CreateUser'] = self.create_user
        if self.cyc_time is not None:
            result['CycTime'] = self.cyc_time
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.dag_type is not None:
            result['DagType'] = self.dag_type
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.modify_time is not None:
            result['ModifyTime'] = self.modify_time
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.param_values is not None:
            result['ParamValues'] = self.param_values
        if self.status is not None:
            result['Status'] = self.status
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BeginRunningTime') is not None:
            self.begin_running_time = m.get('BeginRunningTime')
        if m.get('BeginWaitResTime') is not None:
            self.begin_wait_res_time = m.get('BeginWaitResTime')
        if m.get('BeginWaitTimeTime') is not None:
            self.begin_wait_time_time = m.get('BeginWaitTimeTime')
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('CreateUser') is not None:
            self.create_user = m.get('CreateUser')
        if m.get('CycTime') is not None:
            self.cyc_time = m.get('CycTime')
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('DagType') is not None:
            self.dag_type = m.get('DagType')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ModifyTime') is not None:
            self.modify_time = m.get('ModifyTime')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('ParamValues') is not None:
            self.param_values = m.get('ParamValues')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class GetManualDagInstancesResponseBody(TeaModel):
    def __init__(self, instances=None, request_id=None):
        self.instances = instances  # type: list[GetManualDagInstancesResponseBodyInstances]
        self.request_id = request_id  # type: str

    def validate(self):
        if self.instances:
            for k in self.instances:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetManualDagInstancesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Instances'] = []
        if self.instances is not None:
            for k in self.instances:
                result['Instances'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.instances = []
        if m.get('Instances') is not None:
            for k in m.get('Instances'):
                temp_model = GetManualDagInstancesResponseBodyInstances()
                self.instances.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetManualDagInstancesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetManualDagInstancesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetManualDagInstancesResponse, self).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=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 = GetManualDagInstancesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaCategoryRequest(TeaModel):
    def __init__(self, page_num=None, page_size=None, parent_category_id=None):
        # The number of the page to return.
        self.page_num = page_num  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the category tree.
        self.parent_category_id = parent_category_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaCategoryRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_num is not None:
            result['PageNum'] = self.page_num
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.parent_category_id is not None:
            result['ParentCategoryId'] = self.parent_category_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNum') is not None:
            self.page_num = m.get('PageNum')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ParentCategoryId') is not None:
            self.parent_category_id = m.get('ParentCategoryId')
        return self


class GetMetaCategoryResponseBodyDataDataEntityList(TeaModel):
    def __init__(self, category_id=None, comment=None, create_time=None, depth=None, last_operator_id=None,
                 modified_time=None, name=None, owner_id=None, parent_category_id=None):
        # The ID of the category.
        self.category_id = category_id  # type: long
        # The remarks of the category.
        self.comment = comment  # type: str
        # The time when the category was created.
        self.create_time = create_time  # type: long
        # The number of category levels.
        self.depth = depth  # type: int
        # The ID of the user that performed the last operation.
        self.last_operator_id = last_operator_id  # type: str
        # The time when the category was last modified.
        self.modified_time = modified_time  # type: long
        # The name of the category.
        self.name = name  # type: str
        # The ID of the category owner.
        self.owner_id = owner_id  # type: str
        # The ID of the parent category.
        self.parent_category_id = parent_category_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaCategoryResponseBodyDataDataEntityList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.category_id is not None:
            result['CategoryId'] = self.category_id
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.depth is not None:
            result['Depth'] = self.depth
        if self.last_operator_id is not None:
            result['LastOperatorId'] = self.last_operator_id
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.name is not None:
            result['Name'] = self.name
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.parent_category_id is not None:
            result['ParentCategoryId'] = self.parent_category_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CategoryId') is not None:
            self.category_id = m.get('CategoryId')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('Depth') is not None:
            self.depth = m.get('Depth')
        if m.get('LastOperatorId') is not None:
            self.last_operator_id = m.get('LastOperatorId')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('ParentCategoryId') is not None:
            self.parent_category_id = m.get('ParentCategoryId')
        return self


class GetMetaCategoryResponseBodyData(TeaModel):
    def __init__(self, data_entity_list=None, page_num=None, page_size=None, total_count=None):
        # The information about the category tree.
        self.data_entity_list = data_entity_list  # type: list[GetMetaCategoryResponseBodyDataDataEntityList]
        # The page number of the returned page.
        self.page_num = page_num  # type: int
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The total number of categories.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.data_entity_list:
            for k in self.data_entity_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMetaCategoryResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DataEntityList'] = []
        if self.data_entity_list is not None:
            for k in self.data_entity_list:
                result['DataEntityList'].append(k.to_map() if k else None)
        if self.page_num is not None:
            result['PageNum'] = self.page_num
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data_entity_list = []
        if m.get('DataEntityList') is not None:
            for k in m.get('DataEntityList'):
                temp_model = GetMetaCategoryResponseBodyDataDataEntityList()
                self.data_entity_list.append(temp_model.from_map(k))
        if m.get('PageNum') is not None:
            self.page_num = m.get('PageNum')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class GetMetaCategoryResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The returned result.
        self.data = data  # type: GetMetaCategoryResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaCategoryResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaCategoryResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaCategoryResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaCategoryResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaCategoryResponse, self).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=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 = GetMetaCategoryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaCollectionDetailRequest(TeaModel):
    def __init__(self, qualified_name=None):
        # The unique identifier of the collection.
        self.qualified_name = qualified_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaCollectionDetailRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        return self


class GetMetaCollectionDetailResponseBody(TeaModel):
    def __init__(self, collection=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The collection.
        self.collection = collection  # type: Collection
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # true: The request was successful.
        # 
        # false: The request failed.
        self.success = success  # type: bool

    def validate(self):
        if self.collection:
            self.collection.validate()

    def to_map(self):
        _map = super(GetMetaCollectionDetailResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.collection is not None:
            result['Collection'] = self.collection.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Collection') is not None:
            temp_model = Collection()
            self.collection = temp_model.from_map(m['Collection'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaCollectionDetailResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaCollectionDetailResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaCollectionDetailResponse, self).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=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 = GetMetaCollectionDetailResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaColumnLineageRequest(TeaModel):
    def __init__(self, cluster_id=None, column_guid=None, column_name=None, data_source_type=None,
                 database_name=None, direction=None, page_num=None, page_size=None, table_name=None):
        # The ID of the E-MapReduce (EMR) cluster. Configure this parameter only when you query data in an EMR compute engine instance.
        self.cluster_id = cluster_id  # type: str
        # The GUID of the field.
        self.column_guid = column_guid  # type: str
        # The name of the field.
        self.column_name = column_name  # type: str
        # The type of the data source. Valid values: odps and emr.
        self.data_source_type = data_source_type  # type: str
        # The name of the database.
        self.database_name = database_name  # type: str
        # Specifies whether to query the ancestor or descendant lineage of the field. The value up indicates the ancestor lineage. The value down indicates the descendant lineage.
        self.direction = direction  # type: str
        # The number of the page to return.
        self.page_num = page_num  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The name of the metatable.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaColumnLineageRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.column_guid is not None:
            result['ColumnGuid'] = self.column_guid
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.direction is not None:
            result['Direction'] = self.direction
        if self.page_num is not None:
            result['PageNum'] = self.page_num
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('ColumnGuid') is not None:
            self.column_guid = m.get('ColumnGuid')
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('Direction') is not None:
            self.direction = m.get('Direction')
        if m.get('PageNum') is not None:
            self.page_num = m.get('PageNum')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetMetaColumnLineageResponseBodyDataDataEntityList(TeaModel):
    def __init__(self, cluster_id=None, column_guid=None, column_name=None, database_name=None, table_name=None):
        # The ID of the EMR cluster.
        self.cluster_id = cluster_id  # type: str
        # The GUID of the field.
        self.column_guid = column_guid  # type: str
        # The name of the field.
        self.column_name = column_name  # type: str
        # The name of the database.
        self.database_name = database_name  # type: str
        # The name of the metatable.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaColumnLineageResponseBodyDataDataEntityList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.column_guid is not None:
            result['ColumnGuid'] = self.column_guid
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('ColumnGuid') is not None:
            self.column_guid = m.get('ColumnGuid')
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetMetaColumnLineageResponseBodyData(TeaModel):
    def __init__(self, data_entity_list=None, page_num=None, page_size=None, total_count=None):
        # The list of metatables in the compute engine instance.
        self.data_entity_list = data_entity_list  # type: list[GetMetaColumnLineageResponseBodyDataDataEntityList]
        # The page number of the returned page.
        self.page_num = page_num  # type: int
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The total number of fields.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.data_entity_list:
            for k in self.data_entity_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMetaColumnLineageResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DataEntityList'] = []
        if self.data_entity_list is not None:
            for k in self.data_entity_list:
                result['DataEntityList'].append(k.to_map() if k else None)
        if self.page_num is not None:
            result['PageNum'] = self.page_num
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data_entity_list = []
        if m.get('DataEntityList') is not None:
            for k in m.get('DataEntityList'):
                temp_model = GetMetaColumnLineageResponseBodyDataDataEntityList()
                self.data_entity_list.append(temp_model.from_map(k))
        if m.get('PageNum') is not None:
            self.page_num = m.get('PageNum')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class GetMetaColumnLineageResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The business data returned.
        self.data = data  # type: GetMetaColumnLineageResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaColumnLineageResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaColumnLineageResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaColumnLineageResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaColumnLineageResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaColumnLineageResponse, self).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=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 = GetMetaColumnLineageResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaDBInfoRequest(TeaModel):
    def __init__(self, app_guid=None, cluster_id=None, data_source_type=None, database_name=None):
        # The ID of the request.
        self.app_guid = app_guid  # type: str
        # The business data returned.
        self.cluster_id = cluster_id  # type: str
        # The comment.
        self.data_source_type = data_source_type  # type: str
        # The type of the metadatabase. Only hive is supported.
        self.database_name = database_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaDBInfoRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.app_guid is not None:
            result['AppGuid'] = self.app_guid
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AppGuid') is not None:
            self.app_guid = m.get('AppGuid')
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        return self


class GetMetaDBInfoResponseBodyData(TeaModel):
    def __init__(self, app_guid=None, cluster_biz_id=None, comment=None, create_time=None, endpoint=None,
                 env_type=None, location=None, modify_time=None, name=None, owner_id=None, owner_name=None, project_id=None,
                 project_name=None, project_name_cn=None, tenant_id=None, type=None):
        # The display name of the workspace.
        self.app_guid = app_guid  # type: str
        # The time when the compute engine instance was modified. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since the epoch time January 1, 1970, 00:00:00 UTC.
        self.cluster_biz_id = cluster_biz_id  # type: str
        # The name of the workspace.
        self.comment = comment  # type: str
        # The name of the workspace owner.
        self.create_time = create_time  # type: long
        # The ID of the tenant.
        self.endpoint = endpoint  # type: str
        # The ID of the EMR cluster. This parameter is returned only for an EMR compute engine instance.
        self.env_type = env_type  # type: int
        self.location = location  # type: str
        self.modify_time = modify_time  # type: long
        self.name = name  # type: str
        # The endpoint of the service.
        self.owner_id = owner_id  # type: str
        # Test items
        self.owner_name = owner_name  # type: str
        # The ID of the Alibaba Cloud account used by the workspace owner.
        self.project_id = project_id  # type: long
        # The type of the environment. Valid values: 0 and 1. The value 0 indicates the development environment. The value 1 indicates the production environment.
        self.project_name = project_name  # type: str
        # The name of the metadatabase.
        self.project_name_cn = project_name_cn  # type: str
        self.tenant_id = tenant_id  # type: long
        # The ID of the workspace.
        self.type = type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaDBInfoResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.app_guid is not None:
            result['AppGuid'] = self.app_guid
        if self.cluster_biz_id is not None:
            result['ClusterBizId'] = self.cluster_biz_id
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.endpoint is not None:
            result['Endpoint'] = self.endpoint
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.location is not None:
            result['Location'] = self.location
        if self.modify_time is not None:
            result['ModifyTime'] = self.modify_time
        if self.name is not None:
            result['Name'] = self.name
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.owner_name is not None:
            result['OwnerName'] = self.owner_name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.project_name_cn is not None:
            result['ProjectNameCn'] = self.project_name_cn
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.type is not None:
            result['Type'] = self.type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AppGuid') is not None:
            self.app_guid = m.get('AppGuid')
        if m.get('ClusterBizId') is not None:
            self.cluster_biz_id = m.get('ClusterBizId')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('Endpoint') is not None:
            self.endpoint = m.get('Endpoint')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('Location') is not None:
            self.location = m.get('Location')
        if m.get('ModifyTime') is not None:
            self.modify_time = m.get('ModifyTime')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('OwnerName') is not None:
            self.owner_name = m.get('OwnerName')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('ProjectNameCn') is not None:
            self.project_name_cn = m.get('ProjectNameCn')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class GetMetaDBInfoResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None):
        # The time when the compute engine instance was created. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since the epoch time January 1, 1970, 00:00:00 UTC.
        self.data = data  # type: GetMetaDBInfoResponseBodyData
        # test table
        self.request_id = request_id  # type: str

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaDBInfoResponseBody, self).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=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaDBInfoResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetMetaDBInfoResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaDBInfoResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaDBInfoResponse, self).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=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 = GetMetaDBInfoResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaDBTableListRequest(TeaModel):
    def __init__(self, app_guid=None, cluster_id=None, data_source_type=None, database_name=None, page_number=None,
                 page_size=None):
        # The name of the metadatabase.
        self.app_guid = app_guid  # type: str
        # The type of the data source. Valid values: odps and emr.
        self.cluster_id = cluster_id  # type: str
        # The business data.
        self.data_source_type = data_source_type  # type: str
        # The ID of the request.
        self.database_name = database_name  # type: str
        # The globally unique identifier (GUID) of the MaxCompute project. Specify the GUID in the `odps.{projectName}` format. This parameter must be configured if you set the DataSourceType parameter to odps.
        self.page_number = page_number  # type: int
        # The ID of the E-MapReduce (EMR) cluster. This parameter must be configured if you set the DataSourceType parameter to emr.
        self.page_size = page_size  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaDBTableListRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.app_guid is not None:
            result['AppGuid'] = self.app_guid
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AppGuid') is not None:
            self.app_guid = m.get('AppGuid')
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        return self


class GetMetaDBTableListResponseBodyDataTableEntityList(TeaModel):
    def __init__(self, database_name=None, table_guid=None, table_name=None):
        self.database_name = database_name  # type: str
        self.table_guid = table_guid  # type: str
        # The name of the metadatabase.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaDBTableListResponseBodyDataTableEntityList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetMetaDBTableListResponseBodyData(TeaModel):
    def __init__(self, page_number=None, page_size=None, table_entity_list=None, total_count=None):
        # The total number of compute engine instances.
        self.page_number = page_number  # type: int
        # The list of metatables in the compute engine instance.
        self.page_size = page_size  # type: int
        # The GUID of the metatable.
        self.table_entity_list = table_entity_list  # type: list[GetMetaDBTableListResponseBodyDataTableEntityList]
        # The name of the metatable.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.table_entity_list:
            for k in self.table_entity_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMetaDBTableListResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        result['TableEntityList'] = []
        if self.table_entity_list is not None:
            for k in self.table_entity_list:
                result['TableEntityList'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        self.table_entity_list = []
        if m.get('TableEntityList') is not None:
            for k in m.get('TableEntityList'):
                temp_model = GetMetaDBTableListResponseBodyDataTableEntityList()
                self.table_entity_list.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class GetMetaDBTableListResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None):
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.data = data  # type: GetMetaDBTableListResponseBodyData
        # The page number of the returned page.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaDBTableListResponseBody, self).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=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaDBTableListResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetMetaDBTableListResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaDBTableListResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaDBTableListResponse, self).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=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 = GetMetaDBTableListResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaTableBasicInfoRequest(TeaModel):
    def __init__(self, cluster_id=None, data_source_type=None, database_name=None, extension=None, table_guid=None,
                 table_name=None):
        # The name of the metatable in the EMR cluster. This parameter is required only if you set the DataSourceType parameter to emr.
        # 
        # You can call the [GetMetaDBTableList](~~173916~~) operation to query the name of the metatable.
        self.cluster_id = cluster_id  # type: str
        # The HTTP status code returned.
        self.data_source_type = data_source_type  # type: str
        # The type of the data source. Valid values: odps and emr.
        self.database_name = database_name  # type: str
        # The error message returned.
        self.extension = extension  # type: bool
        # The name of the metadatabase. This parameter is required only if you set the DataSourceType parameter to emr.
        # 
        # You can call the [ListMetaDB](~~185662~~) operation to query the name of the metadatabase.
        self.table_guid = table_guid  # type: str
        # Specifies whether to include extended fields in query results.
        # 
        # The extended fields include ReadCount, FavoriteCount, and ViewCount.
        # 
        # This parameter takes effect only if you set the DataSourceType parameter to odps.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableBasicInfoRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.extension is not None:
            result['Extension'] = self.extension
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('Extension') is not None:
            self.extension = m.get('Extension')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetMetaTableBasicInfoResponseBodyData(TeaModel):
    def __init__(self, caption=None, cluster_id=None, column_count=None, comment=None, create_time=None,
                 data_size=None, database_name=None, env_type=None, favorite_count=None, is_partition_table=None,
                 is_view=None, is_visible=None, last_access_time=None, last_ddl_time=None, last_modify_time=None,
                 life_cycle=None, location=None, owner_id=None, partition_keys=None, project_id=None, project_name=None,
                 read_count=None, schema=None, table_guid=None, table_name=None, tenant_id=None, view_count=None):
        # The schema information of the metatable. This parameter is returned only if you enable the table schema in MaxCompute.
        self.caption = caption  # type: str
        # Indicates whether the metatable is a view. Valid values:
        # 
        # *   true: The metatable is a view.
        # *   false: The metatable is not a view.
        self.cluster_id = cluster_id  # type: str
        # The ID of the workspace.
        self.column_count = column_count  # type: int
        # The time when the metatable was created.
        self.comment = comment  # type: str
        # The ID of the metatable owner.
        self.create_time = create_time  # type: long
        # The time when the schema of the metatable was last changed.
        self.data_size = data_size  # type: long
        # The GUID of the metatable.
        self.database_name = database_name  # type: str
        # The scope in which the metatable is visible. Valid values:
        # 
        # *   0: The metatable is visible to workspace members.
        # *   1: The metatable is visible to users within the tenant.
        # *   2: The metatable is visible to all tenants.
        # *   3: The metatable is visible only to the metatable owner.
        self.env_type = env_type  # type: int
        # The number of fields.
        self.favorite_count = favorite_count  # type: long
        # The lifecycle of the metatable. Unit: days.
        self.is_partition_table = is_partition_table  # type: bool
        # The name of the workspace.
        self.is_view = is_view  # type: bool
        # The number of times the metatable was read. This parameter is returned only if you set the Extension parameter to true and takes effect only if you set the DataSourceType parameter to odps.
        self.is_visible = is_visible  # type: int
        # The time when the metatable was last updated.
        self.last_access_time = last_access_time  # type: long
        # The storage path of the Hive metadatabase.
        self.last_ddl_time = last_ddl_time  # type: long
        # The partition key of the Hive metatable.
        self.last_modify_time = last_modify_time  # type: long
        # The number of times the metatable was viewed. This parameter is returned only if you set the Extension parameter to true and takes effect only if you set the DataSourceType parameter to odps.
        self.life_cycle = life_cycle  # type: int
        # The ID of the tenant.
        self.location = location  # type: str
        # The name of the metadatabase.
        self.owner_id = owner_id  # type: str
        # The display name of the metatable.
        self.partition_keys = partition_keys  # type: str
        # The type of the environment. Valid values:
        # 
        # *   0: development environment
        # *   1: production environment
        self.project_id = project_id  # type: long
        # The time when the metatable was last accessed.
        self.project_name = project_name  # type: str
        # Indicates whether the metatable is a partitioned table. Valid values:
        # 
        # *   true: The metatable is a partitioned table.
        # *   false: The metatable is a non-partitioned table.
        self.read_count = read_count  # type: long
        self.schema = schema  # type: str
        # The ID of the EMR cluster.
        self.table_guid = table_guid  # type: str
        # The comment of the metatable.
        self.table_name = table_name  # type: str
        self.tenant_id = tenant_id  # type: long
        # The size of storage space that is occupied by the metatable. Unit: bytes.
        self.view_count = view_count  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableBasicInfoResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.caption is not None:
            result['Caption'] = self.caption
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.column_count is not None:
            result['ColumnCount'] = self.column_count
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.data_size is not None:
            result['DataSize'] = self.data_size
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.favorite_count is not None:
            result['FavoriteCount'] = self.favorite_count
        if self.is_partition_table is not None:
            result['IsPartitionTable'] = self.is_partition_table
        if self.is_view is not None:
            result['IsView'] = self.is_view
        if self.is_visible is not None:
            result['IsVisible'] = self.is_visible
        if self.last_access_time is not None:
            result['LastAccessTime'] = self.last_access_time
        if self.last_ddl_time is not None:
            result['LastDdlTime'] = self.last_ddl_time
        if self.last_modify_time is not None:
            result['LastModifyTime'] = self.last_modify_time
        if self.life_cycle is not None:
            result['LifeCycle'] = self.life_cycle
        if self.location is not None:
            result['Location'] = self.location
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.partition_keys is not None:
            result['PartitionKeys'] = self.partition_keys
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.read_count is not None:
            result['ReadCount'] = self.read_count
        if self.schema is not None:
            result['Schema'] = self.schema
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.view_count is not None:
            result['ViewCount'] = self.view_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Caption') is not None:
            self.caption = m.get('Caption')
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('ColumnCount') is not None:
            self.column_count = m.get('ColumnCount')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('DataSize') is not None:
            self.data_size = m.get('DataSize')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('FavoriteCount') is not None:
            self.favorite_count = m.get('FavoriteCount')
        if m.get('IsPartitionTable') is not None:
            self.is_partition_table = m.get('IsPartitionTable')
        if m.get('IsView') is not None:
            self.is_view = m.get('IsView')
        if m.get('IsVisible') is not None:
            self.is_visible = m.get('IsVisible')
        if m.get('LastAccessTime') is not None:
            self.last_access_time = m.get('LastAccessTime')
        if m.get('LastDdlTime') is not None:
            self.last_ddl_time = m.get('LastDdlTime')
        if m.get('LastModifyTime') is not None:
            self.last_modify_time = m.get('LastModifyTime')
        if m.get('LifeCycle') is not None:
            self.life_cycle = m.get('LifeCycle')
        if m.get('Location') is not None:
            self.location = m.get('Location')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('PartitionKeys') is not None:
            self.partition_keys = m.get('PartitionKeys')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('ReadCount') is not None:
            self.read_count = m.get('ReadCount')
        if m.get('Schema') is not None:
            self.schema = m.get('Schema')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('ViewCount') is not None:
            self.view_count = m.get('ViewCount')
        return self


class GetMetaTableBasicInfoResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The number of times the metatable was added to a favorite list. This parameter is returned only if you set the Extension parameter to true and takes effect only if you set the DataSourceType parameter to odps.
        self.data = data  # type: GetMetaTableBasicInfoResponseBodyData
        # The name of the metatable.
        self.error_code = error_code  # type: str
        # Indicates whether the request was successful.
        self.error_message = error_message  # type: str
        # The ID of the request.
        self.http_status_code = http_status_code  # type: int
        # The error code returned.
        self.request_id = request_id  # type: str
        # The business data returned.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaTableBasicInfoResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaTableBasicInfoResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaTableBasicInfoResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaTableBasicInfoResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaTableBasicInfoResponse, self).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=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 = GetMetaTableBasicInfoResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaTableChangeLogRequest(TeaModel):
    def __init__(self, change_type=None, end_date=None, object_type=None, page_number=None, page_size=None,
                 start_date=None, table_guid=None):
        # The beginning of the time range to query. Specify the time in the yyyy-MM-dd HH:mm:ss format.
        # 
        # *   By default, the system uses the current time as the value of this parameter if the time that you specify is invalid.
        # *   If both the values of the StartDate and EndDate parameters are invalid, the system automatically queries the change logs that are generated within the last 30 days.
        self.change_type = change_type  # type: str
        # The error message returned.
        self.end_date = end_date  # type: str
        # The end of the time range to query. Specify the time in the yyyy-MM-dd HH:mm:ss format.
        # 
        # *   By default, the system uses the current time as the value of this parameter if the time that you specify is invalid.
        # *   If both the values of the StartDate and EndDate parameters are invalid, the system automatically queries the change logs that are generated within the last 30 days.
        self.object_type = object_type  # type: str
        # The globally unique identifier (GUID) of the table. Specify the GUID in the format of odps.projectName.tableName. You can call the [GetMetaDBTableList](~~173916~~) operation to query the GUID of the table.
        # 
        # >  To query the change logs of a MaxCompute table, you must call the [GetMetaTableChangeLog](~~173925~~) operation.
        self.page_number = page_number  # type: int
        # The type of the change. Valid values: CREATE_TABLE, ALTER_TABLE, DROP_TABLE, ADD_PARTITION, and DROP_PARTITION.
        self.page_size = page_size  # type: int
        # The HTTP status code returned.
        self.start_date = start_date  # type: str
        # The entity on which the change is made. Valid values: TABLE and PARTITION.
        self.table_guid = table_guid  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableChangeLogRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.change_type is not None:
            result['ChangeType'] = self.change_type
        if self.end_date is not None:
            result['EndDate'] = self.end_date
        if self.object_type is not None:
            result['ObjectType'] = self.object_type
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.start_date is not None:
            result['StartDate'] = self.start_date
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ChangeType') is not None:
            self.change_type = m.get('ChangeType')
        if m.get('EndDate') is not None:
            self.end_date = m.get('EndDate')
        if m.get('ObjectType') is not None:
            self.object_type = m.get('ObjectType')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('StartDate') is not None:
            self.start_date = m.get('StartDate')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        return self


class GetMetaTableChangeLogResponseBodyDataDataEntityList(TeaModel):
    def __init__(self, change_content=None, change_type=None, create_time=None, modified_time=None,
                 object_type=None, operator=None):
        # The type of the change.
        self.change_content = change_content  # type: str
        self.change_type = change_type  # type: str
        # The name of the operator.
        self.create_time = create_time  # type: long
        # The content of the change.
        self.modified_time = modified_time  # type: long
        # The time when the metatable was created.
        self.object_type = object_type  # type: str
        self.operator = operator  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableChangeLogResponseBodyDataDataEntityList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.change_content is not None:
            result['ChangeContent'] = self.change_content
        if self.change_type is not None:
            result['ChangeType'] = self.change_type
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.object_type is not None:
            result['ObjectType'] = self.object_type
        if self.operator is not None:
            result['Operator'] = self.operator
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ChangeContent') is not None:
            self.change_content = m.get('ChangeContent')
        if m.get('ChangeType') is not None:
            self.change_type = m.get('ChangeType')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('ObjectType') is not None:
            self.object_type = m.get('ObjectType')
        if m.get('Operator') is not None:
            self.operator = m.get('Operator')
        return self


class GetMetaTableChangeLogResponseBodyData(TeaModel):
    def __init__(self, data_entity_list=None, page_number=None, page_size=None, total_count=None):
        # The last time when the metatable was modified.
        self.data_entity_list = data_entity_list  # type: list[GetMetaTableChangeLogResponseBodyDataDataEntityList]
        # The total number of returned entries.
        self.page_number = page_number  # type: int
        # The information about the change logs of the metatable.
        self.page_size = page_size  # type: int
        # The entity on which the change was made. Valid values: TABLE and PARTITION.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.data_entity_list:
            for k in self.data_entity_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMetaTableChangeLogResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DataEntityList'] = []
        if self.data_entity_list is not None:
            for k in self.data_entity_list:
                result['DataEntityList'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data_entity_list = []
        if m.get('DataEntityList') is not None:
            for k in m.get('DataEntityList'):
                temp_model = GetMetaTableChangeLogResponseBodyDataDataEntityList()
                self.data_entity_list.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class GetMetaTableChangeLogResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.data = data  # type: GetMetaTableChangeLogResponseBodyData
        # The page number of the returned page.
        self.error_code = error_code  # type: str
        # Indicates whether the request is successful.
        self.error_message = error_message  # type: str
        # The ID of the request.
        self.http_status_code = http_status_code  # type: int
        # The error code returned.
        self.request_id = request_id  # type: str
        # The business data returned.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaTableChangeLogResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaTableChangeLogResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaTableChangeLogResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaTableChangeLogResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaTableChangeLogResponse, self).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=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 = GetMetaTableChangeLogResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaTableColumnRequest(TeaModel):
    def __init__(self, cluster_id=None, data_source_type=None, database_name=None, page_num=None, page_size=None,
                 table_guid=None, table_name=None):
        # The name of the metatable in the EMR cluster. You can call the [GetMetaDBTableList](~~173916~~) operation to query the name.
        self.cluster_id = cluster_id  # type: str
        # The error message.
        self.data_source_type = data_source_type  # type: str
        # The type of the data source. Only emr is supported.
        self.database_name = database_name  # type: str
        # The ID of the E-MapReduce (EMR) cluster. You can log on to the EMR console to obtain the ID.
        self.page_num = page_num  # type: int
        # The name of the metadatabase of the EMR cluster. You can call the [ListMetaDB](~~185662~~) operation to query the name.
        self.page_size = page_size  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.table_guid = table_guid  # type: str
        # The HTTP status code.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableColumnRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.page_num is not None:
            result['PageNum'] = self.page_num
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('PageNum') is not None:
            self.page_num = m.get('PageNum')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetMetaTableColumnResponseBodyDataColumnList(TeaModel):
    def __init__(self, caption=None, column_guid=None, column_name=None, column_type=None, comment=None,
                 is_foreign_key=None, is_partition_column=None, is_primary_key=None, position=None, relation_count=None):
        # The number of times the field is read.
        self.caption = caption  # type: str
        # Indicates whether the field is a partition field. Valid values:
        # 
        # *   true: The field is a partition field.
        # *   false: The field is not a partition field.
        self.column_guid = column_guid  # type: str
        # The remarks of the field.
        self.column_name = column_name  # type: str
        # The ordinal number of the field.
        self.column_type = column_type  # type: str
        # Indicates whether the field is the primary key. Valid values:
        # 
        # *   true: The field is the primary key.
        # *   false: The field is not the primary key.
        self.comment = comment  # type: str
        self.is_foreign_key = is_foreign_key  # type: bool
        # The data type of the field.
        self.is_partition_column = is_partition_column  # type: bool
        # The description of the field.
        self.is_primary_key = is_primary_key  # type: bool
        # Indicates whether the field is a foreign key. Valid values:
        # 
        # *   true: The field is a foreign key.
        # *   false: The field is not a foreign key.
        self.position = position  # type: int
        self.relation_count = relation_count  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableColumnResponseBodyDataColumnList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.caption is not None:
            result['Caption'] = self.caption
        if self.column_guid is not None:
            result['ColumnGuid'] = self.column_guid
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.column_type is not None:
            result['ColumnType'] = self.column_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.is_foreign_key is not None:
            result['IsForeignKey'] = self.is_foreign_key
        if self.is_partition_column is not None:
            result['IsPartitionColumn'] = self.is_partition_column
        if self.is_primary_key is not None:
            result['IsPrimaryKey'] = self.is_primary_key
        if self.position is not None:
            result['Position'] = self.position
        if self.relation_count is not None:
            result['RelationCount'] = self.relation_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Caption') is not None:
            self.caption = m.get('Caption')
        if m.get('ColumnGuid') is not None:
            self.column_guid = m.get('ColumnGuid')
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('ColumnType') is not None:
            self.column_type = m.get('ColumnType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('IsForeignKey') is not None:
            self.is_foreign_key = m.get('IsForeignKey')
        if m.get('IsPartitionColumn') is not None:
            self.is_partition_column = m.get('IsPartitionColumn')
        if m.get('IsPrimaryKey') is not None:
            self.is_primary_key = m.get('IsPrimaryKey')
        if m.get('Position') is not None:
            self.position = m.get('Position')
        if m.get('RelationCount') is not None:
            self.relation_count = m.get('RelationCount')
        return self


class GetMetaTableColumnResponseBodyData(TeaModel):
    def __init__(self, column_list=None, page_num=None, page_size=None, total_count=None):
        # The name of the field.
        self.column_list = column_list  # type: list[GetMetaTableColumnResponseBodyDataColumnList]
        # The total number of fields.
        self.page_num = page_num  # type: int
        # The information of fields.
        self.page_size = page_size  # type: int
        # The GUID of the field.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.column_list:
            for k in self.column_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMetaTableColumnResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ColumnList'] = []
        if self.column_list is not None:
            for k in self.column_list:
                result['ColumnList'].append(k.to_map() if k else None)
        if self.page_num is not None:
            result['PageNum'] = self.page_num
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.column_list = []
        if m.get('ColumnList') is not None:
            for k in m.get('ColumnList'):
                temp_model = GetMetaTableColumnResponseBodyDataColumnList()
                self.column_list.append(temp_model.from_map(k))
        if m.get('PageNum') is not None:
            self.page_num = m.get('PageNum')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class GetMetaTableColumnResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.data = data  # type: GetMetaTableColumnResponseBodyData
        # The page number of the returned page.
        self.error_code = error_code  # type: str
        # Indicates whether the request is successful.
        self.error_message = error_message  # type: str
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.http_status_code = http_status_code  # type: int
        # The error code.
        self.request_id = request_id  # type: str
        # The business data.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaTableColumnResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaTableColumnResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaTableColumnResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaTableColumnResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaTableColumnResponse, self).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=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 = GetMetaTableColumnResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaTableFullInfoRequest(TeaModel):
    def __init__(self, cluster_id=None, data_source_type=None, database_name=None, page_num=None, page_size=None,
                 table_guid=None, table_name=None):
        # The ID of the E-MapReduce (EMR) cluster. You can log on to the EMR console to obtain the ID of the cluster.
        self.cluster_id = cluster_id  # type: str
        # The type of the data source. Only emr is supported.
        self.data_source_type = data_source_type  # type: str
        # The name of the metadatabase of the EMR cluster. You can call the [ListMetaDB](~~185662~~) operation to query the name of the metadatabase.
        self.database_name = database_name  # type: str
        # The number of the page to return.
        self.page_num = page_num  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The GUID of the metatable. You can call the [GetMetaDBTableList](~~173916~~) operation to query the GUID of the metatable.
        self.table_guid = table_guid  # type: str
        # The name of the metatable in the EMR cluster. You can call the [GetMetaDBTableList](~~173916~~) operation to query the name of the metatable.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableFullInfoRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.page_num is not None:
            result['PageNum'] = self.page_num
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('PageNum') is not None:
            self.page_num = m.get('PageNum')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetMetaTableFullInfoResponseBodyDataColumnList(TeaModel):
    def __init__(self, caption=None, column_guid=None, column_name=None, column_type=None, comment=None,
                 is_foreign_key=None, is_partition_column=None, is_primary_key=None, position=None):
        # The description of the field.
        self.caption = caption  # type: str
        # The GUID of the field.
        self.column_guid = column_guid  # type: str
        # The name of the field.
        self.column_name = column_name  # type: str
        # The data type of the field.
        self.column_type = column_type  # type: str
        # The remarks of the field.
        self.comment = comment  # type: str
        # Indicates whether the field is a foreign key. Valid values:
        # 
        # *   true: The field is a foreign key.
        # *   false: The field is not a foreign key.
        self.is_foreign_key = is_foreign_key  # type: bool
        # Indicates whether the field is a partition field. Valid values:
        # 
        # *   true: The field is a partition field.
        # *   false: The field is not a partition field.
        self.is_partition_column = is_partition_column  # type: bool
        # Indicates whether the field is the primary key. Valid values:
        # 
        # *   true: The field is the primary key.
        # *   false: The field is not the primary key.
        self.is_primary_key = is_primary_key  # type: bool
        # The ordinal number of the field.
        self.position = position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableFullInfoResponseBodyDataColumnList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.caption is not None:
            result['Caption'] = self.caption
        if self.column_guid is not None:
            result['ColumnGuid'] = self.column_guid
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.column_type is not None:
            result['ColumnType'] = self.column_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.is_foreign_key is not None:
            result['IsForeignKey'] = self.is_foreign_key
        if self.is_partition_column is not None:
            result['IsPartitionColumn'] = self.is_partition_column
        if self.is_primary_key is not None:
            result['IsPrimaryKey'] = self.is_primary_key
        if self.position is not None:
            result['Position'] = self.position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Caption') is not None:
            self.caption = m.get('Caption')
        if m.get('ColumnGuid') is not None:
            self.column_guid = m.get('ColumnGuid')
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('ColumnType') is not None:
            self.column_type = m.get('ColumnType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('IsForeignKey') is not None:
            self.is_foreign_key = m.get('IsForeignKey')
        if m.get('IsPartitionColumn') is not None:
            self.is_partition_column = m.get('IsPartitionColumn')
        if m.get('IsPrimaryKey') is not None:
            self.is_primary_key = m.get('IsPrimaryKey')
        if m.get('Position') is not None:
            self.position = m.get('Position')
        return self


class GetMetaTableFullInfoResponseBodyData(TeaModel):
    def __init__(self, cluster_id=None, column_list=None, comment=None, create_time=None, data_size=None,
                 database_name=None, env_type=None, is_visible=None, last_access_time=None, last_ddl_time=None,
                 last_modify_time=None, life_cycle=None, location=None, owner_id=None, partition_keys=None, project_id=None,
                 project_name=None, schema=None, table_guid=None, table_name=None, tenant_id=None, total_column_count=None):
        # The ID of the EMR cluster.
        self.cluster_id = cluster_id  # type: str
        # The fields in the metatable.
        self.column_list = column_list  # type: list[GetMetaTableFullInfoResponseBodyDataColumnList]
        # The remarks of the metatable.
        self.comment = comment  # type: str
        # The time when the metatable was created. You can convert the timestamp to the related date based on the time zone that you use.
        self.create_time = create_time  # type: long
        # The amount of storage resources that are consumed by the metatable. Unit: bytes.
        self.data_size = data_size  # type: long
        # The name of the database.
        self.database_name = database_name  # type: str
        # The type of the environment in which the metatable resides. Valid values:
        # 
        # *   0: indicates that the metatable resides in the development environment.
        # *   1: indicates that the metatable resides in the production environment.
        self.env_type = env_type  # type: int
        # The scope in which the metatable is visible. Valid values:
        # 
        # *   0: indicates that the metatable is visible to workspace members.
        # *   1: indicates that the metatable is visible to users within a tenant.
        # *   2: indicates that the metatable is visible to all tenants.
        # *   3: indicates that the metatable is visible only to the metatable owner.
        self.is_visible = is_visible  # type: int
        # The time when the metatable was last accessed. You can convert the timestamp to the related date based on the time zone that you use.
        self.last_access_time = last_access_time  # type: long
        # The time when the schema of the metatable was last changed. You can convert the timestamp to the related date based on the time zone that you use.
        self.last_ddl_time = last_ddl_time  # type: long
        # The time when the metatable was last updated. You can convert the timestamp to the related date based on the time zone that you use.
        self.last_modify_time = last_modify_time  # type: long
        # The lifecycle of the metatable. Unit: days.
        self.life_cycle = life_cycle  # type: int
        # The storage path of the Hive metatable.
        self.location = location  # type: str
        # The ID of the metatable owner.
        self.owner_id = owner_id  # type: str
        # The partition key.
        self.partition_keys = partition_keys  # type: str
        # The ID of the workspace to which the metatable belongs.
        self.project_id = project_id  # type: long
        # The name of the workspace to which the metatable belongs.
        self.project_name = project_name  # type: str
        self.schema = schema  # type: str
        # The GUID of the metatable.
        self.table_guid = table_guid  # type: str
        # The name of the metatable.
        self.table_name = table_name  # type: str
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long
        # The total number of fields.
        self.total_column_count = total_column_count  # type: long

    def validate(self):
        if self.column_list:
            for k in self.column_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMetaTableFullInfoResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        result['ColumnList'] = []
        if self.column_list is not None:
            for k in self.column_list:
                result['ColumnList'].append(k.to_map() if k else None)
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.data_size is not None:
            result['DataSize'] = self.data_size
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.is_visible is not None:
            result['IsVisible'] = self.is_visible
        if self.last_access_time is not None:
            result['LastAccessTime'] = self.last_access_time
        if self.last_ddl_time is not None:
            result['LastDdlTime'] = self.last_ddl_time
        if self.last_modify_time is not None:
            result['LastModifyTime'] = self.last_modify_time
        if self.life_cycle is not None:
            result['LifeCycle'] = self.life_cycle
        if self.location is not None:
            result['Location'] = self.location
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.partition_keys is not None:
            result['PartitionKeys'] = self.partition_keys
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.schema is not None:
            result['Schema'] = self.schema
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.total_column_count is not None:
            result['TotalColumnCount'] = self.total_column_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        self.column_list = []
        if m.get('ColumnList') is not None:
            for k in m.get('ColumnList'):
                temp_model = GetMetaTableFullInfoResponseBodyDataColumnList()
                self.column_list.append(temp_model.from_map(k))
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('DataSize') is not None:
            self.data_size = m.get('DataSize')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('IsVisible') is not None:
            self.is_visible = m.get('IsVisible')
        if m.get('LastAccessTime') is not None:
            self.last_access_time = m.get('LastAccessTime')
        if m.get('LastDdlTime') is not None:
            self.last_ddl_time = m.get('LastDdlTime')
        if m.get('LastModifyTime') is not None:
            self.last_modify_time = m.get('LastModifyTime')
        if m.get('LifeCycle') is not None:
            self.life_cycle = m.get('LifeCycle')
        if m.get('Location') is not None:
            self.location = m.get('Location')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('PartitionKeys') is not None:
            self.partition_keys = m.get('PartitionKeys')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('Schema') is not None:
            self.schema = m.get('Schema')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('TotalColumnCount') is not None:
            self.total_column_count = m.get('TotalColumnCount')
        return self


class GetMetaTableFullInfoResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The business data returned.
        self.data = data  # type: GetMetaTableFullInfoResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaTableFullInfoResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaTableFullInfoResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaTableFullInfoResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaTableFullInfoResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaTableFullInfoResponse, self).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=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 = GetMetaTableFullInfoResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaTableIntroWikiRequest(TeaModel):
    def __init__(self, table_guid=None, wiki_version=None):
        # The GUID of the metatable.
        self.table_guid = table_guid  # type: str
        # The version of the instructions.
        self.wiki_version = wiki_version  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableIntroWikiRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.wiki_version is not None:
            result['WikiVersion'] = self.wiki_version
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('WikiVersion') is not None:
            self.wiki_version = m.get('WikiVersion')
        return self


class GetMetaTableIntroWikiResponseBodyData(TeaModel):
    def __init__(self, content=None, create_time=None, creator=None, creator_name=None, modified_time=None,
                 version=None):
        # The description of the metatable.
        self.content = content  # type: str
        # The time when the metatable was created.
        self.create_time = create_time  # type: long
        # The creator of the metatable.
        self.creator = creator  # type: str
        # The name of the user who created the metatable.
        self.creator_name = creator_name  # type: str
        # The time when the metatable was modified.
        self.modified_time = modified_time  # type: long
        # The version number.
        self.version = version  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableIntroWikiResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.creator is not None:
            result['Creator'] = self.creator
        if self.creator_name is not None:
            result['CreatorName'] = self.creator_name
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.version is not None:
            result['Version'] = self.version
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('Creator') is not None:
            self.creator = m.get('Creator')
        if m.get('CreatorName') is not None:
            self.creator_name = m.get('CreatorName')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('Version') is not None:
            self.version = m.get('Version')
        return self


class GetMetaTableIntroWikiResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The business data returned.
        self.data = data  # type: GetMetaTableIntroWikiResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaTableIntroWikiResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaTableIntroWikiResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaTableIntroWikiResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaTableIntroWikiResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaTableIntroWikiResponse, self).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=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 = GetMetaTableIntroWikiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaTableLineageRequest(TeaModel):
    def __init__(self, cluster_id=None, data_source_type=None, database_name=None, direction=None,
                 next_primary_key=None, page_size=None, table_guid=None, table_name=None):
        # The name of the metatable.
        self.cluster_id = cluster_id  # type: str
        # The error message.
        self.data_source_type = data_source_type  # type: str
        # The type of the data source. Valid values: odps and emr.
        self.database_name = database_name  # type: str
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.direction = direction  # type: str
        # The ID of the E-MapReduce (EMR) cluster. Set this parameter only when you query data in an EMR compute engine instance.
        self.next_primary_key = next_primary_key  # type: str
        # The name of the metadatabase.
        self.page_size = page_size  # type: int
        # The logic of paging. Set this parameter based on the value of the response parameter NextPrimaryKey when the value of the response parameter HasNext is true in the last query.
        self.table_guid = table_guid  # type: str
        # The HTTP status code.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableLineageRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.direction is not None:
            result['Direction'] = self.direction
        if self.next_primary_key is not None:
            result['NextPrimaryKey'] = self.next_primary_key
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('Direction') is not None:
            self.direction = m.get('Direction')
        if m.get('NextPrimaryKey') is not None:
            self.next_primary_key = m.get('NextPrimaryKey')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetMetaTableLineageResponseBodyDataDataEntityList(TeaModel):
    def __init__(self, create_timestamp=None, database_name=None, table_guid=None, table_name=None):
        self.create_timestamp = create_timestamp  # type: long
        self.database_name = database_name  # type: str
        self.table_guid = table_guid  # type: str
        # The time when the metatable was created.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableLineageResponseBodyDataDataEntityList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.create_timestamp is not None:
            result['CreateTimestamp'] = self.create_timestamp
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreateTimestamp') is not None:
            self.create_timestamp = m.get('CreateTimestamp')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetMetaTableLineageResponseBodyData(TeaModel):
    def __init__(self, data_entity_list=None, has_next=None, next_primary_key=None):
        # The GUID of the metatable.
        self.data_entity_list = data_entity_list  # type: list[GetMetaTableLineageResponseBodyDataDataEntityList]
        # The name of the metatable.
        self.has_next = has_next  # type: bool
        # The information about the metatable.
        self.next_primary_key = next_primary_key  # type: str

    def validate(self):
        if self.data_entity_list:
            for k in self.data_entity_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMetaTableLineageResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DataEntityList'] = []
        if self.data_entity_list is not None:
            for k in self.data_entity_list:
                result['DataEntityList'].append(k.to_map() if k else None)
        if self.has_next is not None:
            result['HasNext'] = self.has_next
        if self.next_primary_key is not None:
            result['NextPrimaryKey'] = self.next_primary_key
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data_entity_list = []
        if m.get('DataEntityList') is not None:
            for k in m.get('DataEntityList'):
                temp_model = GetMetaTableLineageResponseBodyDataDataEntityList()
                self.data_entity_list.append(temp_model.from_map(k))
        if m.get('HasNext') is not None:
            self.has_next = m.get('HasNext')
        if m.get('NextPrimaryKey') is not None:
            self.next_primary_key = m.get('NextPrimaryKey')
        return self


class GetMetaTableLineageResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the next page has more query results.
        self.data = data  # type: GetMetaTableLineageResponseBodyData
        # The paging information.
        self.error_code = error_code  # type: str
        # Indicates whether the request is successful.
        self.error_message = error_message  # type: str
        # The ID of the request.
        self.http_status_code = http_status_code  # type: int
        # The error code.
        self.request_id = request_id  # type: str
        # The business data.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaTableLineageResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaTableLineageResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaTableLineageResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaTableLineageResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaTableLineageResponse, self).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=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 = GetMetaTableLineageResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaTableListByCategoryRequest(TeaModel):
    def __init__(self, category_id=None, page_number=None, page_size=None):
        self.category_id = category_id  # type: long
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableListByCategoryRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.category_id is not None:
            result['CategoryId'] = self.category_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CategoryId') is not None:
            self.category_id = m.get('CategoryId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        return self


class GetMetaTableListByCategoryResponseBodyData(TeaModel):
    def __init__(self, page_number=None, page_size=None, table_guid_list=None, total_count=None):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.table_guid_list = table_guid_list  # type: list[str]
        self.total_count = total_count  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableListByCategoryResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.table_guid_list is not None:
            result['TableGuidList'] = self.table_guid_list
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TableGuidList') is not None:
            self.table_guid_list = m.get('TableGuidList')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class GetMetaTableListByCategoryResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: GetMetaTableListByCategoryResponseBodyData
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaTableListByCategoryResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaTableListByCategoryResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaTableListByCategoryResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaTableListByCategoryResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaTableListByCategoryResponse, self).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=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 = GetMetaTableListByCategoryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaTableOutputRequest(TeaModel):
    def __init__(self, end_date=None, page_number=None, page_size=None, start_date=None, table_guid=None,
                 task_id=None):
        # The HTTP status code returned.
        self.end_date = end_date  # type: str
        # The Globally Unique Identifier (GUID) of the MaxCompute metatable.
        self.page_number = page_number  # type: int
        # The start date of the time range to query. The start date must be within the previous 30 days.
        self.page_size = page_size  # type: int
        # The ID of the node.
        self.start_date = start_date  # type: str
        # The end date of the time range to query. The end date must be within the previous 30 days.
        self.table_guid = table_guid  # type: str
        # The error message returned.
        self.task_id = task_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableOutputRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.end_date is not None:
            result['EndDate'] = self.end_date
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.start_date is not None:
            result['StartDate'] = self.start_date
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EndDate') is not None:
            self.end_date = m.get('EndDate')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('StartDate') is not None:
            self.start_date = m.get('StartDate')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        return self


class GetMetaTableOutputResponseBodyDataDataEntityList(TeaModel):
    def __init__(self, end_time=None, project_id=None, start_time=None, table_guid=None, task_id=None,
                 task_instance_id=None, wait_time=None):
        # The start time of the node.
        self.end_time = end_time  # type: str
        # The GUID of the MaxCompute metatable.
        self.project_id = project_id  # type: long
        # The duration during which the node waits to start.
        self.start_time = start_time  # type: str
        self.table_guid = table_guid  # type: str
        self.task_id = task_id  # type: str
        # The ID of the workspace.
        self.task_instance_id = task_instance_id  # type: long
        # The ID of the node.
        self.wait_time = wait_time  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableOutputResponseBodyDataDataEntityList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.start_time is not None:
            result['StartTime'] = self.start_time
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        if self.task_instance_id is not None:
            result['TaskInstanceId'] = self.task_instance_id
        if self.wait_time is not None:
            result['WaitTime'] = self.wait_time
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('StartTime') is not None:
            self.start_time = m.get('StartTime')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        if m.get('TaskInstanceId') is not None:
            self.task_instance_id = m.get('TaskInstanceId')
        if m.get('WaitTime') is not None:
            self.wait_time = m.get('WaitTime')
        return self


class GetMetaTableOutputResponseBodyData(TeaModel):
    def __init__(self, data_entity_list=None, page_number=None, page_size=None, total_count=None):
        # The ID of the instance.
        self.data_entity_list = data_entity_list  # type: list[GetMetaTableOutputResponseBodyDataDataEntityList]
        # The total number of entries returned.
        self.page_number = page_number  # type: int
        # The information of the node and instance.
        self.page_size = page_size  # type: int
        # The end time of the node.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.data_entity_list:
            for k in self.data_entity_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMetaTableOutputResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DataEntityList'] = []
        if self.data_entity_list is not None:
            for k in self.data_entity_list:
                result['DataEntityList'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data_entity_list = []
        if m.get('DataEntityList') is not None:
            for k in m.get('DataEntityList'):
                temp_model = GetMetaTableOutputResponseBodyDataDataEntityList()
                self.data_entity_list.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class GetMetaTableOutputResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The number of entries returned per page.
        self.data = data  # type: GetMetaTableOutputResponseBodyData
        # The page number of the returned page.
        self.error_code = error_code  # type: str
        # Indicates whether the request was successful.
        self.error_message = error_message  # type: str
        # The ID of the request.
        self.http_status_code = http_status_code  # type: int
        # The error code returned.
        self.request_id = request_id  # type: str
        # The output node and instance.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaTableOutputResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaTableOutputResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaTableOutputResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaTableOutputResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaTableOutputResponse, self).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=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 = GetMetaTableOutputResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaTablePartitionRequestSortCriterion(TeaModel):
    def __init__(self, order=None, sort_field=None):
        # The error message returned.
        self.order = order  # type: str
        # The HTTP status code returned.
        self.sort_field = sort_field  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTablePartitionRequestSortCriterion, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.order is not None:
            result['Order'] = self.order
        if self.sort_field is not None:
            result['SortField'] = self.sort_field
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Order') is not None:
            self.order = m.get('Order')
        if m.get('SortField') is not None:
            self.sort_field = m.get('SortField')
        return self


class GetMetaTablePartitionRequest(TeaModel):
    def __init__(self, cluster_id=None, data_source_type=None, database_name=None, page_number=None, page_size=None,
                 sort_criterion=None, table_guid=None, table_name=None):
        # The name of the metatable in the EMR cluster. This parameter is required only if you set the DataSourceType parameter to emr.
        # 
        # You can call the [GetMetaDBTableList](~~173916~~) operation to query the name of the metatable.
        self.cluster_id = cluster_id  # type: str
        # The field that is used to sort partitions in the metatable. Valid values: name and modify_time.
        # 
        # By default, partitions in the metatable are sorted based on their creation time.
        self.data_source_type = data_source_type  # type: str
        # The type of the data source. Valid values: odps and emr.
        self.database_name = database_name  # type: str
        # The GUID of the metatable.
        self.page_number = page_number  # type: int
        # The ID of the EMR cluster. This parameter is required only if you set the DataSourceType parameter to emr.
        # 
        # You can log on to the [EMR console](https://emr.console.aliyun.com/?spm=a2c4g.11186623.0.0.965cc5c2GeiHet#/cn-hangzhou) to obtain the ID of the EMR cluster.
        self.page_size = page_size  # type: int
        # The order in which partitions in the metatable are sorted. Valid values: asc and desc. Default value: desc.
        self.sort_criterion = sort_criterion  # type: GetMetaTablePartitionRequestSortCriterion
        # The name of the metadatabase. This parameter is required only if you set the DataSourceType parameter to emr.
        # 
        # You can call the [ListMetaDB](~~185662~~) operation to query the name of the metadatabase.
        self.table_guid = table_guid  # type: str
        # The logic for sorting partitions in the metatable.
        self.table_name = table_name  # type: str

    def validate(self):
        if self.sort_criterion:
            self.sort_criterion.validate()

    def to_map(self):
        _map = super(GetMetaTablePartitionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.sort_criterion is not None:
            result['SortCriterion'] = self.sort_criterion.to_map()
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('SortCriterion') is not None:
            temp_model = GetMetaTablePartitionRequestSortCriterion()
            self.sort_criterion = temp_model.from_map(m['SortCriterion'])
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetMetaTablePartitionShrinkRequest(TeaModel):
    def __init__(self, cluster_id=None, data_source_type=None, database_name=None, page_number=None, page_size=None,
                 sort_criterion_shrink=None, table_guid=None, table_name=None):
        # The name of the metatable in the EMR cluster. This parameter is required only if you set the DataSourceType parameter to emr.
        # 
        # You can call the [GetMetaDBTableList](~~173916~~) operation to query the name of the metatable.
        self.cluster_id = cluster_id  # type: str
        # The field that is used to sort partitions in the metatable. Valid values: name and modify_time.
        # 
        # By default, partitions in the metatable are sorted based on their creation time.
        self.data_source_type = data_source_type  # type: str
        # The type of the data source. Valid values: odps and emr.
        self.database_name = database_name  # type: str
        # The GUID of the metatable.
        self.page_number = page_number  # type: int
        # The ID of the EMR cluster. This parameter is required only if you set the DataSourceType parameter to emr.
        # 
        # You can log on to the [EMR console](https://emr.console.aliyun.com/?spm=a2c4g.11186623.0.0.965cc5c2GeiHet#/cn-hangzhou) to obtain the ID of the EMR cluster.
        self.page_size = page_size  # type: int
        # The order in which partitions in the metatable are sorted. Valid values: asc and desc. Default value: desc.
        self.sort_criterion_shrink = sort_criterion_shrink  # type: str
        # The name of the metadatabase. This parameter is required only if you set the DataSourceType parameter to emr.
        # 
        # You can call the [ListMetaDB](~~185662~~) operation to query the name of the metadatabase.
        self.table_guid = table_guid  # type: str
        # The logic for sorting partitions in the metatable.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTablePartitionShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.sort_criterion_shrink is not None:
            result['SortCriterion'] = self.sort_criterion_shrink
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('SortCriterion') is not None:
            self.sort_criterion_shrink = m.get('SortCriterion')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetMetaTablePartitionResponseBodyDataDataEntityList(TeaModel):
    def __init__(self, comment=None, create_time=None, data_size=None, modified_time=None, partition_guid=None,
                 partition_location=None, partition_name=None, partition_path=None, partition_type=None, record_count=None,
                 table_guid=None):
        # The time when the partition was created. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since the epoch time January 1, 1970, 00:00:00 UTC.
        self.comment = comment  # type: str
        # The type of the partition.
        self.create_time = create_time  # type: long
        # The comment.
        self.data_size = data_size  # type: long
        # The number of entries in the partition.
        self.modified_time = modified_time  # type: long
        # The GUID of the metatable.
        self.partition_guid = partition_guid  # type: str
        self.partition_location = partition_location  # type: str
        # The time when the partition was modified. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since the epoch time January 1, 1970, 00:00:00 UTC.
        self.partition_name = partition_name  # type: str
        # The name of the partition.
        self.partition_path = partition_path  # type: str
        # The location of the Hive partition.
        self.partition_type = partition_type  # type: str
        # The GUID of the partition.
        self.record_count = record_count  # type: long
        self.table_guid = table_guid  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTablePartitionResponseBodyDataDataEntityList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.data_size is not None:
            result['DataSize'] = self.data_size
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.partition_guid is not None:
            result['PartitionGuid'] = self.partition_guid
        if self.partition_location is not None:
            result['PartitionLocation'] = self.partition_location
        if self.partition_name is not None:
            result['PartitionName'] = self.partition_name
        if self.partition_path is not None:
            result['PartitionPath'] = self.partition_path
        if self.partition_type is not None:
            result['PartitionType'] = self.partition_type
        if self.record_count is not None:
            result['RecordCount'] = self.record_count
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('DataSize') is not None:
            self.data_size = m.get('DataSize')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('PartitionGuid') is not None:
            self.partition_guid = m.get('PartitionGuid')
        if m.get('PartitionLocation') is not None:
            self.partition_location = m.get('PartitionLocation')
        if m.get('PartitionName') is not None:
            self.partition_name = m.get('PartitionName')
        if m.get('PartitionPath') is not None:
            self.partition_path = m.get('PartitionPath')
        if m.get('PartitionType') is not None:
            self.partition_type = m.get('PartitionType')
        if m.get('RecordCount') is not None:
            self.record_count = m.get('RecordCount')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        return self


class GetMetaTablePartitionResponseBodyData(TeaModel):
    def __init__(self, data_entity_list=None, page_number=None, page_size=None, total_count=None):
        # The size of the partition. Unit: bytes.
        self.data_entity_list = data_entity_list  # type: list[GetMetaTablePartitionResponseBodyDataDataEntityList]
        # The total number of partitions.
        self.page_number = page_number  # type: int
        # The list of partitions.
        self.page_size = page_size  # type: int
        # The path of the partition.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.data_entity_list:
            for k in self.data_entity_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMetaTablePartitionResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DataEntityList'] = []
        if self.data_entity_list is not None:
            for k in self.data_entity_list:
                result['DataEntityList'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data_entity_list = []
        if m.get('DataEntityList') is not None:
            for k in m.get('DataEntityList'):
                temp_model = GetMetaTablePartitionResponseBodyDataDataEntityList()
                self.data_entity_list.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class GetMetaTablePartitionResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.data = data  # type: GetMetaTablePartitionResponseBodyData
        # The page number of the returned page.
        self.error_code = error_code  # type: str
        # Indicates whether the request was successful.
        self.error_message = error_message  # type: str
        # The ID of the request.
        self.http_status_code = http_status_code  # type: int
        # The error code returned.
        self.request_id = request_id  # type: str
        # The business data returned.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMetaTablePartitionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMetaTablePartitionResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaTablePartitionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaTablePartitionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaTablePartitionResponse, self).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=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 = GetMetaTablePartitionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaTableProducingTasksRequest(TeaModel):
    def __init__(self, cluster_id=None, data_source_type=None, db_name=None, schema_name=None, table_guid=None,
                 table_name=None):
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.db_name = db_name  # type: str
        self.schema_name = schema_name  # type: str
        self.table_guid = table_guid  # type: str
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableProducingTasksRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.db_name is not None:
            result['DbName'] = self.db_name
        if self.schema_name is not None:
            result['SchemaName'] = self.schema_name
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DbName') is not None:
            self.db_name = m.get('DbName')
        if m.get('SchemaName') is not None:
            self.schema_name = m.get('SchemaName')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetMetaTableProducingTasksResponseBodyData(TeaModel):
    def __init__(self, task_id=None, task_name=None):
        self.task_id = task_id  # type: str
        self.task_name = task_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableProducingTasksResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        if self.task_name is not None:
            result['TaskName'] = self.task_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        if m.get('TaskName') is not None:
            self.task_name = m.get('TaskName')
        return self


class GetMetaTableProducingTasksResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: list[GetMetaTableProducingTasksResponseBodyData]
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMetaTableProducingTasksResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = GetMetaTableProducingTasksResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaTableProducingTasksResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaTableProducingTasksResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaTableProducingTasksResponse, self).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=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 = GetMetaTableProducingTasksResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMetaTableThemeLevelRequest(TeaModel):
    def __init__(self, data_source_type=None, table_guid=None):
        # The type of the data source. Set the value to odps.
        self.data_source_type = data_source_type  # type: str
        # The globally unique identifier (GUID) of the table. Specify the GUID in the format of odps.${projectName}.${tableName}.
        self.table_guid = table_guid  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableThemeLevelRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        return self


class GetMetaTableThemeLevelResponseBodyEntityLevel(TeaModel):
    def __init__(self, description=None, level_id=None, name=None, type=None):
        # The description of the table level.
        self.description = description  # type: str
        # The ID of the table level.
        self.level_id = level_id  # type: long
        # The name of the table level.
        self.name = name  # type: str
        # The type of the table level. Valid values:
        # 
        # *   1: indicates the logical level.
        # *   2: indicates the physical level.
        self.type = type  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableThemeLevelResponseBodyEntityLevel, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        if self.level_id is not None:
            result['LevelId'] = self.level_id
        if self.name is not None:
            result['Name'] = self.name
        if self.type is not None:
            result['Type'] = self.type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('LevelId') is not None:
            self.level_id = m.get('LevelId')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class GetMetaTableThemeLevelResponseBodyEntityTheme(TeaModel):
    def __init__(self, level=None, name=None, parent_id=None, theme_id=None):
        # The level of the table folder. Valid values:
        # 
        # *   1: indicates a table folder of level 1.
        # *   2: indicates a table folder of level 2.
        self.level = level  # type: int
        # The name of the table folder.
        self.name = name  # type: str
        # The ID of the parent table folder.
        self.parent_id = parent_id  # type: long
        # The ID of the table folder.
        self.theme_id = theme_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMetaTableThemeLevelResponseBodyEntityTheme, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.level is not None:
            result['Level'] = self.level
        if self.name is not None:
            result['Name'] = self.name
        if self.parent_id is not None:
            result['ParentId'] = self.parent_id
        if self.theme_id is not None:
            result['ThemeId'] = self.theme_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Level') is not None:
            self.level = m.get('Level')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ParentId') is not None:
            self.parent_id = m.get('ParentId')
        if m.get('ThemeId') is not None:
            self.theme_id = m.get('ThemeId')
        return self


class GetMetaTableThemeLevelResponseBodyEntity(TeaModel):
    def __init__(self, level=None, theme=None):
        # The information about the table level.
        self.level = level  # type: list[GetMetaTableThemeLevelResponseBodyEntityLevel]
        # The information about the table folder.
        self.theme = theme  # type: list[GetMetaTableThemeLevelResponseBodyEntityTheme]

    def validate(self):
        if self.level:
            for k in self.level:
                if k:
                    k.validate()
        if self.theme:
            for k in self.theme:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMetaTableThemeLevelResponseBodyEntity, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Level'] = []
        if self.level is not None:
            for k in self.level:
                result['Level'].append(k.to_map() if k else None)
        result['Theme'] = []
        if self.theme is not None:
            for k in self.theme:
                result['Theme'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.level = []
        if m.get('Level') is not None:
            for k in m.get('Level'):
                temp_model = GetMetaTableThemeLevelResponseBodyEntityLevel()
                self.level.append(temp_model.from_map(k))
        self.theme = []
        if m.get('Theme') is not None:
            for k in m.get('Theme'):
                temp_model = GetMetaTableThemeLevelResponseBodyEntityTheme()
                self.theme.append(temp_model.from_map(k))
        return self


class GetMetaTableThemeLevelResponseBody(TeaModel):
    def __init__(self, entity=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The returned data.
        self.entity = entity  # type: GetMetaTableThemeLevelResponseBodyEntity
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can troubleshoot errors based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.entity:
            self.entity.validate()

    def to_map(self):
        _map = super(GetMetaTableThemeLevelResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.entity is not None:
            result['Entity'] = self.entity.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Entity') is not None:
            temp_model = GetMetaTableThemeLevelResponseBodyEntity()
            self.entity = temp_model.from_map(m['Entity'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMetaTableThemeLevelResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMetaTableThemeLevelResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMetaTableThemeLevelResponse, self).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=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 = GetMetaTableThemeLevelResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMigrationProcessRequest(TeaModel):
    def __init__(self, migration_id=None, project_id=None):
        # The ID of the migration package. You can call the CreateImportMigration operation to query the ID.
        self.migration_id = migration_id  # type: long
        # The ID of the workspace. You can go to the Workspace Management page of the DataWorks console to view the ID.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMigrationProcessRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.migration_id is not None:
            result['MigrationId'] = self.migration_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('MigrationId') is not None:
            self.migration_id = m.get('MigrationId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetMigrationProcessResponseBodyData(TeaModel):
    def __init__(self, task_name=None, task_status=None):
        # The name of the step in the migration task.
        self.task_name = task_name  # type: str
        # The running status of the step in the migration task. Valid values:
        # 
        # *   INT
        # *   RUNNING
        # *   FAILURE
        # *   SUCCESS
        self.task_status = task_status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMigrationProcessResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.task_name is not None:
            result['TaskName'] = self.task_name
        if self.task_status is not None:
            result['TaskStatus'] = self.task_status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TaskName') is not None:
            self.task_name = m.get('TaskName')
        if m.get('TaskStatus') is not None:
            self.task_status = m.get('TaskStatus')
        return self


class GetMigrationProcessResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The progress information of the migration task, including the names of all steps in and status of the migration task.
        self.data = data  # type: list[GetMigrationProcessResponseBodyData]
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetMigrationProcessResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = GetMigrationProcessResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMigrationProcessResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMigrationProcessResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMigrationProcessResponse, self).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=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 = GetMigrationProcessResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetMigrationSummaryRequest(TeaModel):
    def __init__(self, migration_id=None, project_id=None):
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.migration_id = migration_id  # type: long
        # The ID of the migration task.
        # 
        # You can call the [CreateImportMigration](~~2809123~~) operation to obtain the ID of the import task and call the [CreateExportMigration](~~3241603~~) operation to obtain the ID of the export task.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMigrationSummaryRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.migration_id is not None:
            result['MigrationId'] = self.migration_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('MigrationId') is not None:
            self.migration_id = m.get('MigrationId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetMigrationSummaryResponseBodyData(TeaModel):
    def __init__(self, create_user=None, download_url=None, gmt_create=None, gmt_modified=None, migration_id=None,
                 name=None, op_user=None, project_id=None, status=None):
        # The ID of the user who manages the migration task.
        self.create_user = create_user  # type: str
        self.download_url = download_url  # type: str
        # The time when the migration task was modified.
        self.gmt_create = gmt_create  # type: long
        # The ID of the user who creates the migration task.
        self.gmt_modified = gmt_modified  # type: long
        # The name of the migration task.
        self.migration_id = migration_id  # type: long
        # The time when the migration task was created.
        self.name = name  # type: str
        # The status of the migration task. Valid values:
        # 
        # *   INIT: The migration task is initiating.
        # *   EDITING: The migration task is being edited.
        # *   IMPORTING: The migration task is importing data objects.
        # *   IMPORT_ERROR: The migration task fails to import data objects.
        # *   IMPORT_SUCCESS: Data objects are imported.
        # *   EXPORTING: The migration task is exporting data objects.
        # *   EXPORT_ERROR: The migration task fails to export data objects.
        # *   EXPORT_SUCCESS: The migration task successfully exports data objects.
        # *   REVOKED: The migration task is canceled.
        # *   PARTIAL_SUCCESS: The migration task successfully imports or exports only some data objects.
        self.op_user = op_user  # type: str
        # The URL that is used to download the package of the export task.
        self.project_id = project_id  # type: long
        # The ID of the DataWorks workspace.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetMigrationSummaryResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.create_user is not None:
            result['CreateUser'] = self.create_user
        if self.download_url is not None:
            result['DownloadUrl'] = self.download_url
        if self.gmt_create is not None:
            result['GmtCreate'] = self.gmt_create
        if self.gmt_modified is not None:
            result['GmtModified'] = self.gmt_modified
        if self.migration_id is not None:
            result['MigrationId'] = self.migration_id
        if self.name is not None:
            result['Name'] = self.name
        if self.op_user is not None:
            result['OpUser'] = self.op_user
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreateUser') is not None:
            self.create_user = m.get('CreateUser')
        if m.get('DownloadUrl') is not None:
            self.download_url = m.get('DownloadUrl')
        if m.get('GmtCreate') is not None:
            self.gmt_create = m.get('GmtCreate')
        if m.get('GmtModified') is not None:
            self.gmt_modified = m.get('GmtModified')
        if m.get('MigrationId') is not None:
            self.migration_id = m.get('MigrationId')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('OpUser') is not None:
            self.op_user = m.get('OpUser')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetMigrationSummaryResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # The ID of the migration task.
        self.data = data  # type: GetMigrationSummaryResponseBodyData
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails. You can locate the error based on the request ID.
        self.request_id = request_id  # type: str
        # The details of the migration task.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetMigrationSummaryResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetMigrationSummaryResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetMigrationSummaryResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetMigrationSummaryResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetMigrationSummaryResponse, self).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=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 = GetMigrationSummaryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetNodeRequest(TeaModel):
    def __init__(self, node_id=None, project_env=None):
        # The interval at which the node is rerun after the node fails to run.
        self.node_id = node_id  # type: long
        # The priority of the node. Valid values: 1, 3, 5, 7, and 8.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class GetNodeResponseBodyData(TeaModel):
    def __init__(self, baseline_id=None, business_id=None, connection=None, cron_express=None, description=None,
                 dqc_description=None, dqc_type=None, file_type=None, node_id=None, node_name=None, owner_id=None, param_values=None,
                 priority=None, program_type=None, project_id=None, related_flow_id=None, repeat_interval=None,
                 repeatability=None, res_group_identifier=None, res_group_name=None, scheduler_type=None):
        # The description of the node.
        self.baseline_id = baseline_id  # type: long
        # The operation that you want to perform. Set the value to **GetNode**.
        self.business_id = business_id  # type: long
        # The environment of the workspace. Valid values: PROD and DEV.
        self.connection = connection  # type: str
        # The environment of the workspace. Valid values: PROD and DEV.
        self.cron_express = cron_express  # type: str
        # The name of the resource group.
        self.description = description  # type: str
        # The ID of the node. You can call the [ListNodes](~~173979~~) operation to query the node ID.
        self.dqc_description = dqc_description  # type: str
        # The error message returned.
        self.dqc_type = dqc_type  # type: int
        self.file_type = file_type  # type: int
        # The HTTP status code returned.
        self.node_id = node_id  # type: long
        # The scheduling type of the node. Valid values:
        # 
        # *   NORMAL: The node is an auto triggered node.
        # *   MANUAL: The node is a manually triggered node. Manually triggered nodes cannot be automatically triggered.
        # *   PAUSE: The node is a paused node.
        # *   SKIP: The node is a dry-run node. Dry-run nodes are started as scheduled but the system sets the status of the nodes to successful when it starts to run them.
        self.node_name = node_name  # type: str
        # The ID of the node.
        self.owner_id = owner_id  # type: str
        # The CRON expression returned.
        self.param_values = param_values  # type: str
        # The HTTP status code returned.
        self.priority = priority  # type: int
        # The ID of the owner of the node.
        self.program_type = program_type  # type: str
        # Indicates whether the node can be rerun.
        self.project_id = project_id  # type: long
        # Indicates whether the node is associated with Data Quality. Valid values: 0 and 1. A value of 0 indicates that the node is associated with Data Quality. A value of 1 indicates that the node is not associated with Data Quality.
        self.related_flow_id = related_flow_id  # type: long
        # The ID of the workflow to which the node belongs.
        self.repeat_interval = repeat_interval  # type: long
        # The type of the node.
        self.repeatability = repeatability  # type: str
        self.res_group_identifier = res_group_identifier  # type: str
        # The ID of the request. You can use the ID to locate logs and troubleshoot issues.
        self.res_group_name = res_group_name  # type: str
        # The ID of the workspace.
        self.scheduler_type = scheduler_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.connection is not None:
            result['Connection'] = self.connection
        if self.cron_express is not None:
            result['CronExpress'] = self.cron_express
        if self.description is not None:
            result['Description'] = self.description
        if self.dqc_description is not None:
            result['DqcDescription'] = self.dqc_description
        if self.dqc_type is not None:
            result['DqcType'] = self.dqc_type
        if self.file_type is not None:
            result['FileType'] = self.file_type
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.param_values is not None:
            result['ParamValues'] = self.param_values
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.related_flow_id is not None:
            result['RelatedFlowId'] = self.related_flow_id
        if self.repeat_interval is not None:
            result['RepeatInterval'] = self.repeat_interval
        if self.repeatability is not None:
            result['Repeatability'] = self.repeatability
        if self.res_group_identifier is not None:
            result['ResGroupIdentifier'] = self.res_group_identifier
        if self.res_group_name is not None:
            result['ResGroupName'] = self.res_group_name
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('Connection') is not None:
            self.connection = m.get('Connection')
        if m.get('CronExpress') is not None:
            self.cron_express = m.get('CronExpress')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('DqcDescription') is not None:
            self.dqc_description = m.get('DqcDescription')
        if m.get('DqcType') is not None:
            self.dqc_type = m.get('DqcType')
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('ParamValues') is not None:
            self.param_values = m.get('ParamValues')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RelatedFlowId') is not None:
            self.related_flow_id = m.get('RelatedFlowId')
        if m.get('RepeatInterval') is not None:
            self.repeat_interval = m.get('RepeatInterval')
        if m.get('Repeatability') is not None:
            self.repeatability = m.get('Repeatability')
        if m.get('ResGroupIdentifier') is not None:
            self.res_group_identifier = m.get('ResGroupIdentifier')
        if m.get('ResGroupName') is not None:
            self.res_group_name = m.get('ResGroupName')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        return self


class GetNodeResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The details of the node.
        self.data = data  # type: GetNodeResponseBodyData
        # The ID of the node. You can call the [ListNodes](~~173979~~) operation to query the node ID.
        self.error_code = error_code  # type: str
        # The connection string.
        self.error_message = error_message  # type: str
        # The operation that you want to perform. Set the value to **GetNode**.
        self.http_status_code = http_status_code  # type: int
        # Other parameters.
        self.request_id = request_id  # type: str
        # The ID of the workflow.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetNodeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetNodeResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetNodeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetNodeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetNodeResponse, self).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=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 = GetNodeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetNodeChildrenRequest(TeaModel):
    def __init__(self, node_id=None, project_env=None):
        # The ID of the node. You can go to the Operation Center page in the DataWorks console to view the ID.
        self.node_id = node_id  # type: long
        # The environment of the workspace. Valid values: PROD and DEV. The value PROD indicates the production environment, and the value DEV indicates the development environment.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeChildrenRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class GetNodeChildrenResponseBodyDataNodes(TeaModel):
    def __init__(self, baseline_id=None, cron_express=None, node_id=None, node_name=None, owner_id=None,
                 priority=None, program_type=None, project_id=None, repeatability=None, scheduler_type=None):
        # The ID of the baseline.
        self.baseline_id = baseline_id  # type: long
        # The cron expression. Cron expressions are used to run auto triggered nodes.
        self.cron_express = cron_express  # type: str
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The ID of the Alibaba Cloud account used by the node owner.
        self.owner_id = owner_id  # type: str
        # The priority of the node. Valid values: 1 to 8. A large value indicates a high priority.
        self.priority = priority  # type: int
        # The type of the node.
        self.program_type = program_type  # type: str
        # The ID of the workspace to which the node belongs.
        self.project_id = project_id  # type: long
        # Indicates whether the node can be rerun if the node fails to run. Valid values:
        # 
        # *   true: indicates that the node can be rerun.
        # *   false: indicates that the node cannot be rerun.
        self.repeatability = repeatability  # type: bool
        # The scheduling type of the node. Valid values:
        # 
        # *   NORMAL: indicates that the node is an auto triggered node.
        # *   MANUAL: indicates that node is a manually triggered node.
        # *   PAUSE: indicates that the node is a paused node. Paused nodes are started as scheduled but the system sets the status of the nodes to failed when it starts to run them.
        # *   SKIP: indicates that the node is a dry-run node. Dry-run nodes are started as scheduled but the system sets the status of the nodes to successful when it starts to run them.
        self.scheduler_type = scheduler_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeChildrenResponseBodyDataNodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.cron_express is not None:
            result['CronExpress'] = self.cron_express
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.repeatability is not None:
            result['Repeatability'] = self.repeatability
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('CronExpress') is not None:
            self.cron_express = m.get('CronExpress')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Repeatability') is not None:
            self.repeatability = m.get('Repeatability')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        return self


class GetNodeChildrenResponseBodyData(TeaModel):
    def __init__(self, nodes=None):
        # The descendant nodes returned.
        self.nodes = nodes  # type: list[GetNodeChildrenResponseBodyDataNodes]

    def validate(self):
        if self.nodes:
            for k in self.nodes:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetNodeChildrenResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Nodes'] = []
        if self.nodes is not None:
            for k in self.nodes:
                result['Nodes'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.nodes = []
        if m.get('Nodes') is not None:
            for k in m.get('Nodes'):
                temp_model = GetNodeChildrenResponseBodyDataNodes()
                self.nodes.append(temp_model.from_map(k))
        return self


class GetNodeChildrenResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The information of the descendant nodes.
        self.data = data  # type: GetNodeChildrenResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetNodeChildrenResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetNodeChildrenResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetNodeChildrenResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetNodeChildrenResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetNodeChildrenResponse, self).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=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 = GetNodeChildrenResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetNodeCodeRequest(TeaModel):
    def __init__(self, node_id=None, project_env=None):
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The environment of the workspace. Valid values: PROD and DEV.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeCodeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class GetNodeCodeResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The code of the node.
        self.data = data  # type: str
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request, You can use the ID to query logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeCodeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetNodeCodeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetNodeCodeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetNodeCodeResponse, self).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=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 = GetNodeCodeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetNodeOnBaselineRequest(TeaModel):
    def __init__(self, baseline_id=None):
        self.baseline_id = baseline_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeOnBaselineRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        return self


class GetNodeOnBaselineResponseBodyData(TeaModel):
    def __init__(self, node_id=None, node_name=None, owner=None, project_id=None):
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeOnBaselineResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetNodeOnBaselineResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: list[GetNodeOnBaselineResponseBodyData]
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: str

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetNodeOnBaselineResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = GetNodeOnBaselineResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetNodeOnBaselineResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetNodeOnBaselineResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetNodeOnBaselineResponse, self).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=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 = GetNodeOnBaselineResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetNodeParentsRequest(TeaModel):
    def __init__(self, node_id=None, project_env=None):
        # The ID of the node. You can go to the Operation Center page in the DataWorks console to view the node ID.
        self.node_id = node_id  # type: long
        # The environment of the workspace. Valid values: PROD and DEV. The value PROD indicates the production environment, and the value DEV indicates the development environment.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeParentsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class GetNodeParentsResponseBodyDataNodes(TeaModel):
    def __init__(self, baseline_id=None, cron_express=None, node_id=None, node_name=None, owner_id=None,
                 priority=None, program_type=None, project_id=None, repeatability=None, scheduler_type=None):
        # The ID of the baseline.
        self.baseline_id = baseline_id  # type: long
        # The cron expression. Cron expressions are used to run auto triggered nodes.
        self.cron_express = cron_express  # type: str
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The ID of the Alibaba Cloud account used by the node owner.
        self.owner_id = owner_id  # type: str
        # The priority of the node. Valid values: 1 to 8. A large value indicates a high priority.
        self.priority = priority  # type: int
        # The type of the node.
        self.program_type = program_type  # type: str
        # The ID of the workspace to which the node belongs.
        self.project_id = project_id  # type: long
        # Indicates whether the node can be rerun if the node fails to run. Valid values:
        # 
        # *   true: indicates that the node can be rerun.
        # *   false: indicates that the node cannot be rerun.
        self.repeatability = repeatability  # type: bool
        # The scheduling type of the node. Valid values:
        # 
        # *   NORMAL: indicates that the node is an auto triggered node.
        # *   MANUAL: indicates that the node is a manually triggered node.
        # *   PAUSE: indicates that the node is a paused node. Paused nodes are started as scheduled but the system sets the status of the nodes to failed when it starts to run them.
        # *   SKIP: indicates that the node is a dry-run node. Dry-run nodes are started as scheduled but the system sets the status of the nodes to successful when it starts to run them.
        self.scheduler_type = scheduler_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeParentsResponseBodyDataNodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.cron_express is not None:
            result['CronExpress'] = self.cron_express
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.repeatability is not None:
            result['Repeatability'] = self.repeatability
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('CronExpress') is not None:
            self.cron_express = m.get('CronExpress')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Repeatability') is not None:
            self.repeatability = m.get('Repeatability')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        return self


class GetNodeParentsResponseBodyData(TeaModel):
    def __init__(self, nodes=None):
        # The ancestor nodes returned.
        self.nodes = nodes  # type: list[GetNodeParentsResponseBodyDataNodes]

    def validate(self):
        if self.nodes:
            for k in self.nodes:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetNodeParentsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Nodes'] = []
        if self.nodes is not None:
            for k in self.nodes:
                result['Nodes'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.nodes = []
        if m.get('Nodes') is not None:
            for k in m.get('Nodes'):
                temp_model = GetNodeParentsResponseBodyDataNodes()
                self.nodes.append(temp_model.from_map(k))
        return self


class GetNodeParentsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The information of the ancestor nodes.
        self.data = data  # type: GetNodeParentsResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetNodeParentsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetNodeParentsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetNodeParentsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetNodeParentsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetNodeParentsResponse, self).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=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 = GetNodeParentsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetNodeTypeListInfoRequest(TeaModel):
    def __init__(self, keyword=None, locale=None, page_number=None, page_size=None, project_id=None,
                 project_identifier=None):
        self.keyword = keyword  # type: str
        self.locale = locale  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeTypeListInfoRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        if self.locale is not None:
            result['Locale'] = self.locale
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Keyword') is not None:
            self.keyword = m.get('Keyword')
        if m.get('Locale') is not None:
            self.locale = m.get('Locale')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class GetNodeTypeListInfoResponseBodyNodeTypeInfoListNodeTypeInfo(TeaModel):
    def __init__(self, node_type=None, node_type_name=None):
        self.node_type = node_type  # type: int
        self.node_type_name = node_type_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetNodeTypeListInfoResponseBodyNodeTypeInfoListNodeTypeInfo, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_type is not None:
            result['NodeType'] = self.node_type
        if self.node_type_name is not None:
            result['NodeTypeName'] = self.node_type_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeType') is not None:
            self.node_type = m.get('NodeType')
        if m.get('NodeTypeName') is not None:
            self.node_type_name = m.get('NodeTypeName')
        return self


class GetNodeTypeListInfoResponseBodyNodeTypeInfoList(TeaModel):
    def __init__(self, node_type_info=None, page_number=None, page_size=None, total_count=None):
        self.node_type_info = node_type_info  # type: list[GetNodeTypeListInfoResponseBodyNodeTypeInfoListNodeTypeInfo]
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.total_count = total_count  # type: int

    def validate(self):
        if self.node_type_info:
            for k in self.node_type_info:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetNodeTypeListInfoResponseBodyNodeTypeInfoList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['NodeTypeInfo'] = []
        if self.node_type_info is not None:
            for k in self.node_type_info:
                result['NodeTypeInfo'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.node_type_info = []
        if m.get('NodeTypeInfo') is not None:
            for k in m.get('NodeTypeInfo'):
                temp_model = GetNodeTypeListInfoResponseBodyNodeTypeInfoListNodeTypeInfo()
                self.node_type_info.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class GetNodeTypeListInfoResponseBody(TeaModel):
    def __init__(self, node_type_info_list=None, request_id=None):
        self.node_type_info_list = node_type_info_list  # type: GetNodeTypeListInfoResponseBodyNodeTypeInfoList
        self.request_id = request_id  # type: str

    def validate(self):
        if self.node_type_info_list:
            self.node_type_info_list.validate()

    def to_map(self):
        _map = super(GetNodeTypeListInfoResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_type_info_list is not None:
            result['NodeTypeInfoList'] = self.node_type_info_list.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeTypeInfoList') is not None:
            temp_model = GetNodeTypeListInfoResponseBodyNodeTypeInfoList()
            self.node_type_info_list = temp_model.from_map(m['NodeTypeInfoList'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetNodeTypeListInfoResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetNodeTypeListInfoResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetNodeTypeListInfoResponse, self).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=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 = GetNodeTypeListInfoResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetOpRiskDataRequest(TeaModel):
    def __init__(self, date=None, name=None, page_no=None, page_size=None, risk_type=None):
        # The date on which the access records were queried. Specify the value in the yyyyMMdd format.
        self.date = date  # type: str
        # The parameters that you can specify to query the access records. Valid values:
        # 
        # *   dbType: the data type
        # *   instanceName: the name of the instance
        # *   databaseName: the name of the database
        # *   projectName: the name of the workspace
        # *   clusterName: the name of the cluster
        # 
        # The following example shows the parameters configured to query the access records of the sensitive data in the abc database of the ABC Hologres instance:
        # 
        # {"dbType":"hologres","instanceName":"ABC","databaseName":"abc"}
        # 
        # You must specify the parameters based on the compute engine that you use in your business.
        self.name = name  # type: str
        # The number of the page to return. Minimum value: 1.
        self.page_no = page_no  # type: int
        # The number of entries to return on each page. Maximum value: 1000.
        self.page_size = page_size  # type: int
        # The method that you use to identify risks.
        # 
        # *   You can manually identify risks.
        # *   You can also use a risk rule to identify risks. You can go to the DataWorks console to obtain the name of the risk rule on the Custom Identification Rules page of Data Security Guard.
        self.risk_type = risk_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetOpRiskDataRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.date is not None:
            result['Date'] = self.date
        if self.name is not None:
            result['Name'] = self.name
        if self.page_no is not None:
            result['PageNo'] = self.page_no
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.risk_type is not None:
            result['RiskType'] = self.risk_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Date') is not None:
            self.date = m.get('Date')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('PageNo') is not None:
            self.page_no = m.get('PageNo')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('RiskType') is not None:
            self.risk_type = m.get('RiskType')
        return self


class GetOpRiskDataResponseBody(TeaModel):
    def __init__(self, request_id=None, risk_data=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # The information of the risky sensitive data returned. The information includes totalCount and opRiskDatas.
        # 
        # opRiskDatas includes the following parameters:
        # 
        # *   sensType: the type of the sensitive data
        # *   sensLevel: the sensitivity level of the sensitive data
        # *   opType: the type of the operation
        # *   sql: the SQL statement that is executed
        # *   opAccount: the account that is used to perform the operation
        # *   opTime: the time when the operation was performed
        self.risk_data = risk_data  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetOpRiskDataResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.risk_data is not None:
            result['RiskData'] = self.risk_data
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('RiskData') is not None:
            self.risk_data = m.get('RiskData')
        return self


class GetOpRiskDataResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetOpRiskDataResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetOpRiskDataResponse, self).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=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 = GetOpRiskDataResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetOpSensitiveDataRequest(TeaModel):
    def __init__(self, date=None, name=None, op_type=None, page_no=None, page_size=None):
        # The date on which access records were generated. Specify the value in the yyyyMMdd format.
        self.date = date  # type: str
        # The parameters that you can specify to query the access records. Valid values:
        # 
        # *   dbType: the data type
        # *   instanceName: the name of the instance
        # *   databaseName: the name of the database
        # *   projectName: the name of the workspace
        # *   clusterName: the name of the cluster
        # 
        # The following example shows the parameters configured to query the access records of the sensitive data in the abc database of the ABC Hologres instance:
        # 
        # {"dbType":"hologres","instanceName":"ABC","databaseName":"abc"}
        # 
        # You must specify the parameters based on the compute engine that you use in your business.
        self.name = name  # type: str
        # The operation that is performed on the data. Valid values:
        # 
        # *   SQL_SELECT: indicates that the data is accessed. For example, the SELECT statement is executed to query the data.
        # *   TUNNEL_DOWNLOAD: indicates that the data is downloaded. For example, a Tunnel command is run to download the data.
        self.op_type = op_type  # type: str
        # The number of the page to return. Minimum value:1. Maximum value: 1000.
        self.page_no = page_no  # type: int
        # The number of entries to return on each page. Minimum value: 1. Maximum value: 1000.
        self.page_size = page_size  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetOpSensitiveDataRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.date is not None:
            result['Date'] = self.date
        if self.name is not None:
            result['Name'] = self.name
        if self.op_type is not None:
            result['OpType'] = self.op_type
        if self.page_no is not None:
            result['PageNo'] = self.page_no
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Date') is not None:
            self.date = m.get('Date')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('OpType') is not None:
            self.op_type = m.get('OpType')
        if m.get('PageNo') is not None:
            self.page_no = m.get('PageNo')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        return self


class GetOpSensitiveDataResponseBody(TeaModel):
    def __init__(self, op_sensitive_data=None, request_id=None):
        # The information of the access records returned for the sensitive data. The information includes totalCount and opRiskDatas.
        # 
        # opRiskDatas includes the following parameters:
        # 
        # *   sensType: indicates the type of the sensitive data.
        # *   sensLevel: indicates the sensitivity level of the sensitive data. A larger value of sensLevel indicates a higher sensitivity level.
        # *   opType: indicates the type of the operation.
        # *   sql: indicates the SQL statement that is executed.
        # *   opAccount: indicates the account that is used to perform the operation.
        # *   opTime: indicates the time when the operation was performed.
        self.op_sensitive_data = op_sensitive_data  # type: str
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetOpSensitiveDataResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.op_sensitive_data is not None:
            result['OpSensitiveData'] = self.op_sensitive_data
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('OpSensitiveData') is not None:
            self.op_sensitive_data = m.get('OpSensitiveData')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetOpSensitiveDataResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetOpSensitiveDataResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetOpSensitiveDataResponse, self).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=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 = GetOpSensitiveDataResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetOptionValueForProjectRequest(TeaModel):
    def __init__(self, extension_code=None, project_id=None):
        # The ID of the workspace.
        self.extension_code = extension_code  # type: str
        # Id of the request
        self.project_id = project_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetOptionValueForProjectRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.extension_code is not None:
            result['ExtensionCode'] = self.extension_code
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ExtensionCode') is not None:
            self.extension_code = m.get('ExtensionCode')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetOptionValueForProjectResponseBody(TeaModel):
    def __init__(self, option_value=None, request_id=None):
        self.option_value = option_value  # type: str
        # The option settings. In the example, cuNumber is a custom key.
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetOptionValueForProjectResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.option_value is not None:
            result['OptionValue'] = self.option_value
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('OptionValue') is not None:
            self.option_value = m.get('OptionValue')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetOptionValueForProjectResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetOptionValueForProjectResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetOptionValueForProjectResponse, self).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=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 = GetOptionValueForProjectResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetPermissionApplyOrderDetailRequest(TeaModel):
    def __init__(self, flow_id=None):
        # The ID of the permission request order. You can call the ListPermissionApplyOrders operation to obtain the order ID.
        self.flow_id = flow_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetPermissionApplyOrderDetailRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.flow_id is not None:
            result['FlowId'] = self.flow_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FlowId') is not None:
            self.flow_id = m.get('FlowId')
        return self


class GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveAccountList(TeaModel):
    def __init__(self, base_id=None):
        # The unique ID of the Alibaba Cloud account that is used to approve the permission request order.
        self.base_id = base_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveAccountList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.base_id is not None:
            result['BaseId'] = self.base_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaseId') is not None:
            self.base_id = m.get('BaseId')
        return self


class GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMetaObjectMetaListColumnMetaList(TeaModel):
    def __init__(self, column_comment=None, column_name=None, security_level=None):
        # The description of the column on which you request permissions.
        self.column_comment = column_comment  # type: str
        # The name of the column on which you request permissions.
        self.column_name = column_name  # type: str
        self.security_level = security_level  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMetaObjectMetaListColumnMetaList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_comment is not None:
            result['ColumnComment'] = self.column_comment
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.security_level is not None:
            result['SecurityLevel'] = self.security_level
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnComment') is not None:
            self.column_comment = m.get('ColumnComment')
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('SecurityLevel') is not None:
            self.security_level = m.get('SecurityLevel')
        return self


class GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMetaObjectMetaList(TeaModel):
    def __init__(self, column_meta_list=None, object_name=None):
        # The information about the column fields in the object on which you request permissions.
        self.column_meta_list = column_meta_list  # type: list[GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMetaObjectMetaListColumnMetaList]
        # The name of the table on which you request permissions.
        self.object_name = object_name  # type: str

    def validate(self):
        if self.column_meta_list:
            for k in self.column_meta_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMetaObjectMetaList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ColumnMetaList'] = []
        if self.column_meta_list is not None:
            for k in self.column_meta_list:
                result['ColumnMetaList'].append(k.to_map() if k else None)
        if self.object_name is not None:
            result['ObjectName'] = self.object_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.column_meta_list = []
        if m.get('ColumnMetaList') is not None:
            for k in m.get('ColumnMetaList'):
                temp_model = GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMetaObjectMetaListColumnMetaList()
                self.column_meta_list.append(temp_model.from_map(k))
        if m.get('ObjectName') is not None:
            self.object_name = m.get('ObjectName')
        return self


class GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMeta(TeaModel):
    def __init__(self, max_compute_project_name=None, object_meta_list=None, workspace_id=None):
        # The MaxCompute project to which the object on which you request permissions belongs.
        self.max_compute_project_name = max_compute_project_name  # type: str
        # Details about the object on which you request permissions.
        self.object_meta_list = object_meta_list  # type: list[GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMetaObjectMetaList]
        # The ID of the DataWorks workspace that is associated with the object on which you request permissions.
        self.workspace_id = workspace_id  # type: int

    def validate(self):
        if self.object_meta_list:
            for k in self.object_meta_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMeta, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.max_compute_project_name is not None:
            result['MaxComputeProjectName'] = self.max_compute_project_name
        result['ObjectMetaList'] = []
        if self.object_meta_list is not None:
            for k in self.object_meta_list:
                result['ObjectMetaList'].append(k.to_map() if k else None)
        if self.workspace_id is not None:
            result['WorkspaceId'] = self.workspace_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('MaxComputeProjectName') is not None:
            self.max_compute_project_name = m.get('MaxComputeProjectName')
        self.object_meta_list = []
        if m.get('ObjectMetaList') is not None:
            for k in m.get('ObjectMetaList'):
                temp_model = GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMetaObjectMetaList()
                self.object_meta_list.append(temp_model.from_map(k))
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


class GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContent(TeaModel):
    def __init__(self, apply_reason=None, deadline=None, order_type=None, project_meta=None):
        # The reason for your request. The administrator decides whether to approve the request based on the request reason.
        self.apply_reason = apply_reason  # type: str
        # The expiration time of the permissions that you requested. The parameter value is a UNIX timestamp.
        # 
        # If LabelSecurity is disabled in the MaxCompute project, or the security level of fields in the MaxCompute table on which you request permissions is 0 or is less than or equal to the security level of the Alibaba Cloud account for which you request permissions, you can request only permanent permissions.
        self.deadline = deadline  # type: long
        # The type of the permission request order. The parameter value is 1 and cannot be changed. 1 indicates that ACL-based authorization is requested.
        self.order_type = order_type  # type: int
        # The information about the project and workspace that are associated with the object on which you requested permissions.
        self.project_meta = project_meta  # type: GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMeta

    def validate(self):
        if self.project_meta:
            self.project_meta.validate()

    def to_map(self):
        _map = super(GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContent, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.apply_reason is not None:
            result['ApplyReason'] = self.apply_reason
        if self.deadline is not None:
            result['Deadline'] = self.deadline
        if self.order_type is not None:
            result['OrderType'] = self.order_type
        if self.project_meta is not None:
            result['ProjectMeta'] = self.project_meta.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApplyReason') is not None:
            self.apply_reason = m.get('ApplyReason')
        if m.get('Deadline') is not None:
            self.deadline = m.get('Deadline')
        if m.get('OrderType') is not None:
            self.order_type = m.get('OrderType')
        if m.get('ProjectMeta') is not None:
            temp_model = GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMeta()
            self.project_meta = temp_model.from_map(m['ProjectMeta'])
        return self


class GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailGranteeObjectList(TeaModel):
    def __init__(self, grantee_id=None, grantee_name=None, grantee_type=None, grantee_type_sub=None):
        # The unique ID of the account that is used to request permissions.
        self.grantee_id = grantee_id  # type: str
        # The name of the account that is used to request permissions. The name is in the same format as that of the account used to access the MaxCompute project.
        # 
        # *   An Alibaba Cloud account is in the format of ALIYUN$+Account name.
        # *   A RAM user is in the format of RAM$+Account name.
        self.grantee_name = grantee_name  # type: str
        # The type of the subject that requests permissions. The parameter value is 1 and cannot be changed. It indicates user.
        self.grantee_type = grantee_type  # type: int
        # The subtype of the subject that requests permissions. Valid values:
        # 
        # *   101: production account
        # *   103: individual account
        # *   105: account that requests permissions for others
        self.grantee_type_sub = grantee_type_sub  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailGranteeObjectList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.grantee_id is not None:
            result['GranteeId'] = self.grantee_id
        if self.grantee_name is not None:
            result['GranteeName'] = self.grantee_name
        if self.grantee_type is not None:
            result['GranteeType'] = self.grantee_type
        if self.grantee_type_sub is not None:
            result['GranteeTypeSub'] = self.grantee_type_sub
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('GranteeId') is not None:
            self.grantee_id = m.get('GranteeId')
        if m.get('GranteeName') is not None:
            self.grantee_name = m.get('GranteeName')
        if m.get('GranteeType') is not None:
            self.grantee_type = m.get('GranteeType')
        if m.get('GranteeTypeSub') is not None:
            self.grantee_type_sub = m.get('GranteeTypeSub')
        return self


class GetPermissionApplyOrderDetailResponseBodyApplyOrderDetail(TeaModel):
    def __init__(self, apply_base_id=None, apply_timestamp=None, approve_account_list=None, approve_content=None,
                 flow_id=None, flow_status=None, grantee_object_list=None):
        # The unique ID of the Alibaba Cloud account that is used to submit the permission request order.
        self.apply_base_id = apply_base_id  # type: str
        # The time when the permission request order was submitted. The parameter value is a UNIX timestamp.
        self.apply_timestamp = apply_timestamp  # type: long
        # The list of Alibaba Cloud accounts that are used to approve the permission request order.
        self.approve_account_list = approve_account_list  # type: list[GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveAccountList]
        # The content of the permission request.
        self.approve_content = approve_content  # type: GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContent
        # The ID of the permission request order.
        self.flow_id = flow_id  # type: str
        # The status of the permission request order. Valid values:
        # 
        # *   1: pending approval
        # *   2: approved and authorized
        # *   3: approved but authorization failed
        # *   4: rejected
        self.flow_status = flow_status  # type: int
        # Information about the account that is used to request permissions.
        self.grantee_object_list = grantee_object_list  # type: list[GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailGranteeObjectList]

    def validate(self):
        if self.approve_account_list:
            for k in self.approve_account_list:
                if k:
                    k.validate()
        if self.approve_content:
            self.approve_content.validate()
        if self.grantee_object_list:
            for k in self.grantee_object_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetPermissionApplyOrderDetailResponseBodyApplyOrderDetail, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.apply_base_id is not None:
            result['ApplyBaseId'] = self.apply_base_id
        if self.apply_timestamp is not None:
            result['ApplyTimestamp'] = self.apply_timestamp
        result['ApproveAccountList'] = []
        if self.approve_account_list is not None:
            for k in self.approve_account_list:
                result['ApproveAccountList'].append(k.to_map() if k else None)
        if self.approve_content is not None:
            result['ApproveContent'] = self.approve_content.to_map()
        if self.flow_id is not None:
            result['FlowId'] = self.flow_id
        if self.flow_status is not None:
            result['FlowStatus'] = self.flow_status
        result['GranteeObjectList'] = []
        if self.grantee_object_list is not None:
            for k in self.grantee_object_list:
                result['GranteeObjectList'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApplyBaseId') is not None:
            self.apply_base_id = m.get('ApplyBaseId')
        if m.get('ApplyTimestamp') is not None:
            self.apply_timestamp = m.get('ApplyTimestamp')
        self.approve_account_list = []
        if m.get('ApproveAccountList') is not None:
            for k in m.get('ApproveAccountList'):
                temp_model = GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveAccountList()
                self.approve_account_list.append(temp_model.from_map(k))
        if m.get('ApproveContent') is not None:
            temp_model = GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContent()
            self.approve_content = temp_model.from_map(m['ApproveContent'])
        if m.get('FlowId') is not None:
            self.flow_id = m.get('FlowId')
        if m.get('FlowStatus') is not None:
            self.flow_status = m.get('FlowStatus')
        self.grantee_object_list = []
        if m.get('GranteeObjectList') is not None:
            for k in m.get('GranteeObjectList'):
                temp_model = GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailGranteeObjectList()
                self.grantee_object_list.append(temp_model.from_map(k))
        return self


class GetPermissionApplyOrderDetailResponseBody(TeaModel):
    def __init__(self, apply_order_detail=None, request_id=None):
        # Details about the permission request order.
        self.apply_order_detail = apply_order_detail  # type: GetPermissionApplyOrderDetailResponseBodyApplyOrderDetail
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.apply_order_detail:
            self.apply_order_detail.validate()

    def to_map(self):
        _map = super(GetPermissionApplyOrderDetailResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.apply_order_detail is not None:
            result['ApplyOrderDetail'] = self.apply_order_detail.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApplyOrderDetail') is not None:
            temp_model = GetPermissionApplyOrderDetailResponseBodyApplyOrderDetail()
            self.apply_order_detail = temp_model.from_map(m['ApplyOrderDetail'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetPermissionApplyOrderDetailResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetPermissionApplyOrderDetailResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetPermissionApplyOrderDetailResponse, self).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=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 = GetPermissionApplyOrderDetailResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetProjectRequest(TeaModel):
    def __init__(self, project_id=None, project_identifier=None):
        # The ID of the request. You can use the ID to locate logs and troubleshoot issues.
        self.project_id = project_id  # type: long
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetProjectRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class GetProjectResponseBodyDataTags(TeaModel):
    def __init__(self, key=None, value=None):
        self.key = key  # type: str
        self.value = value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetProjectResponseBodyDataTags, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class GetProjectResponseBodyData(TeaModel):
    def __init__(self, appkey=None, base_project=None, default_di_resource_group_identifier=None, destination=None,
                 dev_storage_quota=None, development_type=None, disable_development=None, env_types=None, gmt_create=None,
                 gmt_modified=None, is_allow_download=None, is_default=None, max_flow_node=None, prod_storage_quota=None,
                 project_description=None, project_id=None, project_identifier=None, project_mode=None, project_name=None,
                 project_owner_base_id=None, protected_mode=None, resident_area=None, resource_manager_resource_group_id=None,
                 scheduler_max_retry_times=None, scheduler_retry_interval=None, status=None, table_privacy_mode=None, tags=None,
                 tenant_id=None, use_proxy_odps_account=None):
        # Indicates whether the workspace is a default workspace. Valid values:
        # 
        # *   1: The workspace is a default workspace.
        # *   0: The workspace is not a default workspace.
        self.appkey = appkey  # type: str
        # The time when the workspace was created. Example: Dec 3, 2019 9:12:20 PM.
        self.base_project = base_project  # type: bool
        self.default_di_resource_group_identifier = default_di_resource_group_identifier  # type: str
        # The unique identifier of the workspace.
        self.destination = destination  # type: int
        # This parameter is deprecated.
        self.dev_storage_quota = dev_storage_quota  # type: str
        # The default maximum number of automatic reruns that are allowed after an error occurs.
        self.development_type = development_type  # type: int
        # This parameter is deprecated.
        self.disable_development = disable_development  # type: bool
        # The list of tags.
        # 
        # The tags are added to resources in the workspace and used for authentication and cost allocation.
        self.env_types = env_types  # type: list[str]
        # The environment of the workspace. Valid values: PROD and DEV.
        # 
        # *   The value PROD indicates the production environment. Workspaces in basic mode provide only the production environment.
        # *   The value DEV indicates the development environment. Workspaces in standard mode provide both the development environment and the production environment.
        self.gmt_create = gmt_create  # type: str
        # The description of the workspace.
        self.gmt_modified = gmt_modified  # type: str
        # The time when the workspace was last modified. Example: Dec 3, 2019 9:12:20 PM.
        self.is_allow_download = is_allow_download  # type: int
        # The display name of the workspace.
        self.is_default = is_default  # type: int
        # Indicates whether you are allowed to download the query result from DataStudio. Valid values:
        # 
        # *   1: You are allowed to download the query result from DataStudio.
        # *   0: You are not allowed to download the query result from DataStudio.
        self.max_flow_node = max_flow_node  # type: int
        # The development type of the workspace. The value is fixed as 4. This parameter is deprecated.
        self.prod_storage_quota = prod_storage_quota  # type: str
        # Indicates whether the MaxCompute tables in the workspace are visible to the users within a tenant. Valid values:
        # 
        # *   0: The MaxCompute tables are invisible to the users within a tenant.
        # *   1: The MaxCompute tables are visible to the users within a tenant.
        self.project_description = project_description  # type: str
        # The mode of the workspace. Valid values:
        # 
        # *   2: The workspace is in basic mode.
        # *   3: The workspace is in standard mode.
        self.project_id = project_id  # type: int
        # The ID of the Alibaba Cloud account used by the workspace owner.
        self.project_identifier = project_identifier  # type: str
        # This parameter is deprecated.
        self.project_mode = project_mode  # type: int
        # Indicates whether the Development role is disabled. Valid values:
        # 
        # *   false: The Development role is enabled.
        # *   true: The Development role is disabled.
        # 
        # <!---->
        # 
        # *   Default value: false.
        self.project_name = project_name  # type: str
        # Indicates whether a proxy account is used to access the MaxCompute compute engine instance associated with the workspace.
        self.project_owner_base_id = project_owner_base_id  # type: str
        # This parameter is deprecated.
        self.protected_mode = protected_mode  # type: int
        self.resident_area = resident_area  # type: str
        # The keys of the tags that are added to resources in the workspace. The tag keys must meet the following conditions:
        # 
        # *   The number of tag keys that can be added to resources ranges from 1 to 20.
        # *   Each tag key can be a maximum of 128 characters in length.
        # *   The tag keys cannot start with acs: or aliyun:.
        # *   The tag keys cannot contain http:// or https://.
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        # The interval between automatic reruns after an error occurs. Unit: milliseconds. The maximum interval is 30 minutes. You must pay attention to the conversion between units.
        self.scheduler_max_retry_times = scheduler_max_retry_times  # type: int
        # This parameter is deprecated.
        self.scheduler_retry_interval = scheduler_retry_interval  # type: int
        # The ID of the workspace.
        self.status = status  # type: int
        # Indicates whether the workspace protection feature is enabled. Valid values:
        # 
        # *   1: The workspace protection feature is enabled.
        # *   0: The workspace protection feature is disabled.
        self.table_privacy_mode = table_privacy_mode  # type: int
        # The values of the tags that are added to resources in the workspace. The tag values must meet the following conditions:
        # 
        # *   The number of tag values that can be added to resources ranges from 1 to 20.
        # *   Each tag value can be a maximum of 128 characters in length.
        # *   The tag values cannot start with acs:.
        # *   The tag values cannot contain http:// or https://.
        self.tags = tags  # type: list[GetProjectResponseBodyDataTags]
        # The ID of the resource group used in the workspace.
        self.tenant_id = tenant_id  # type: long
        # The ID of the tenant.
        self.use_proxy_odps_account = use_proxy_odps_account  # type: bool

    def validate(self):
        if self.tags:
            for k in self.tags:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetProjectResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.appkey is not None:
            result['Appkey'] = self.appkey
        if self.base_project is not None:
            result['BaseProject'] = self.base_project
        if self.default_di_resource_group_identifier is not None:
            result['DefaultDiResourceGroupIdentifier'] = self.default_di_resource_group_identifier
        if self.destination is not None:
            result['Destination'] = self.destination
        if self.dev_storage_quota is not None:
            result['DevStorageQuota'] = self.dev_storage_quota
        if self.development_type is not None:
            result['DevelopmentType'] = self.development_type
        if self.disable_development is not None:
            result['DisableDevelopment'] = self.disable_development
        if self.env_types is not None:
            result['EnvTypes'] = self.env_types
        if self.gmt_create is not None:
            result['GmtCreate'] = self.gmt_create
        if self.gmt_modified is not None:
            result['GmtModified'] = self.gmt_modified
        if self.is_allow_download is not None:
            result['IsAllowDownload'] = self.is_allow_download
        if self.is_default is not None:
            result['IsDefault'] = self.is_default
        if self.max_flow_node is not None:
            result['MaxFlowNode'] = self.max_flow_node
        if self.prod_storage_quota is not None:
            result['ProdStorageQuota'] = self.prod_storage_quota
        if self.project_description is not None:
            result['ProjectDescription'] = self.project_description
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.project_mode is not None:
            result['ProjectMode'] = self.project_mode
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.project_owner_base_id is not None:
            result['ProjectOwnerBaseId'] = self.project_owner_base_id
        if self.protected_mode is not None:
            result['ProtectedMode'] = self.protected_mode
        if self.resident_area is not None:
            result['ResidentArea'] = self.resident_area
        if self.resource_manager_resource_group_id is not None:
            result['ResourceManagerResourceGroupId'] = self.resource_manager_resource_group_id
        if self.scheduler_max_retry_times is not None:
            result['SchedulerMaxRetryTimes'] = self.scheduler_max_retry_times
        if self.scheduler_retry_interval is not None:
            result['SchedulerRetryInterval'] = self.scheduler_retry_interval
        if self.status is not None:
            result['Status'] = self.status
        if self.table_privacy_mode is not None:
            result['TablePrivacyMode'] = self.table_privacy_mode
        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.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.use_proxy_odps_account is not None:
            result['UseProxyOdpsAccount'] = self.use_proxy_odps_account
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Appkey') is not None:
            self.appkey = m.get('Appkey')
        if m.get('BaseProject') is not None:
            self.base_project = m.get('BaseProject')
        if m.get('DefaultDiResourceGroupIdentifier') is not None:
            self.default_di_resource_group_identifier = m.get('DefaultDiResourceGroupIdentifier')
        if m.get('Destination') is not None:
            self.destination = m.get('Destination')
        if m.get('DevStorageQuota') is not None:
            self.dev_storage_quota = m.get('DevStorageQuota')
        if m.get('DevelopmentType') is not None:
            self.development_type = m.get('DevelopmentType')
        if m.get('DisableDevelopment') is not None:
            self.disable_development = m.get('DisableDevelopment')
        if m.get('EnvTypes') is not None:
            self.env_types = m.get('EnvTypes')
        if m.get('GmtCreate') is not None:
            self.gmt_create = m.get('GmtCreate')
        if m.get('GmtModified') is not None:
            self.gmt_modified = m.get('GmtModified')
        if m.get('IsAllowDownload') is not None:
            self.is_allow_download = m.get('IsAllowDownload')
        if m.get('IsDefault') is not None:
            self.is_default = m.get('IsDefault')
        if m.get('MaxFlowNode') is not None:
            self.max_flow_node = m.get('MaxFlowNode')
        if m.get('ProdStorageQuota') is not None:
            self.prod_storage_quota = m.get('ProdStorageQuota')
        if m.get('ProjectDescription') is not None:
            self.project_description = m.get('ProjectDescription')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('ProjectMode') is not None:
            self.project_mode = m.get('ProjectMode')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('ProjectOwnerBaseId') is not None:
            self.project_owner_base_id = m.get('ProjectOwnerBaseId')
        if m.get('ProtectedMode') is not None:
            self.protected_mode = m.get('ProtectedMode')
        if m.get('ResidentArea') is not None:
            self.resident_area = m.get('ResidentArea')
        if m.get('ResourceManagerResourceGroupId') is not None:
            self.resource_manager_resource_group_id = m.get('ResourceManagerResourceGroupId')
        if m.get('SchedulerMaxRetryTimes') is not None:
            self.scheduler_max_retry_times = m.get('SchedulerMaxRetryTimes')
        if m.get('SchedulerRetryInterval') is not None:
            self.scheduler_retry_interval = m.get('SchedulerRetryInterval')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TablePrivacyMode') is not None:
            self.table_privacy_mode = m.get('TablePrivacyMode')
        self.tags = []
        if m.get('Tags') is not None:
            for k in m.get('Tags'):
                temp_model = GetProjectResponseBodyDataTags()
                self.tags.append(temp_model.from_map(k))
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('UseProxyOdpsAccount') is not None:
            self.use_proxy_odps_account = m.get('UseProxyOdpsAccount')
        return self


class GetProjectResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        # This parameter is deprecated.
        self.data = data  # type: GetProjectResponseBodyData
        # Indicates whether the request was successful.
        self.http_status_code = http_status_code  # type: int
        # The description of the workspace.
        self.request_id = request_id  # type: str
        # The status of the workspace. Valid values:
        # 
        # *   AVAILABLE(0): The workspace is in a normal state.
        # *   DELETED(1): The workspace is deleted.
        # *   INITIALIZING(2): The workspace is being initialized.
        # *   INIT_FAILED(3): The workspace fails to be initialized.
        # *   FORBIDDEN(4): The workspace is manually disabled.
        # *   DELETING(5): The workspace is being deleted.
        # *   DEL_FAILED(6): The workspace fails to be deleted.
        # *   FROZEN(7): The workspace is frozen due to overdue payments.
        # *   UPDATING(8): The workspace is being updated. The workspace enters this state after you associate a new compute engine with the workspace and the compute engine is being initialized.
        # *   UPDATE_FAILED(9): The workspace fails to be updated.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetProjectResponseBody, self).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.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetProjectResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetProjectResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetProjectResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetProjectResponse, self).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=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 = GetProjectResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetProjectDetailRequest(TeaModel):
    def __init__(self, project_id=None):
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetProjectDetailRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetProjectDetailResponseBodyDataTags(TeaModel):
    def __init__(self, key=None, value=None):
        self.key = key  # type: str
        self.value = value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetProjectDetailResponseBodyDataTags, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class GetProjectDetailResponseBodyData(TeaModel):
    def __init__(self, default_di_resource_group_identifier=None, development_type=None, disable_development=None,
                 env_types=None, gmt_create=None, gmt_modified=None, is_allow_download=None, is_default=None,
                 project_description=None, project_id=None, project_identifier=None, project_mode=None, project_name=None,
                 project_owner_base_id=None, protected_mode=None, resident_area=None, resource_manager_resource_group_id=None,
                 scheduler_max_retry_times=None, scheduler_retry_interval=None, status=None, table_privacy_mode=None, tags=None,
                 tenant_id=None, use_proxy_odps_account=None):
        self.default_di_resource_group_identifier = default_di_resource_group_identifier  # type: str
        self.development_type = development_type  # type: int
        self.disable_development = disable_development  # type: bool
        self.env_types = env_types  # type: list[str]
        self.gmt_create = gmt_create  # type: str
        self.gmt_modified = gmt_modified  # type: str
        self.is_allow_download = is_allow_download  # type: int
        self.is_default = is_default  # type: int
        self.project_description = project_description  # type: str
        self.project_id = project_id  # type: int
        self.project_identifier = project_identifier  # type: str
        self.project_mode = project_mode  # type: int
        self.project_name = project_name  # type: str
        self.project_owner_base_id = project_owner_base_id  # type: str
        self.protected_mode = protected_mode  # type: int
        self.resident_area = resident_area  # type: str
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        self.scheduler_max_retry_times = scheduler_max_retry_times  # type: int
        self.scheduler_retry_interval = scheduler_retry_interval  # type: int
        self.status = status  # type: int
        self.table_privacy_mode = table_privacy_mode  # type: int
        self.tags = tags  # type: list[GetProjectDetailResponseBodyDataTags]
        self.tenant_id = tenant_id  # type: long
        self.use_proxy_odps_account = use_proxy_odps_account  # type: bool

    def validate(self):
        if self.tags:
            for k in self.tags:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetProjectDetailResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.default_di_resource_group_identifier is not None:
            result['DefaultDiResourceGroupIdentifier'] = self.default_di_resource_group_identifier
        if self.development_type is not None:
            result['DevelopmentType'] = self.development_type
        if self.disable_development is not None:
            result['DisableDevelopment'] = self.disable_development
        if self.env_types is not None:
            result['EnvTypes'] = self.env_types
        if self.gmt_create is not None:
            result['GmtCreate'] = self.gmt_create
        if self.gmt_modified is not None:
            result['GmtModified'] = self.gmt_modified
        if self.is_allow_download is not None:
            result['IsAllowDownload'] = self.is_allow_download
        if self.is_default is not None:
            result['IsDefault'] = self.is_default
        if self.project_description is not None:
            result['ProjectDescription'] = self.project_description
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.project_mode is not None:
            result['ProjectMode'] = self.project_mode
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.project_owner_base_id is not None:
            result['ProjectOwnerBaseId'] = self.project_owner_base_id
        if self.protected_mode is not None:
            result['ProtectedMode'] = self.protected_mode
        if self.resident_area is not None:
            result['ResidentArea'] = self.resident_area
        if self.resource_manager_resource_group_id is not None:
            result['ResourceManagerResourceGroupId'] = self.resource_manager_resource_group_id
        if self.scheduler_max_retry_times is not None:
            result['SchedulerMaxRetryTimes'] = self.scheduler_max_retry_times
        if self.scheduler_retry_interval is not None:
            result['SchedulerRetryInterval'] = self.scheduler_retry_interval
        if self.status is not None:
            result['Status'] = self.status
        if self.table_privacy_mode is not None:
            result['TablePrivacyMode'] = self.table_privacy_mode
        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.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.use_proxy_odps_account is not None:
            result['UseProxyOdpsAccount'] = self.use_proxy_odps_account
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DefaultDiResourceGroupIdentifier') is not None:
            self.default_di_resource_group_identifier = m.get('DefaultDiResourceGroupIdentifier')
        if m.get('DevelopmentType') is not None:
            self.development_type = m.get('DevelopmentType')
        if m.get('DisableDevelopment') is not None:
            self.disable_development = m.get('DisableDevelopment')
        if m.get('EnvTypes') is not None:
            self.env_types = m.get('EnvTypes')
        if m.get('GmtCreate') is not None:
            self.gmt_create = m.get('GmtCreate')
        if m.get('GmtModified') is not None:
            self.gmt_modified = m.get('GmtModified')
        if m.get('IsAllowDownload') is not None:
            self.is_allow_download = m.get('IsAllowDownload')
        if m.get('IsDefault') is not None:
            self.is_default = m.get('IsDefault')
        if m.get('ProjectDescription') is not None:
            self.project_description = m.get('ProjectDescription')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('ProjectMode') is not None:
            self.project_mode = m.get('ProjectMode')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('ProjectOwnerBaseId') is not None:
            self.project_owner_base_id = m.get('ProjectOwnerBaseId')
        if m.get('ProtectedMode') is not None:
            self.protected_mode = m.get('ProtectedMode')
        if m.get('ResidentArea') is not None:
            self.resident_area = m.get('ResidentArea')
        if m.get('ResourceManagerResourceGroupId') is not None:
            self.resource_manager_resource_group_id = m.get('ResourceManagerResourceGroupId')
        if m.get('SchedulerMaxRetryTimes') is not None:
            self.scheduler_max_retry_times = m.get('SchedulerMaxRetryTimes')
        if m.get('SchedulerRetryInterval') is not None:
            self.scheduler_retry_interval = m.get('SchedulerRetryInterval')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TablePrivacyMode') is not None:
            self.table_privacy_mode = m.get('TablePrivacyMode')
        self.tags = []
        if m.get('Tags') is not None:
            for k in m.get('Tags'):
                temp_model = GetProjectDetailResponseBodyDataTags()
                self.tags.append(temp_model.from_map(k))
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('UseProxyOdpsAccount') is not None:
            self.use_proxy_odps_account = m.get('UseProxyOdpsAccount')
        return self


class GetProjectDetailResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        self.data = data  # type: GetProjectDetailResponseBodyData
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetProjectDetailResponseBody, self).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.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetProjectDetailResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetProjectDetailResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetProjectDetailResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetProjectDetailResponse, self).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=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 = GetProjectDetailResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetQualityEntityRequest(TeaModel):
    def __init__(self, env_type=None, match_expression=None, project_id=None, project_name=None, table_name=None):
        # The type of the compute engine instance or data source.
        self.env_type = env_type  # type: str
        # The partition filter expression.
        self.match_expression = match_expression  # type: str
        self.project_id = project_id  # type: long
        # The name of the compute engine instance or data source. You can obtain the name from data source configurations.
        self.project_name = project_name  # type: str
        # The name of the partitioned table. You can call the [GetMetaTablePartition](~~173923~~) operation to obtain the name.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetQualityEntityRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.match_expression is not None:
            result['MatchExpression'] = self.match_expression
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('MatchExpression') is not None:
            self.match_expression = m.get('MatchExpression')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetQualityEntityResponseBodyData(TeaModel):
    def __init__(self, create_time=None, entity_level=None, env_type=None, followers=None, has_relative_node=None,
                 id=None, match_expression=None, modify_time=None, modify_user=None, on_duty=None,
                 on_duty_account_name=None, project_name=None, relative_node=None, sql=None, table_name=None, task=None):
        # The time when the partition filter expression was created.
        self.create_time = create_time  # type: long
        # The level of the partition filter expression. Valid values:
        # 
        # *   0: The partition filter expression is at the SQL level. This indicates that the system checks data quality after each SQL statement is executed.
        # *   1: The partition filter expression is at the node level. This indicates that the system checks data quality after all the SQL statements for a node are executed.
        self.entity_level = entity_level  # type: int
        # The type of the compute engine instance or data source.
        self.env_type = env_type  # type: str
        # The ID of the Alibaba Cloud account that is used to receive alert notifications.
        self.followers = followers  # type: str
        # Indicates whether the partition filter expression is associated with a node. Valid values:
        # 
        # *   true: The partition filter expression is associated with a node.
        # *   false: The partition filter expression is not associated with a node.
        self.has_relative_node = has_relative_node  # type: bool
        # The ID of the partition filter expression.
        self.id = id  # type: long
        # The partition filter expression.
        self.match_expression = match_expression  # type: str
        # The time when the partition filter expression was modified.
        self.modify_time = modify_time  # type: long
        # The ID of the Alibaba Cloud account that is used to modify the partition filter expression.
        self.modify_user = modify_user  # type: str
        # The ID of the Alibaba Cloud account that is used to configure the partition filter expression.
        self.on_duty = on_duty  # type: str
        # The name of the Alibaba Cloud account that is used to configure the partition filter expression.
        self.on_duty_account_name = on_duty_account_name  # type: str
        # The name of the compute engine instance or data source.
        self.project_name = project_name  # type: str
        # The information about the node with which the partition filter expression is associated. The information includes the following items:
        # 
        # *   ProjectName: the name of the workspace to which the node belongs.
        # *   NodeID: the ID of the node.
        self.relative_node = relative_node  # type: str
        # Indicates that the partition filter expression is at the SQL level.
        self.sql = sql  # type: int
        # The name of the partitioned table.
        self.table_name = table_name  # type: str
        # The node.
        self.task = task  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetQualityEntityResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.entity_level is not None:
            result['EntityLevel'] = self.entity_level
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.followers is not None:
            result['Followers'] = self.followers
        if self.has_relative_node is not None:
            result['HasRelativeNode'] = self.has_relative_node
        if self.id is not None:
            result['Id'] = self.id
        if self.match_expression is not None:
            result['MatchExpression'] = self.match_expression
        if self.modify_time is not None:
            result['ModifyTime'] = self.modify_time
        if self.modify_user is not None:
            result['ModifyUser'] = self.modify_user
        if self.on_duty is not None:
            result['OnDuty'] = self.on_duty
        if self.on_duty_account_name is not None:
            result['OnDutyAccountName'] = self.on_duty_account_name
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.relative_node is not None:
            result['RelativeNode'] = self.relative_node
        if self.sql is not None:
            result['Sql'] = self.sql
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.task is not None:
            result['Task'] = self.task
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('EntityLevel') is not None:
            self.entity_level = m.get('EntityLevel')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('Followers') is not None:
            self.followers = m.get('Followers')
        if m.get('HasRelativeNode') is not None:
            self.has_relative_node = m.get('HasRelativeNode')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('MatchExpression') is not None:
            self.match_expression = m.get('MatchExpression')
        if m.get('ModifyTime') is not None:
            self.modify_time = m.get('ModifyTime')
        if m.get('ModifyUser') is not None:
            self.modify_user = m.get('ModifyUser')
        if m.get('OnDuty') is not None:
            self.on_duty = m.get('OnDuty')
        if m.get('OnDutyAccountName') is not None:
            self.on_duty_account_name = m.get('OnDutyAccountName')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('RelativeNode') is not None:
            self.relative_node = m.get('RelativeNode')
        if m.get('Sql') is not None:
            self.sql = m.get('Sql')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('Task') is not None:
            self.task = m.get('Task')
        return self


class GetQualityEntityResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The information about the partition filter expression.
        self.data = data  # type: list[GetQualityEntityResponseBodyData]
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetQualityEntityResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = GetQualityEntityResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetQualityEntityResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetQualityEntityResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetQualityEntityResponse, self).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=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 = GetQualityEntityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetQualityFollowerRequest(TeaModel):
    def __init__(self, entity_id=None, project_id=None, project_name=None):
        self.entity_id = entity_id  # type: long
        self.project_id = project_id  # type: long
        self.project_name = project_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetQualityFollowerRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class GetQualityFollowerResponseBodyData(TeaModel):
    def __init__(self, alarm_mode=None, create_time=None, entity_id=None, follower=None, follower_account_name=None,
                 id=None, modify_time=None, project_name=None, table_name=None):
        self.alarm_mode = alarm_mode  # type: int
        self.create_time = create_time  # type: long
        self.entity_id = entity_id  # type: str
        self.follower = follower  # type: str
        self.follower_account_name = follower_account_name  # type: str
        self.id = id  # type: long
        self.modify_time = modify_time  # type: long
        self.project_name = project_name  # type: str
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetQualityFollowerResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alarm_mode is not None:
            result['AlarmMode'] = self.alarm_mode
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.follower is not None:
            result['Follower'] = self.follower
        if self.follower_account_name is not None:
            result['FollowerAccountName'] = self.follower_account_name
        if self.id is not None:
            result['Id'] = self.id
        if self.modify_time is not None:
            result['ModifyTime'] = self.modify_time
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlarmMode') is not None:
            self.alarm_mode = m.get('AlarmMode')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('Follower') is not None:
            self.follower = m.get('Follower')
        if m.get('FollowerAccountName') is not None:
            self.follower_account_name = m.get('FollowerAccountName')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('ModifyTime') is not None:
            self.modify_time = m.get('ModifyTime')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class GetQualityFollowerResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: list[GetQualityFollowerResponseBodyData]
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetQualityFollowerResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = GetQualityFollowerResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetQualityFollowerResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetQualityFollowerResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetQualityFollowerResponse, self).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=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 = GetQualityFollowerResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetQualityRuleRequest(TeaModel):
    def __init__(self, project_id=None, project_name=None, rule_id=None):
        self.project_id = project_id  # type: long
        # The name of the compute engine instance or data source.
        self.project_name = project_name  # type: str
        # The ID of the monitoring rule. You can call the [ListQualityRules](~~173995~~) operation to query the ID.
        self.rule_id = rule_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetQualityRuleRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.rule_id is not None:
            result['RuleId'] = self.rule_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('RuleId') is not None:
            self.rule_id = m.get('RuleId')
        return self


class GetQualityRuleResponseBodyData(TeaModel):
    def __init__(self, block_type=None, checker=None, checker_name=None, comment=None, critical_threshold=None,
                 entity_id=None, expect_value=None, fix_check=None, id=None, method_id=None, method_name=None, on_duty=None,
                 on_duty_account_name=None, open_switch=None, operator=None, predict_type=None, property=None, rule_name=None,
                 rule_type=None, template_id=None, template_name=None, trend=None, warning_threshold=None,
                 where_condition=None):
        # The strength of the monitoring rule. The strength of a monitoring rule indicates the importance of the rule. Valid values:
        # 
        # *   1: indicates that the monitoring rule is a strong rule.
        # 
        # *   0: indicates that the monitoring rule is a weak rule.
        # 
        #     You can specify whether a monitoring rule is a strong rule based on your business requirements. If a strong rule is used and an error alert is triggered, nodes are blocked.
        self.block_type = block_type  # type: int
        # The ID of the checker. The value of this parameter corresponds to the ID at the frontend and is converted from the ID of the primary key.
        self.checker = checker  # type: int
        # The name of the checker.
        self.checker_name = checker_name  # type: str
        # The description of the monitoring rule.
        self.comment = comment  # type: str
        # The threshold for an error alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements. If a strong rule is used and an error alert is triggered, nodes are blocked.
        self.critical_threshold = critical_threshold  # type: str
        # The ID of the partition filter expression.
        self.entity_id = entity_id  # type: long
        # The expected value.
        self.expect_value = expect_value  # type: str
        # Indicates whether the monitoring is performed based on a fixed value.
        self.fix_check = fix_check  # type: bool
        # The ID of the monitoring rule.
        self.id = id  # type: long
        # The ID of the sampling method of the monitoring rule.
        self.method_id = method_id  # type: int
        # The name of the method that is used to collect sample data, such as avg, count, sum, min, max, count_distinct, user_defined, table_count, table_size, table_dt_load_count, table_dt_refuseload_count, null_value, null_value/table_count, (table_count-count_distinct)/table_count, or table_count-count_distinct.
        self.method_name = method_name  # type: str
        # The ID of the Alibaba Cloud account that is used to configure the monitoring rule.
        self.on_duty = on_duty  # type: str
        # The name of the Alibaba Cloud account that is used to configure the monitoring rule.
        self.on_duty_account_name = on_duty_account_name  # type: str
        self.open_switch = open_switch  # type: bool
        # The comparison operator of the monitoring rule.
        self.operator = operator  # type: str
        # Indicates whether the threshold is a dynamic threshold. Valid values:
        # 
        # *   0: The threshold is not a dynamic threshold.
        # *   1: The threshold is a dynamic threshold.
        self.predict_type = predict_type  # type: int
        # The field that is monitored. This field is a column name in the data source table that is monitored.
        self.property = property  # type: str
        # The name of the monitoring rule.
        self.rule_name = rule_name  # type: str
        # The type of the monitoring rule.
        self.rule_type = rule_type  # type: int
        # The ID of the monitoring template.
        self.template_id = template_id  # type: int
        # The name of the monitoring template.
        self.template_name = template_name  # type: str
        # The trend of the monitoring result.
        self.trend = trend  # type: str
        # The threshold for a warning alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements.
        self.warning_threshold = warning_threshold  # type: str
        # The filter condition or custom SQL statement that is used for monitoring.
        self.where_condition = where_condition  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetQualityRuleResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.block_type is not None:
            result['BlockType'] = self.block_type
        if self.checker is not None:
            result['Checker'] = self.checker
        if self.checker_name is not None:
            result['CheckerName'] = self.checker_name
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.critical_threshold is not None:
            result['CriticalThreshold'] = self.critical_threshold
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.expect_value is not None:
            result['ExpectValue'] = self.expect_value
        if self.fix_check is not None:
            result['FixCheck'] = self.fix_check
        if self.id is not None:
            result['Id'] = self.id
        if self.method_id is not None:
            result['MethodId'] = self.method_id
        if self.method_name is not None:
            result['MethodName'] = self.method_name
        if self.on_duty is not None:
            result['OnDuty'] = self.on_duty
        if self.on_duty_account_name is not None:
            result['OnDutyAccountName'] = self.on_duty_account_name
        if self.open_switch is not None:
            result['OpenSwitch'] = self.open_switch
        if self.operator is not None:
            result['Operator'] = self.operator
        if self.predict_type is not None:
            result['PredictType'] = self.predict_type
        if self.property is not None:
            result['Property'] = self.property
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        if self.rule_type is not None:
            result['RuleType'] = self.rule_type
        if self.template_id is not None:
            result['TemplateId'] = self.template_id
        if self.template_name is not None:
            result['TemplateName'] = self.template_name
        if self.trend is not None:
            result['Trend'] = self.trend
        if self.warning_threshold is not None:
            result['WarningThreshold'] = self.warning_threshold
        if self.where_condition is not None:
            result['WhereCondition'] = self.where_condition
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BlockType') is not None:
            self.block_type = m.get('BlockType')
        if m.get('Checker') is not None:
            self.checker = m.get('Checker')
        if m.get('CheckerName') is not None:
            self.checker_name = m.get('CheckerName')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CriticalThreshold') is not None:
            self.critical_threshold = m.get('CriticalThreshold')
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('ExpectValue') is not None:
            self.expect_value = m.get('ExpectValue')
        if m.get('FixCheck') is not None:
            self.fix_check = m.get('FixCheck')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('MethodId') is not None:
            self.method_id = m.get('MethodId')
        if m.get('MethodName') is not None:
            self.method_name = m.get('MethodName')
        if m.get('OnDuty') is not None:
            self.on_duty = m.get('OnDuty')
        if m.get('OnDutyAccountName') is not None:
            self.on_duty_account_name = m.get('OnDutyAccountName')
        if m.get('OpenSwitch') is not None:
            self.open_switch = m.get('OpenSwitch')
        if m.get('Operator') is not None:
            self.operator = m.get('Operator')
        if m.get('PredictType') is not None:
            self.predict_type = m.get('PredictType')
        if m.get('Property') is not None:
            self.property = m.get('Property')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        if m.get('RuleType') is not None:
            self.rule_type = m.get('RuleType')
        if m.get('TemplateId') is not None:
            self.template_id = m.get('TemplateId')
        if m.get('TemplateName') is not None:
            self.template_name = m.get('TemplateName')
        if m.get('Trend') is not None:
            self.trend = m.get('Trend')
        if m.get('WarningThreshold') is not None:
            self.warning_threshold = m.get('WarningThreshold')
        if m.get('WhereCondition') is not None:
            self.where_condition = m.get('WhereCondition')
        return self


class GetQualityRuleResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The information of the monitoring rule.
        self.data = data  # type: GetQualityRuleResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetQualityRuleResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetQualityRuleResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetQualityRuleResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetQualityRuleResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetQualityRuleResponse, self).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=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 = GetQualityRuleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetRemindRequest(TeaModel):
    def __init__(self, remind_id=None):
        # The ID of the custom alert rule.
        self.remind_id = remind_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetRemindRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.remind_id is not None:
            result['RemindId'] = self.remind_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RemindId') is not None:
            self.remind_id = m.get('RemindId')
        return self


class GetRemindResponseBodyDataBaselines(TeaModel):
    def __init__(self, baseline_id=None, baseline_name=None):
        # The ID of the baseline.
        self.baseline_id = baseline_id  # type: long
        # The name of the baseline.
        self.baseline_name = baseline_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetRemindResponseBodyDataBaselines, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        return self


class GetRemindResponseBodyDataBizProcesses(TeaModel):
    def __init__(self, biz_id=None, biz_process_name=None):
        # The ID of the workflow.
        self.biz_id = biz_id  # type: long
        # The name of the workflow.
        self.biz_process_name = biz_process_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetRemindResponseBodyDataBizProcesses, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_id is not None:
            result['BizId'] = self.biz_id
        if self.biz_process_name is not None:
            result['BizProcessName'] = self.biz_process_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizId') is not None:
            self.biz_id = m.get('BizId')
        if m.get('BizProcessName') is not None:
            self.biz_process_name = m.get('BizProcessName')
        return self


class GetRemindResponseBodyDataNodes(TeaModel):
    def __init__(self, node_id=None, node_name=None, owner=None, project_id=None):
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The ID of the Alibaba Cloud account used by the owner of the node.
        self.owner = owner  # type: str
        # The ID of the workspace to which the node belongs.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetRemindResponseBodyDataNodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetRemindResponseBodyDataProjects(TeaModel):
    def __init__(self, project_id=None):
        # The ID of the workspace.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetRemindResponseBodyDataProjects, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetRemindResponseBodyDataRobots(TeaModel):
    def __init__(self, at_all=None, web_url=None):
        # Indicates whether all group members are notified when the alert notification is sent to a DingTalk group. Valid values: true and false.
        self.at_all = at_all  # type: bool
        # The webhook URL of the DingTalk chatbot.
        self.web_url = web_url  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetRemindResponseBodyDataRobots, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.at_all is not None:
            result['AtAll'] = self.at_all
        if self.web_url is not None:
            result['WebUrl'] = self.web_url
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AtAll') is not None:
            self.at_all = m.get('AtAll')
        if m.get('WebUrl') is not None:
            self.web_url = m.get('WebUrl')
        return self


class GetRemindResponseBodyData(TeaModel):
    def __init__(self, alert_interval=None, alert_methods=None, alert_targets=None, alert_unit=None, baselines=None,
                 biz_processes=None, detail=None, dnd_end=None, dnd_start=None, founder=None, max_alert_times=None, nodes=None,
                 projects=None, remind_id=None, remind_name=None, remind_type=None, remind_unit=None, robots=None,
                 useflag=None, webhooks=None):
        # The minimum interval at which alerts are reported. Unit: seconds.
        self.alert_interval = alert_interval  # type: int
        # The notification method. Valid values:
        # 
        # *   MAIL: Alert notifications are sent by emails.
        # 
        # *   SMS: Alert notifications are sent by text messages.
        # 
        #     Alert notifications can be sent by text messages only in the Singapore (Singapore), Malaysia (Kuala Lumpur), and Germany (Frankfurt) regions.
        # 
        # *   Multiple notification methods are separated by commas (,).
        self.alert_methods = alert_methods  # type: list[str]
        # *   If the value of the AlertUnit parameter is OWNER, this parameter is left empty.
        # *   If the value of the AlertUnit parameter is OTHER, the ID of the Alibaba Cloud account used by the specified user is returned. Multiple IDs are separated by commas (,).
        self.alert_targets = alert_targets  # type: list[str]
        # The recipient of the alert. Valid values: OWNER and OTHER. A value of OWNER indicates the node owner. A value of OTHER indicates a specified user.
        self.alert_unit = alert_unit  # type: str
        # The baselines to which the custom alert rule is applied. This parameter is returned if the value of the RemindUnit parameter is BASELINE.
        self.baselines = baselines  # type: list[GetRemindResponseBodyDataBaselines]
        # The workflows to which the custom alert rule is applied. This parameter is returned if the value of the RemindUnit parameter is BIZPROCESS.
        self.biz_processes = biz_processes  # type: list[GetRemindResponseBodyDataBizProcesses]
        # *   If the value of the RemindType parameter is FINISHED, this parameter is left empty.
        # *   If the value of the RemindType parameter is UNFINISHED, the trigger conditions are returned as key-value pairs. Example: {"hour":23,"minu":59}. Valid values of hour: 0 to 47. Valid values of minu: 0 to 59.
        # *   If the value of the RemindType parameter is ERROR, this parameter is left empty.
        # *   If the value of the RemindType parameter is CYCLE_UNFINISHED, the trigger conditions are returned as key-value pairs. Example: {"1":"05:50","2":"06:50","3":"07:50","4":"08:50","5":"09:50","6":"10:50","7":"11:50","8":"12:50","9":"13:50","10":"14:50","11":"15:50","12":"16:50","13":"17:50","14":"18:50","15":"19:50","16":"20:50","17":"21:50","18":"22:50","19":"23:50","20":"24:50","21":"25:50"}. The key indicates the ID of the cycle. Valid values: 1 to 288. The value indicates the timeout period of the node that is run in the cycle. The value is in the hh:mm format. Valid values of hh: 0 to 47. Valid values of mm: 0 to 59.
        # *   If the value of the RemindType parameter is TIMEOUT, the timeout period is returned. Unit: seconds. Example: 1800. This value indicates that an alert is reported if the node is run for more than 30 minutes.
        self.detail = detail  # type: str
        # The end time of the quiet hours. The value is in the hh:mm format. Valid values of hh: 0 to 23. Valid values of mm: 0 to 59.
        self.dnd_end = dnd_end  # type: str
        # The start time of the quiet hours. The value is in the hh:mm format. Valid values of hh: 0 to 23. Valid values of mm: 0 to 59.
        self.dnd_start = dnd_start  # type: str
        # The ID of the Alibaba Cloud account used by the creator of the custom alert rule.
        self.founder = founder  # type: str
        # The maximum number of alerts.
        self.max_alert_times = max_alert_times  # type: int
        # The nodes to which the custom alert rule is applied. This parameter is returned if the value of the RemindUnit parameter is NODE.
        self.nodes = nodes  # type: list[GetRemindResponseBodyDataNodes]
        # The workspaces to which the custom alert rule is applied. This parameter is returned if the value of the RemindUnit parameter is PROJECT.
        self.projects = projects  # type: list[GetRemindResponseBodyDataProjects]
        # The ID of the custom alert rule.
        self.remind_id = remind_id  # type: long
        # The name of the custom alert rule.
        self.remind_name = remind_name  # type: str
        # The conditions that trigger an alert. Valid values: FINISHED, UNFINISHED, ERROR, CYCLE_UNFINISHED, and TIMEOUT. A value of FINISHED indicates that the node is run. A value of UNFINISHED indicates that the node is still running at the specified point in time. A value of ERROR indicates that an error occurs when the node is running. A value of CYCLE_UNFINISHED indicates that the node is still running in the specified cycle. A value of TIMEOUT indicates that the node times out.
        self.remind_type = remind_type  # type: str
        # The type of the object to which the custom alert rule is applied. Valid values: NODE, BASELINE, PROJECT, and BIZPROCESS. A value of NODE indicates that the monitored object is a node. A value of BASELINE indicates that the monitored object is a baseline. A value of PROJECT indicates that the monitored object is a workspace. A value of BIZPROCESS indicates that the monitored object is a workflow.
        self.remind_unit = remind_unit  # type: str
        # The webhook URLs of the DingTalk chatbots.
        self.robots = robots  # type: list[GetRemindResponseBodyDataRobots]
        # Indicates whether the custom alert rule is enabled. Valid values: true and false.
        self.useflag = useflag  # type: bool
        # -\
        self.webhooks = webhooks  # type: list[str]

    def validate(self):
        if self.baselines:
            for k in self.baselines:
                if k:
                    k.validate()
        if self.biz_processes:
            for k in self.biz_processes:
                if k:
                    k.validate()
        if self.nodes:
            for k in self.nodes:
                if k:
                    k.validate()
        if self.projects:
            for k in self.projects:
                if k:
                    k.validate()
        if self.robots:
            for k in self.robots:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetRemindResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_interval is not None:
            result['AlertInterval'] = self.alert_interval
        if self.alert_methods is not None:
            result['AlertMethods'] = self.alert_methods
        if self.alert_targets is not None:
            result['AlertTargets'] = self.alert_targets
        if self.alert_unit is not None:
            result['AlertUnit'] = self.alert_unit
        result['Baselines'] = []
        if self.baselines is not None:
            for k in self.baselines:
                result['Baselines'].append(k.to_map() if k else None)
        result['BizProcesses'] = []
        if self.biz_processes is not None:
            for k in self.biz_processes:
                result['BizProcesses'].append(k.to_map() if k else None)
        if self.detail is not None:
            result['Detail'] = self.detail
        if self.dnd_end is not None:
            result['DndEnd'] = self.dnd_end
        if self.dnd_start is not None:
            result['DndStart'] = self.dnd_start
        if self.founder is not None:
            result['Founder'] = self.founder
        if self.max_alert_times is not None:
            result['MaxAlertTimes'] = self.max_alert_times
        result['Nodes'] = []
        if self.nodes is not None:
            for k in self.nodes:
                result['Nodes'].append(k.to_map() if k else None)
        result['Projects'] = []
        if self.projects is not None:
            for k in self.projects:
                result['Projects'].append(k.to_map() if k else None)
        if self.remind_id is not None:
            result['RemindId'] = self.remind_id
        if self.remind_name is not None:
            result['RemindName'] = self.remind_name
        if self.remind_type is not None:
            result['RemindType'] = self.remind_type
        if self.remind_unit is not None:
            result['RemindUnit'] = self.remind_unit
        result['Robots'] = []
        if self.robots is not None:
            for k in self.robots:
                result['Robots'].append(k.to_map() if k else None)
        if self.useflag is not None:
            result['Useflag'] = self.useflag
        if self.webhooks is not None:
            result['Webhooks'] = self.webhooks
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertInterval') is not None:
            self.alert_interval = m.get('AlertInterval')
        if m.get('AlertMethods') is not None:
            self.alert_methods = m.get('AlertMethods')
        if m.get('AlertTargets') is not None:
            self.alert_targets = m.get('AlertTargets')
        if m.get('AlertUnit') is not None:
            self.alert_unit = m.get('AlertUnit')
        self.baselines = []
        if m.get('Baselines') is not None:
            for k in m.get('Baselines'):
                temp_model = GetRemindResponseBodyDataBaselines()
                self.baselines.append(temp_model.from_map(k))
        self.biz_processes = []
        if m.get('BizProcesses') is not None:
            for k in m.get('BizProcesses'):
                temp_model = GetRemindResponseBodyDataBizProcesses()
                self.biz_processes.append(temp_model.from_map(k))
        if m.get('Detail') is not None:
            self.detail = m.get('Detail')
        if m.get('DndEnd') is not None:
            self.dnd_end = m.get('DndEnd')
        if m.get('DndStart') is not None:
            self.dnd_start = m.get('DndStart')
        if m.get('Founder') is not None:
            self.founder = m.get('Founder')
        if m.get('MaxAlertTimes') is not None:
            self.max_alert_times = m.get('MaxAlertTimes')
        self.nodes = []
        if m.get('Nodes') is not None:
            for k in m.get('Nodes'):
                temp_model = GetRemindResponseBodyDataNodes()
                self.nodes.append(temp_model.from_map(k))
        self.projects = []
        if m.get('Projects') is not None:
            for k in m.get('Projects'):
                temp_model = GetRemindResponseBodyDataProjects()
                self.projects.append(temp_model.from_map(k))
        if m.get('RemindId') is not None:
            self.remind_id = m.get('RemindId')
        if m.get('RemindName') is not None:
            self.remind_name = m.get('RemindName')
        if m.get('RemindType') is not None:
            self.remind_type = m.get('RemindType')
        if m.get('RemindUnit') is not None:
            self.remind_unit = m.get('RemindUnit')
        self.robots = []
        if m.get('Robots') is not None:
            for k in m.get('Robots'):
                temp_model = GetRemindResponseBodyDataRobots()
                self.robots.append(temp_model.from_map(k))
        if m.get('Useflag') is not None:
            self.useflag = m.get('Useflag')
        if m.get('Webhooks') is not None:
            self.webhooks = m.get('Webhooks')
        return self


class GetRemindResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The details of the custom alert rule.
        self.data = data  # type: GetRemindResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The unique ID of the request. You can troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetRemindResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetRemindResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetRemindResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetRemindResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetRemindResponse, self).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=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 = GetRemindResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetSensitiveDataRequest(TeaModel):
    def __init__(self, name=None, page_no=None, page_size=None):
        # The parameters that you can specify to query the access records. Valid values:
        # 
        # *   dbType: the data type
        # *   instanceName: the name of the instance
        # *   databaseName: the name of the database
        # *   projectName: the name of the workspace
        # *   clusterName: the name of the cluster
        # 
        # The following example shows the parameters configured to query the access records of the sensitive data in the abc database of the ABC Hologres instance:
        # 
        # {"dbType":"hologres","instanceName":"ABC","databaseName":"abc"}
        # 
        # You must specify the parameters based on the compute engine that you use in your business.
        self.name = name  # type: str
        # The number of the page to return. Minimum value:1.
        self.page_no = page_no  # type: int
        # The number of entries to return on each page. Maximum value: 1000.
        self.page_size = page_size  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetSensitiveDataRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.name is not None:
            result['Name'] = self.name
        if self.page_no is not None:
            result['PageNo'] = self.page_no
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('PageNo') is not None:
            self.page_no = m.get('PageNo')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        return self


class GetSensitiveDataResponseBody(TeaModel):
    def __init__(self, request_id=None, sensitive_data=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # The information of the sensitive data returned. The information includes totalCount and sensDatas.
        # 
        # sensDatas includes the following parameters:
        # 
        # *   guid: the ID of the metadata of the tenant. For example, the ID of the metadata in the MaxCompute compute engine is in the Project name.Table name.Column name format.
        # *   sensType: the type of the sensitive data.
        # *   sensLevel: the sensitivity level of the sensitive data.
        self.sensitive_data = sensitive_data  # type: dict[str, any]

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetSensitiveDataResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.sensitive_data is not None:
            result['SensitiveData'] = self.sensitive_data
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('SensitiveData') is not None:
            self.sensitive_data = m.get('SensitiveData')
        return self


class GetSensitiveDataResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetSensitiveDataResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetSensitiveDataResponse, self).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=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 = GetSensitiveDataResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetSuccessInstanceTrendRequest(TeaModel):
    def __init__(self, project_id=None):
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetSuccessInstanceTrendRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class GetSuccessInstanceTrendResponseBodyInstanceStatusTrendAvgTrend(TeaModel):
    def __init__(self, count=None, time_point=None):
        self.count = count  # type: int
        self.time_point = time_point  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetSuccessInstanceTrendResponseBodyInstanceStatusTrendAvgTrend, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.time_point is not None:
            result['TimePoint'] = self.time_point
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('TimePoint') is not None:
            self.time_point = m.get('TimePoint')
        return self


class GetSuccessInstanceTrendResponseBodyInstanceStatusTrendTodayTrend(TeaModel):
    def __init__(self, count=None, time_point=None):
        self.count = count  # type: int
        self.time_point = time_point  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetSuccessInstanceTrendResponseBodyInstanceStatusTrendTodayTrend, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.time_point is not None:
            result['TimePoint'] = self.time_point
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('TimePoint') is not None:
            self.time_point = m.get('TimePoint')
        return self


class GetSuccessInstanceTrendResponseBodyInstanceStatusTrendYesterdayTrend(TeaModel):
    def __init__(self, count=None, time_point=None):
        self.count = count  # type: int
        self.time_point = time_point  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetSuccessInstanceTrendResponseBodyInstanceStatusTrendYesterdayTrend, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.time_point is not None:
            result['TimePoint'] = self.time_point
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('TimePoint') is not None:
            self.time_point = m.get('TimePoint')
        return self


class GetSuccessInstanceTrendResponseBodyInstanceStatusTrend(TeaModel):
    def __init__(self, avg_trend=None, today_trend=None, yesterday_trend=None):
        self.avg_trend = avg_trend  # type: list[GetSuccessInstanceTrendResponseBodyInstanceStatusTrendAvgTrend]
        self.today_trend = today_trend  # type: list[GetSuccessInstanceTrendResponseBodyInstanceStatusTrendTodayTrend]
        self.yesterday_trend = yesterday_trend  # type: list[GetSuccessInstanceTrendResponseBodyInstanceStatusTrendYesterdayTrend]

    def validate(self):
        if self.avg_trend:
            for k in self.avg_trend:
                if k:
                    k.validate()
        if self.today_trend:
            for k in self.today_trend:
                if k:
                    k.validate()
        if self.yesterday_trend:
            for k in self.yesterday_trend:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetSuccessInstanceTrendResponseBodyInstanceStatusTrend, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['AvgTrend'] = []
        if self.avg_trend is not None:
            for k in self.avg_trend:
                result['AvgTrend'].append(k.to_map() if k else None)
        result['TodayTrend'] = []
        if self.today_trend is not None:
            for k in self.today_trend:
                result['TodayTrend'].append(k.to_map() if k else None)
        result['YesterdayTrend'] = []
        if self.yesterday_trend is not None:
            for k in self.yesterday_trend:
                result['YesterdayTrend'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.avg_trend = []
        if m.get('AvgTrend') is not None:
            for k in m.get('AvgTrend'):
                temp_model = GetSuccessInstanceTrendResponseBodyInstanceStatusTrendAvgTrend()
                self.avg_trend.append(temp_model.from_map(k))
        self.today_trend = []
        if m.get('TodayTrend') is not None:
            for k in m.get('TodayTrend'):
                temp_model = GetSuccessInstanceTrendResponseBodyInstanceStatusTrendTodayTrend()
                self.today_trend.append(temp_model.from_map(k))
        self.yesterday_trend = []
        if m.get('YesterdayTrend') is not None:
            for k in m.get('YesterdayTrend'):
                temp_model = GetSuccessInstanceTrendResponseBodyInstanceStatusTrendYesterdayTrend()
                self.yesterday_trend.append(temp_model.from_map(k))
        return self


class GetSuccessInstanceTrendResponseBody(TeaModel):
    def __init__(self, instance_status_trend=None, request_id=None):
        self.instance_status_trend = instance_status_trend  # type: GetSuccessInstanceTrendResponseBodyInstanceStatusTrend
        self.request_id = request_id  # type: str

    def validate(self):
        if self.instance_status_trend:
            self.instance_status_trend.validate()

    def to_map(self):
        _map = super(GetSuccessInstanceTrendResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_status_trend is not None:
            result['InstanceStatusTrend'] = self.instance_status_trend.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceStatusTrend') is not None:
            temp_model = GetSuccessInstanceTrendResponseBodyInstanceStatusTrend()
            self.instance_status_trend = temp_model.from_map(m['InstanceStatusTrend'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class GetSuccessInstanceTrendResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetSuccessInstanceTrendResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetSuccessInstanceTrendResponse, self).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=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 = GetSuccessInstanceTrendResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetTopicRequest(TeaModel):
    def __init__(self, topic_id=None):
        # The ID of the request. You can troubleshoot issues based on the ID.
        self.topic_id = topic_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetTopicRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.topic_id is not None:
            result['TopicId'] = self.topic_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TopicId') is not None:
            self.topic_id = m.get('TopicId')
        return self


class GetTopicResponseBodyData(TeaModel):
    def __init__(self, add_time=None, alert_time=None, assigner=None, baseline_buffer=None, baseline_id=None,
                 baseline_in_group_id=None, baseline_name=None, baseline_status=None, buffer=None, deal_time=None, deal_user=None,
                 fix_time=None, happen_time=None, instance_id=None, next_alert_time=None, node_id=None, node_name=None,
                 owner=None, project_id=None, topic_id=None, topic_name=None, topic_status=None, topic_type=None):
        self.add_time = add_time  # type: long
        # The ID of the Apsara Stack tenant account used by the alert recipient.
        self.alert_time = alert_time  # type: long
        # The timestamp when the event was found.
        self.assigner = assigner  # type: str
        # The status of the event. Valid values: IGNORE, NEW, FIXING, and RECOVER. A value of IGNORE indicates that the event is ignored. A value of NEW indicates that the event is a new event. A value of FIXING indicates that the event is being processed. A value of RECOVER indicates that the event is processed.
        self.baseline_buffer = baseline_buffer  # type: long
        # The timestamp when the first alert was reported.
        self.baseline_id = baseline_id  # type: long
        # The type of the event. Valid values: SLOW and ERROR. A value of SLOW indicates that the duration of the task is significantly longer than the average duration of the task in previous cycles. A value of ERROR indicates that the task fails to run.
        self.baseline_in_group_id = baseline_in_group_id  # type: int
        # The name of the node that triggered the event.
        self.baseline_name = baseline_name  # type: str
        # The timestamp when the system reports the next alert.
        self.baseline_status = baseline_status  # type: str
        # The ID of the event.
        self.buffer = buffer  # type: long
        # The name of the baseline to which the worst baseline instance belongs.
        self.deal_time = deal_time  # type: long
        # The ID of the baseline to which the worst baseline instance belongs.
        self.deal_user = deal_user  # type: str
        # The margin of the worst baseline instance. Unit: seconds.
        self.fix_time = fix_time  # type: long
        # The ID of the Apsara Stack tenant account used by the user who last processed the event.
        self.happen_time = happen_time  # type: long
        # The ID of the cycle of the worst baseline instance.
        self.instance_id = instance_id  # type: long
        # The timestamp when the event was processed.
        self.next_alert_time = next_alert_time  # type: long
        self.node_id = node_id  # type: long
        # The margin of the event. Unit: seconds.
        self.node_name = node_name  # type: str
        # The status of the baseline. Valid values: ERROR, SAFE, DANGROUS, and OVER. A value of ERROR indicates that no nodes are associated with the baseline, or all nodes associated with the baseline are suspended. A value of SAFE indicates that nodes are run before the alert duration begins. A value of DANGROUS indicates that nodes are still running after the alert duration ends but the committed time does not arrive. A value of OVER indicates that nodes are still running after the committed time.
        self.owner = owner  # type: str
        # The ID of the instance that triggered the event.
        self.project_id = project_id  # type: long
        # The ID of the node that triggered the event.
        self.topic_id = topic_id  # type: long
        # The ID of the workspace to which the node that triggered the event belongs.
        self.topic_name = topic_name  # type: str
        # The timestamp when the event was last processed.
        self.topic_status = topic_status  # type: str
        # The timestamp when the system event occurred. A time difference may exist between the time when the event occurred and the time when the event was found.
        self.topic_type = topic_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetTopicResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.add_time is not None:
            result['AddTime'] = self.add_time
        if self.alert_time is not None:
            result['AlertTime'] = self.alert_time
        if self.assigner is not None:
            result['Assigner'] = self.assigner
        if self.baseline_buffer is not None:
            result['BaselineBuffer'] = self.baseline_buffer
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_in_group_id is not None:
            result['BaselineInGroupId'] = self.baseline_in_group_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.baseline_status is not None:
            result['BaselineStatus'] = self.baseline_status
        if self.buffer is not None:
            result['Buffer'] = self.buffer
        if self.deal_time is not None:
            result['DealTime'] = self.deal_time
        if self.deal_user is not None:
            result['DealUser'] = self.deal_user
        if self.fix_time is not None:
            result['FixTime'] = self.fix_time
        if self.happen_time is not None:
            result['HappenTime'] = self.happen_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.next_alert_time is not None:
            result['NextAlertTime'] = self.next_alert_time
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.topic_id is not None:
            result['TopicId'] = self.topic_id
        if self.topic_name is not None:
            result['TopicName'] = self.topic_name
        if self.topic_status is not None:
            result['TopicStatus'] = self.topic_status
        if self.topic_type is not None:
            result['TopicType'] = self.topic_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AddTime') is not None:
            self.add_time = m.get('AddTime')
        if m.get('AlertTime') is not None:
            self.alert_time = m.get('AlertTime')
        if m.get('Assigner') is not None:
            self.assigner = m.get('Assigner')
        if m.get('BaselineBuffer') is not None:
            self.baseline_buffer = m.get('BaselineBuffer')
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineInGroupId') is not None:
            self.baseline_in_group_id = m.get('BaselineInGroupId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('BaselineStatus') is not None:
            self.baseline_status = m.get('BaselineStatus')
        if m.get('Buffer') is not None:
            self.buffer = m.get('Buffer')
        if m.get('DealTime') is not None:
            self.deal_time = m.get('DealTime')
        if m.get('DealUser') is not None:
            self.deal_user = m.get('DealUser')
        if m.get('FixTime') is not None:
            self.fix_time = m.get('FixTime')
        if m.get('HappenTime') is not None:
            self.happen_time = m.get('HappenTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('NextAlertTime') is not None:
            self.next_alert_time = m.get('NextAlertTime')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TopicId') is not None:
            self.topic_id = m.get('TopicId')
        if m.get('TopicName') is not None:
            self.topic_name = m.get('TopicName')
        if m.get('TopicStatus') is not None:
            self.topic_status = m.get('TopicStatus')
        if m.get('TopicType') is not None:
            self.topic_type = m.get('TopicType')
        return self


class GetTopicResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The name of the event.
        self.data = data  # type: GetTopicResponseBodyData
        # The details of the event.
        self.error_code = error_code  # type: str
        # Indicates whether the request is successful.
        self.error_message = error_message  # type: str
        # The error message returned.
        self.http_status_code = http_status_code  # type: int
        # The error code returned.
        self.request_id = request_id  # type: str
        # The ID of the Apsara Stack tenant account used by the event owner.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetTopicResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetTopicResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetTopicResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetTopicResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetTopicResponse, self).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=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 = GetTopicResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetTopicInfluenceRequest(TeaModel):
    def __init__(self, topic_id=None):
        self.topic_id = topic_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetTopicInfluenceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.topic_id is not None:
            result['TopicId'] = self.topic_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TopicId') is not None:
            self.topic_id = m.get('TopicId')
        return self


class GetTopicInfluenceResponseBodyDataInfluences(TeaModel):
    def __init__(self, baseline_id=None, baseline_name=None, bizdate=None, buffer=None, in_group_id=None, owner=None,
                 priority=None, project_id=None, status=None):
        self.baseline_id = baseline_id  # type: long
        self.baseline_name = baseline_name  # type: str
        self.bizdate = bizdate  # type: long
        self.buffer = buffer  # type: long
        self.in_group_id = in_group_id  # type: int
        self.owner = owner  # type: str
        self.priority = priority  # type: int
        self.project_id = project_id  # type: long
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetTopicInfluenceResponseBodyDataInfluences, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.buffer is not None:
            result['Buffer'] = self.buffer
        if self.in_group_id is not None:
            result['InGroupId'] = self.in_group_id
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('Buffer') is not None:
            self.buffer = m.get('Buffer')
        if m.get('InGroupId') is not None:
            self.in_group_id = m.get('InGroupId')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class GetTopicInfluenceResponseBodyData(TeaModel):
    def __init__(self, influences=None, topic_id=None):
        self.influences = influences  # type: list[GetTopicInfluenceResponseBodyDataInfluences]
        self.topic_id = topic_id  # type: long

    def validate(self):
        if self.influences:
            for k in self.influences:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(GetTopicInfluenceResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Influences'] = []
        if self.influences is not None:
            for k in self.influences:
                result['Influences'].append(k.to_map() if k else None)
        if self.topic_id is not None:
            result['TopicId'] = self.topic_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.influences = []
        if m.get('Influences') is not None:
            for k in m.get('Influences'):
                temp_model = GetTopicInfluenceResponseBodyDataInfluences()
                self.influences.append(temp_model.from_map(k))
        if m.get('TopicId') is not None:
            self.topic_id = m.get('TopicId')
        return self


class GetTopicInfluenceResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: GetTopicInfluenceResponseBodyData
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(GetTopicInfluenceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = GetTopicInfluenceResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class GetTopicInfluenceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetTopicInfluenceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(GetTopicInfluenceResponse, self).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=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 = GetTopicInfluenceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ImportDataSourcesRequest(TeaModel):
    def __init__(self, data_sources=None, project_id=None):
        # The configurations of the data sources to be imported. The Name, DataSourceType, SubType, Description, Content, and EnvType fields are required. For more information about the fields, see [CreateDataSource](~~211429~~).
        self.data_sources = data_sources  # type: str
        # The ID of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace ID.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ImportDataSourcesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data_sources is not None:
            result['DataSources'] = self.data_sources
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DataSources') is not None:
            self.data_sources = m.get('DataSources')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ImportDataSourcesResponseBodyData(TeaModel):
    def __init__(self, message=None, status=None):
        # The reason why the data sources failed to be imported. If the data sources were imported, this parameter is left empty.
        self.message = message  # type: str
        # Indicates whether the data sources were imported. Valid values:
        # 
        # *   true: All the data sources were imported.
        # *   false: Some of the data sources failed to be imported. You can troubleshoot issues based on the Message parameter.
        self.status = status  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(ImportDataSourcesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class ImportDataSourcesResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # The information about the import operation.
        self.data = data  # type: ImportDataSourcesResponseBodyData
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ImportDataSourcesResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ImportDataSourcesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ImportDataSourcesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ImportDataSourcesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ImportDataSourcesResponse, self).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=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 = ImportDataSourcesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListAlertMessagesRequest(TeaModel):
    def __init__(self, alert_methods=None, alert_rule_types=None, alert_user=None, baseline_id=None,
                 begin_time=None, end_time=None, page_number=None, page_size=None, remind_id=None):
        # The notification method. Valid values:
        # 
        # *   MAIL: email
        # 
        # *   SMS: text message
        # 
        #     Alert notifications can be sent by text message only in the Singapore, Malaysia (Kuala Lumpur), and Germany (Frankfurt) regions.
        # 
        # You can specify multiple notification methods. Separate them with commas (,).
        self.alert_methods = alert_methods  # type: str
        # The type of the alert rule. Valid values: GLOBAL, USER_DEFINE, and OTHER. The value GLOBAL indicates that the alert rule is a global alert rule. The value USER_DEFINE indicates that the alert rule is customized by a user. The value OTHER indicates that the alert rule is a rule of another type. You can specify multiple types. Separate them with commas (,).
        self.alert_rule_types = alert_rule_types  # type: str
        # The ID of the Alibaba Cloud account used by the alert recipient.
        self.alert_user = alert_user  # type: str
        # The ID of the baseline. This parameter takes effect if the AlertRuleTypes parameter is set to GLOBAL.
        # 
        # You can configure either this parameter or RemindId.
        self.baseline_id = baseline_id  # type: long
        # The beginning of the time range to query. Specify the time in the yyyy-MM-dd\"T\"HH:mm:ssZ format. The time must be in UTC.
        self.begin_time = begin_time  # type: str
        # The end of the time range to query. Specify the time in the yyyy-MM-dd\"T\"HH:mm:ssZ format. The time must be in UTC.
        self.end_time = end_time  # type: str
        # The number of the page to return. Valid values: 1 to 30. Default value: 1.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the custom alert rule. This parameter takes effect if the AlertRuleTypes parameter is set to USER_DEFINE.
        # 
        # You can configure either this parameter or BaselineId.
        self.remind_id = remind_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListAlertMessagesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_methods is not None:
            result['AlertMethods'] = self.alert_methods
        if self.alert_rule_types is not None:
            result['AlertRuleTypes'] = self.alert_rule_types
        if self.alert_user is not None:
            result['AlertUser'] = self.alert_user
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.begin_time is not None:
            result['BeginTime'] = self.begin_time
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.remind_id is not None:
            result['RemindId'] = self.remind_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertMethods') is not None:
            self.alert_methods = m.get('AlertMethods')
        if m.get('AlertRuleTypes') is not None:
            self.alert_rule_types = m.get('AlertRuleTypes')
        if m.get('AlertUser') is not None:
            self.alert_user = m.get('AlertUser')
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BeginTime') is not None:
            self.begin_time = m.get('BeginTime')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('RemindId') is not None:
            self.remind_id = m.get('RemindId')
        return self


class ListAlertMessagesResponseBodyDataAlertMessagesInstances(TeaModel):
    def __init__(self, instance_id=None, node_id=None, node_name=None, project_id=None, status=None):
        # The ID of the instance.
        self.instance_id = instance_id  # type: long
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The ID of the workspace to which the node belongs.
        self.project_id = project_id  # type: long
        # The status of the instance. Valid values: NOT_RUN, WAIT_TIME, WAIT_RESOURCE, RUNNING, CHECKING, CHECKING_CONDITION, FAILURE, and SUCCESS. The value NOT_RUN indicates that the instance is not run. The value WAIT_TIME indicates that the instance is waiting to be run. The value WAIT_RESOURCE indicates that the instance is waiting for resources. The value RUNNING indicates that the instance is running. The value CHECKING indicates that data quality is being checked for the node. The value CHECKING_CONDITION indicates that branch conditions are being checked for the node. The value FAILURE indicates that the instance fails to run. The value SUCCESS indicates that the instance is successfully run.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListAlertMessagesResponseBodyDataAlertMessagesInstances, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class ListAlertMessagesResponseBodyDataAlertMessagesNodes(TeaModel):
    def __init__(self, node_id=None, node_name=None, owner=None, project_id=None):
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The ID of the Alibaba Cloud account used by the owner of the node.
        self.owner = owner  # type: str
        # The ID of the workspace to which the node belongs.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListAlertMessagesResponseBodyDataAlertMessagesNodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListAlertMessagesResponseBodyDataAlertMessagesSlaAlert(TeaModel):
    def __init__(self, baseline_id=None, baseline_name=None, baseline_owner=None, bizdate=None, in_group_id=None,
                 project_id=None, status=None):
        # The ID of the baseline.
        self.baseline_id = baseline_id  # type: long
        # The name of the baseline.
        self.baseline_name = baseline_name  # type: str
        # The ID of the Alibaba Cloud account used by the baseline owner. Multiple IDs are separated by commas (,).
        self.baseline_owner = baseline_owner  # type: str
        # The data timestamp of the baseline instance.
        self.bizdate = bizdate  # type: long
        # The ID of the cycle of the baseline instance. Valid values of the ID of an hour-level cycle: 1 to 24. The ID of a day-level cycle is 1.
        self.in_group_id = in_group_id  # type: int
        # The ID of the workspace to which the baseline belongs.
        self.project_id = project_id  # type: long
        # The status of the baseline. Valid values: ERROR, SAFE, DANGROUS, and OVER. The value ERROR indicates that no nodes are associated with the baseline, or all nodes associated with the baseline are suspended. The value SAFE indicates that nodes are run before the alert duration begins. The value DANGROUS indicates that nodes are still running after the alert duration ends but the committed time does not arrive. The value OVER indicates that nodes are still running after the committed time.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListAlertMessagesResponseBodyDataAlertMessagesSlaAlert, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.baseline_owner is not None:
            result['BaselineOwner'] = self.baseline_owner
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.in_group_id is not None:
            result['InGroupId'] = self.in_group_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('BaselineOwner') is not None:
            self.baseline_owner = m.get('BaselineOwner')
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('InGroupId') is not None:
            self.in_group_id = m.get('InGroupId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class ListAlertMessagesResponseBodyDataAlertMessagesTopics(TeaModel):
    def __init__(self, instance_id=None, node_id=None, topic_id=None, topic_name=None, topic_owner=None,
                 topic_status=None):
        # The ID of the instance that triggered the event.
        self.instance_id = instance_id  # type: long
        # The ID of the node that triggered the event.
        self.node_id = node_id  # type: long
        # The ID of the event.
        self.topic_id = topic_id  # type: long
        # The name of the event.
        self.topic_name = topic_name  # type: str
        # The ID of the Alibaba Cloud account used by the event owner.
        self.topic_owner = topic_owner  # type: str
        # The status of the event. Valid values: IGNORE, NEW, FIXING, and RECOVER. The value IGNORE indicates that the event is ignored. The value NEW indicates that the event is a new event. The value FIXING indicates that the event is being handled. The value RECOVER indicates that the event is handled.
        self.topic_status = topic_status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListAlertMessagesResponseBodyDataAlertMessagesTopics, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.topic_id is not None:
            result['TopicId'] = self.topic_id
        if self.topic_name is not None:
            result['TopicName'] = self.topic_name
        if self.topic_owner is not None:
            result['TopicOwner'] = self.topic_owner
        if self.topic_status is not None:
            result['TopicStatus'] = self.topic_status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('TopicId') is not None:
            self.topic_id = m.get('TopicId')
        if m.get('TopicName') is not None:
            self.topic_name = m.get('TopicName')
        if m.get('TopicOwner') is not None:
            self.topic_owner = m.get('TopicOwner')
        if m.get('TopicStatus') is not None:
            self.topic_status = m.get('TopicStatus')
        return self


class ListAlertMessagesResponseBodyDataAlertMessages(TeaModel):
    def __init__(self, alert_id=None, alert_message_status=None, alert_method=None, alert_time=None,
                 alert_user=None, content=None, instances=None, nodes=None, remind_id=None, remind_name=None, sla_alert=None,
                 source=None, topics=None):
        # The ID of the alert.
        self.alert_id = alert_id  # type: long
        # The sending status of the notification. Valid values: READY_TO_SEND, SEND_FAIL, SEND_SUCCESS, and SEND_OVERLIMIT. The value READY_TO_SEND indicates that the notification is waiting to be sent. The value SEND_FAIL indicates that the notification fails to be sent. The value SEND_SUCCESS indicates that the notification is sent. The value SEND_OVERLIMIT indicates that the number of notifications that are sent exceeds the upper limit.
        self.alert_message_status = alert_message_status  # type: str
        # The notification method. Valid values: MAIL, SMS, and PHONE. The value MAIL indicates that the notification is sent by email. The value SMS indicates that the notification is sent by text message. The value PHONE indicates that the notification is sent by phone call. Only DataWorks Professional Edition and more advanced editions support the PHONE notification method.
        self.alert_method = alert_method  # type: str
        # The timestamp when the alert was reported.
        self.alert_time = alert_time  # type: long
        # The ID of the Alibaba Cloud used by the alert recipient.
        self.alert_user = alert_user  # type: str
        # The content of the alert.
        self.content = content  # type: str
        # The instances that triggered the custom alert rule. This parameter is returned if the value of the Source parameter is REMIND_ALERT. This parameter is left empty if the value of the Source parameter is not REMIND_ALERT.
        self.instances = instances  # type: list[ListAlertMessagesResponseBodyDataAlertMessagesInstances]
        # The nodes returned for different alert sources.
        # 
        # *   The nodes that form a loop are returned if the value of the Source parameter is NODE_CYCLE_ALERT.
        # *   The nodes that are isolated are returned if the value of the Source parameter is NODE_LONELY_ALERT.
        self.nodes = nodes  # type: list[ListAlertMessagesResponseBodyDataAlertMessagesNodes]
        # The ID of the custom alert rule that was triggered. This parameter is returned if the value of the Source parameter is REMIND_ALERT.
        self.remind_id = remind_id  # type: long
        # The name of the custom alert rule that was triggered. This parameter is returned if the value of the Source parameter is REMIND_ALERT.
        self.remind_name = remind_name  # type: str
        # The basic information about the baseline instance that triggered an alert. This parameter is returned if the value of the Source parameter is SLA_ALERT. This parameter is left empty if the value of the Source parameter is not SLA_ALERT.
        self.sla_alert = sla_alert  # type: ListAlertMessagesResponseBodyDataAlertMessagesSlaAlert
        # The type of the alert. Valid values: REMIND_ALERT, TOPIC_ALERT, SLA_ALERT, NODE_CYCLE_ALERT, and NODE_LONELY_ALERT. The value REMIND_ALERT indicates that the alert is a custom alert. The value TOPIC_ALERT indicates that the alert is an event alert. The value SLA_ALERT indicates that the alert is a baseline alert. The value NODE_CYCLE_ALERT indicates that the alert is reported for a node dependency loop. The value NODE_LONELY_ALERT indicates that the alert is reported for isolated nodes.
        self.source = source  # type: str
        # The events that triggered alerts. This parameter is returned if the value of the Source parameter is TOPIC_ALERT. This parameter is left empty if the value of the Source parameter is not TOPIC_ALERT.
        self.topics = topics  # type: list[ListAlertMessagesResponseBodyDataAlertMessagesTopics]

    def validate(self):
        if self.instances:
            for k in self.instances:
                if k:
                    k.validate()
        if self.nodes:
            for k in self.nodes:
                if k:
                    k.validate()
        if self.sla_alert:
            self.sla_alert.validate()
        if self.topics:
            for k in self.topics:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListAlertMessagesResponseBodyDataAlertMessages, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_id is not None:
            result['AlertId'] = self.alert_id
        if self.alert_message_status is not None:
            result['AlertMessageStatus'] = self.alert_message_status
        if self.alert_method is not None:
            result['AlertMethod'] = self.alert_method
        if self.alert_time is not None:
            result['AlertTime'] = self.alert_time
        if self.alert_user is not None:
            result['AlertUser'] = self.alert_user
        if self.content is not None:
            result['Content'] = self.content
        result['Instances'] = []
        if self.instances is not None:
            for k in self.instances:
                result['Instances'].append(k.to_map() if k else None)
        result['Nodes'] = []
        if self.nodes is not None:
            for k in self.nodes:
                result['Nodes'].append(k.to_map() if k else None)
        if self.remind_id is not None:
            result['RemindId'] = self.remind_id
        if self.remind_name is not None:
            result['RemindName'] = self.remind_name
        if self.sla_alert is not None:
            result['SlaAlert'] = self.sla_alert.to_map()
        if self.source is not None:
            result['Source'] = self.source
        result['Topics'] = []
        if self.topics is not None:
            for k in self.topics:
                result['Topics'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertId') is not None:
            self.alert_id = m.get('AlertId')
        if m.get('AlertMessageStatus') is not None:
            self.alert_message_status = m.get('AlertMessageStatus')
        if m.get('AlertMethod') is not None:
            self.alert_method = m.get('AlertMethod')
        if m.get('AlertTime') is not None:
            self.alert_time = m.get('AlertTime')
        if m.get('AlertUser') is not None:
            self.alert_user = m.get('AlertUser')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        self.instances = []
        if m.get('Instances') is not None:
            for k in m.get('Instances'):
                temp_model = ListAlertMessagesResponseBodyDataAlertMessagesInstances()
                self.instances.append(temp_model.from_map(k))
        self.nodes = []
        if m.get('Nodes') is not None:
            for k in m.get('Nodes'):
                temp_model = ListAlertMessagesResponseBodyDataAlertMessagesNodes()
                self.nodes.append(temp_model.from_map(k))
        if m.get('RemindId') is not None:
            self.remind_id = m.get('RemindId')
        if m.get('RemindName') is not None:
            self.remind_name = m.get('RemindName')
        if m.get('SlaAlert') is not None:
            temp_model = ListAlertMessagesResponseBodyDataAlertMessagesSlaAlert()
            self.sla_alert = temp_model.from_map(m['SlaAlert'])
        if m.get('Source') is not None:
            self.source = m.get('Source')
        self.topics = []
        if m.get('Topics') is not None:
            for k in m.get('Topics'):
                temp_model = ListAlertMessagesResponseBodyDataAlertMessagesTopics()
                self.topics.append(temp_model.from_map(k))
        return self


class ListAlertMessagesResponseBodyData(TeaModel):
    def __init__(self, alert_messages=None, page_number=None, page_size=None, total_count=None):
        # The alerts.
        self.alert_messages = alert_messages  # type: list[ListAlertMessagesResponseBodyDataAlertMessages]
        # The page number of the returned page.
        self.page_number = page_number  # type: str
        # The number of entries returned per page.
        self.page_size = page_size  # type: str
        # The total number of returned alerts.
        self.total_count = total_count  # type: str

    def validate(self):
        if self.alert_messages:
            for k in self.alert_messages:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListAlertMessagesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['AlertMessages'] = []
        if self.alert_messages is not None:
            for k in self.alert_messages:
                result['AlertMessages'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.alert_messages = []
        if m.get('AlertMessages') is not None:
            for k in m.get('AlertMessages'):
                temp_model = ListAlertMessagesResponseBodyDataAlertMessages()
                self.alert_messages.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListAlertMessagesResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The information about returned alerts.
        self.data = data  # type: ListAlertMessagesResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListAlertMessagesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListAlertMessagesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListAlertMessagesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListAlertMessagesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListAlertMessagesResponse, self).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=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 = ListAlertMessagesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListBaselineConfigsRequest(TeaModel):
    def __init__(self, baseline_types=None, owner=None, page_number=None, page_size=None, priority=None,
                 project_id=None, search_text=None, useflag=None):
        # The type of the baseline. Valid values: DAILY and HOURLY. A value of DAILY indicates that the baseline is a day-level baseline. A value of HOURLY indicates that the baseline is an hour-level baseline. Separate multiple baseline types with commas (,).
        self.baseline_types = baseline_types  # type: str
        # The ID of the Alibaba Cloud account used by the baseline owner.
        self.owner = owner  # type: str
        # The number of the page to return. Valid values: 1 to 30. Default value: 1.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Valid values: 1 to 100. Default value: 10.
        self.page_size = page_size  # type: int
        # The priority of the baseline. Valid values: 1, 3, 5, 7, and 8. Separate multiple priorities with commas (,).
        self.priority = priority  # type: str
        # The ID of the workspace. You can call the ListProjects operation to query the ID.
        self.project_id = project_id  # type: long
        # The keyword in the baseline name used to search for the baseline.
        self.search_text = search_text  # type: str
        # Specifies whether to enable the baseline. Valid values: true and false.
        self.useflag = useflag  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListBaselineConfigsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_types is not None:
            result['BaselineTypes'] = self.baseline_types
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.search_text is not None:
            result['SearchText'] = self.search_text
        if self.useflag is not None:
            result['Useflag'] = self.useflag
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineTypes') is not None:
            self.baseline_types = m.get('BaselineTypes')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SearchText') is not None:
            self.search_text = m.get('SearchText')
        if m.get('Useflag') is not None:
            self.useflag = m.get('Useflag')
        return self


class ListBaselineConfigsResponseBodyDataBaselines(TeaModel):
    def __init__(self, baseline_id=None, baseline_name=None, baseline_type=None, exp_hour=None, exp_minu=None,
                 hour_exp_detail=None, hour_sla_detail=None, is_default=None, owner=None, priority=None, project_id=None,
                 sla_hour=None, sla_minu=None, use_flag=None):
        # The ID of the baseline.
        self.baseline_id = baseline_id  # type: long
        # The name of the baseline.
        self.baseline_name = baseline_name  # type: str
        # The type of the baseline. Valid values: DAILY and HOURLY. A value of DAILY indicates that the baseline is a day-level baseline. A value of HOURLY indicates that the baseline is an hour-level baseline.
        self.baseline_type = baseline_type  # type: str
        # The hour in the alert time of the day-level baseline. Valid values: 0 to 47.
        self.exp_hour = exp_hour  # type: int
        # The minute in the alert time of the day-level baseline. Valid values: 0 to 59.
        self.exp_minu = exp_minu  # type: int
        # The alert time of the hour-level baseline. This parameter is presented as key-value pairs in the JSON format. The key indicates the ID of the cycle, and the value is presented in the hh:mm format. Valid values of hh: 0 to 47. Valid values of mm: 0 to 59.
        self.hour_exp_detail = hour_exp_detail  # type: str
        # The committed time of the hour-level baseline. This parameter is presented as key-value pairs in the JSON format. The key indicates the ID of the cycle, and the value is presented in the hh:mm format. Valid values of hh: 0 to 47. Valid values of mm: 0 to 59.
        self.hour_sla_detail = hour_sla_detail  # type: str
        # Indicates whether the baseline is a default baseline of the workspace. Valid values: true and false.
        self.is_default = is_default  # type: bool
        # The ID of the Alibaba Cloud account used by the baseline owner. Multiple IDs are separated by commas (,).
        self.owner = owner  # type: str
        # The priority of the baseline. Valid values: 1, 3, 5, 7, and 8.
        self.priority = priority  # type: int
        # The ID of the workspace to which the baseline belongs.
        self.project_id = project_id  # type: long
        # The hour in the committed time of the day-level baseline. Valid values: 0 to 47.
        self.sla_hour = sla_hour  # type: int
        # The minute in the alert time of the day-level baseline. Valid values: 0 to 59.
        self.sla_minu = sla_minu  # type: int
        # Indicates whether the baseline is enabled. Valid values: true and false.
        self.use_flag = use_flag  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListBaselineConfigsResponseBodyDataBaselines, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.baseline_type is not None:
            result['BaselineType'] = self.baseline_type
        if self.exp_hour is not None:
            result['ExpHour'] = self.exp_hour
        if self.exp_minu is not None:
            result['ExpMinu'] = self.exp_minu
        if self.hour_exp_detail is not None:
            result['HourExpDetail'] = self.hour_exp_detail
        if self.hour_sla_detail is not None:
            result['HourSlaDetail'] = self.hour_sla_detail
        if self.is_default is not None:
            result['IsDefault'] = self.is_default
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.sla_hour is not None:
            result['SlaHour'] = self.sla_hour
        if self.sla_minu is not None:
            result['SlaMinu'] = self.sla_minu
        if self.use_flag is not None:
            result['UseFlag'] = self.use_flag
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('BaselineType') is not None:
            self.baseline_type = m.get('BaselineType')
        if m.get('ExpHour') is not None:
            self.exp_hour = m.get('ExpHour')
        if m.get('ExpMinu') is not None:
            self.exp_minu = m.get('ExpMinu')
        if m.get('HourExpDetail') is not None:
            self.hour_exp_detail = m.get('HourExpDetail')
        if m.get('HourSlaDetail') is not None:
            self.hour_sla_detail = m.get('HourSlaDetail')
        if m.get('IsDefault') is not None:
            self.is_default = m.get('IsDefault')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SlaHour') is not None:
            self.sla_hour = m.get('SlaHour')
        if m.get('SlaMinu') is not None:
            self.sla_minu = m.get('SlaMinu')
        if m.get('UseFlag') is not None:
            self.use_flag = m.get('UseFlag')
        return self


class ListBaselineConfigsResponseBodyData(TeaModel):
    def __init__(self, baselines=None, page_number=None, page_size=None, total_count=None):
        # The list of baselines.
        self.baselines = baselines  # type: list[ListBaselineConfigsResponseBodyDataBaselines]
        # The page number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries returned on each page.
        self.page_size = page_size  # type: int
        # The total number of baselines returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.baselines:
            for k in self.baselines:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListBaselineConfigsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Baselines'] = []
        if self.baselines is not None:
            for k in self.baselines:
                result['Baselines'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.baselines = []
        if m.get('Baselines') is not None:
            for k in m.get('Baselines'):
                temp_model = ListBaselineConfigsResponseBodyDataBaselines()
                self.baselines.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListBaselineConfigsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The return results of the request.
        self.data = data  # type: ListBaselineConfigsResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The unique ID of the request. You can troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListBaselineConfigsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListBaselineConfigsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListBaselineConfigsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListBaselineConfigsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListBaselineConfigsResponse, self).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=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 = ListBaselineConfigsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListBaselineStatusesRequest(TeaModel):
    def __init__(self, baseline_types=None, bizdate=None, finish_status=None, owner=None, page_number=None,
                 page_size=None, priority=None, search_text=None, status=None, topic_id=None):
        # The type of the baseline. Valid values: DAILY and HOURLY. The value DAILY indicates that the baseline is scheduled by day. The value HOURLY indicates that the baseline is scheduled by hour. Multiple types are separated by commas (,).
        self.baseline_types = baseline_types  # type: str
        # The data timestamp of the baseline instance. Specify the time in the ISO 8601 standard in the yyyy-MM-dd\"T\"HH:mm:ssZ format. The time must be in UTC.
        self.bizdate = bizdate  # type: str
        # The status of the baseline instance. Valid values: UNFINISH and FINISH. The value UNFINISH indicates that the baseline instance is still running. The value FINISH indicates that the baseline instance finishes running. Multiple states are separated by commas (,).
        self.finish_status = finish_status  # type: str
        # The ID of the Alibaba Cloud account used by the baseline owner.
        self.owner = owner  # type: str
        # The number of the page to return. Valid values: 1 to 30. Default value: 1.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The priority of the baseline. Valid values: 1, 3, 5, 7, and 8. Multiple priorities are separated by commas (,).
        self.priority = priority  # type: str
        # The keyword of the baseline name used to search for the baseline.
        self.search_text = search_text  # type: str
        # The status of the baseline. Valid values: ERROR, SAFE, DANGEROUS, and OVER. The value ERROR indicates that no nodes are associated with the baseline, or all nodes associated with the baseline are suspended. The value SAFE indicates that nodes finish running before the alerting time. The value DANGEROUS indicates that nodes are still running after the alerting time but before the committed completion time. The value OVER indicates that nodes are still running after the committed completion time. Multiple states are separated by commas (,).
        self.status = status  # type: str
        # The ID of the event.
        self.topic_id = topic_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListBaselineStatusesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_types is not None:
            result['BaselineTypes'] = self.baseline_types
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.finish_status is not None:
            result['FinishStatus'] = self.finish_status
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.search_text is not None:
            result['SearchText'] = self.search_text
        if self.status is not None:
            result['Status'] = self.status
        if self.topic_id is not None:
            result['TopicId'] = self.topic_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineTypes') is not None:
            self.baseline_types = m.get('BaselineTypes')
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('FinishStatus') is not None:
            self.finish_status = m.get('FinishStatus')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('SearchText') is not None:
            self.search_text = m.get('SearchText')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TopicId') is not None:
            self.topic_id = m.get('TopicId')
        return self


class ListBaselineStatusesResponseBodyDataBaselineStatuses(TeaModel):
    def __init__(self, baseline_id=None, baseline_name=None, bizdate=None, buffer=None, end_cast=None, exp_time=None,
                 finish_status=None, finish_time=None, in_group_id=None, owner=None, priority=None, project_id=None, sla_time=None,
                 status=None):
        # The ID of the baseline.
        self.baseline_id = baseline_id  # type: long
        # The name of the baseline.
        self.baseline_name = baseline_name  # type: str
        # The data timestamp of the baseline instance.
        self.bizdate = bizdate  # type: long
        # The margin of the baseline instance. Unit: seconds.
        self.buffer = buffer  # type: long
        # The predicted time when the baseline instance finished running.
        self.end_cast = end_cast  # type: long
        # The alerting time of the baseline instance.
        self.exp_time = exp_time  # type: long
        # The status of the baseline instance. Valid values: UNFINISH and FINISH. The value UNFINISH indicates that the baseline instance is still running. The value FINISH indicates that the baseline instance finishes running.
        self.finish_status = finish_status  # type: str
        # The timestamp of the actual time when the baseline instance finished running. This parameter is returned if the value of the FinishStatus parameter is FINISH.
        self.finish_time = finish_time  # type: long
        # The ID of the scheduling cycle of the baseline instance. For a baseline instance that is scheduled by day, the value of this parameter is 1. For a baseline instance that is scheduled by hour, the value of this parameter ranges from 1 to 24.
        self.in_group_id = in_group_id  # type: int
        # The ID of the Alibaba Cloud account used by the baseline owner. Multiple IDs are separated by commas (,).
        self.owner = owner  # type: str
        # The priority of the baseline. Valid values: 1, 3, 5, 7, and 8.
        self.priority = priority  # type: int
        # The ID of the workspace to which the baseline belongs.
        self.project_id = project_id  # type: long
        # The actual time when the baseline instance finished running.
        self.sla_time = sla_time  # type: long
        # The status of the baseline. Valid values: ERROR, SAFE, DANGEROUS, and OVER. The value ERROR indicates that no nodes are associated with the baseline, or all nodes associated with the baseline are suspended. The value SAFE indicates that nodes finish running before the alerting time. The value DANGEROUS indicates that nodes are still running after the alerting time but before the committed completion time. The value OVER indicates that nodes are still running after the committed completion time.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListBaselineStatusesResponseBodyDataBaselineStatuses, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.buffer is not None:
            result['Buffer'] = self.buffer
        if self.end_cast is not None:
            result['EndCast'] = self.end_cast
        if self.exp_time is not None:
            result['ExpTime'] = self.exp_time
        if self.finish_status is not None:
            result['FinishStatus'] = self.finish_status
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.in_group_id is not None:
            result['InGroupId'] = self.in_group_id
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.sla_time is not None:
            result['SlaTime'] = self.sla_time
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('Buffer') is not None:
            self.buffer = m.get('Buffer')
        if m.get('EndCast') is not None:
            self.end_cast = m.get('EndCast')
        if m.get('ExpTime') is not None:
            self.exp_time = m.get('ExpTime')
        if m.get('FinishStatus') is not None:
            self.finish_status = m.get('FinishStatus')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('InGroupId') is not None:
            self.in_group_id = m.get('InGroupId')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SlaTime') is not None:
            self.sla_time = m.get('SlaTime')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class ListBaselineStatusesResponseBodyData(TeaModel):
    def __init__(self, baseline_statuses=None, page_number=None, page_size=None, total_count=None):
        # The list of baseline instances.
        self.baseline_statuses = baseline_statuses  # type: list[ListBaselineStatusesResponseBodyDataBaselineStatuses]
        # The page number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries returned per page.
        self.page_size = page_size  # type: int
        # The total number of baseline instances.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.baseline_statuses:
            for k in self.baseline_statuses:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListBaselineStatusesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['BaselineStatuses'] = []
        if self.baseline_statuses is not None:
            for k in self.baseline_statuses:
                result['BaselineStatuses'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.baseline_statuses = []
        if m.get('BaselineStatuses') is not None:
            for k in m.get('BaselineStatuses'):
                temp_model = ListBaselineStatusesResponseBodyDataBaselineStatuses()
                self.baseline_statuses.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListBaselineStatusesResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The list of baseline instances returned.
        self.data = data  # type: ListBaselineStatusesResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListBaselineStatusesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListBaselineStatusesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListBaselineStatusesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListBaselineStatusesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListBaselineStatusesResponse, self).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=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 = ListBaselineStatusesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListBaselinesRequest(TeaModel):
    def __init__(self, baseline_types=None, enable=None, owner=None, page_number=None, page_size=None, priority=None,
                 project_id=None, search_text=None):
        self.baseline_types = baseline_types  # type: str
        self.enable = enable  # type: bool
        self.owner = owner  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.priority = priority  # type: str
        self.project_id = project_id  # type: long
        self.search_text = search_text  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListBaselinesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_types is not None:
            result['BaselineTypes'] = self.baseline_types
        if self.enable is not None:
            result['Enable'] = self.enable
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.search_text is not None:
            result['SearchText'] = self.search_text
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineTypes') is not None:
            self.baseline_types = m.get('BaselineTypes')
        if m.get('Enable') is not None:
            self.enable = m.get('Enable')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SearchText') is not None:
            self.search_text = m.get('SearchText')
        return self


class ListBaselinesResponseBodyDataBaselinesOverTimeSettings(TeaModel):
    def __init__(self, cycle=None, time=None):
        self.cycle = cycle  # type: int
        self.time = time  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListBaselinesResponseBodyDataBaselinesOverTimeSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cycle is not None:
            result['Cycle'] = self.cycle
        if self.time is not None:
            result['Time'] = self.time
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Cycle') is not None:
            self.cycle = m.get('Cycle')
        if m.get('Time') is not None:
            self.time = m.get('Time')
        return self


class ListBaselinesResponseBodyDataBaselines(TeaModel):
    def __init__(self, alert_enabled=None, alert_margin_threshold=None, baseline_id=None, baseline_name=None,
                 baseline_type=None, enabled=None, over_time_settings=None, owner=None, priority=None, project_id=None):
        self.alert_enabled = alert_enabled  # type: bool
        self.alert_margin_threshold = alert_margin_threshold  # type: int
        self.baseline_id = baseline_id  # type: long
        self.baseline_name = baseline_name  # type: str
        self.baseline_type = baseline_type  # type: str
        self.enabled = enabled  # type: bool
        self.over_time_settings = over_time_settings  # type: list[ListBaselinesResponseBodyDataBaselinesOverTimeSettings]
        self.owner = owner  # type: str
        self.priority = priority  # type: int
        self.project_id = project_id  # type: long

    def validate(self):
        if self.over_time_settings:
            for k in self.over_time_settings:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListBaselinesResponseBodyDataBaselines, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_enabled is not None:
            result['AlertEnabled'] = self.alert_enabled
        if self.alert_margin_threshold is not None:
            result['AlertMarginThreshold'] = self.alert_margin_threshold
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.baseline_type is not None:
            result['BaselineType'] = self.baseline_type
        if self.enabled is not None:
            result['Enabled'] = self.enabled
        result['OverTimeSettings'] = []
        if self.over_time_settings is not None:
            for k in self.over_time_settings:
                result['OverTimeSettings'].append(k.to_map() if k else None)
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertEnabled') is not None:
            self.alert_enabled = m.get('AlertEnabled')
        if m.get('AlertMarginThreshold') is not None:
            self.alert_margin_threshold = m.get('AlertMarginThreshold')
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('BaselineType') is not None:
            self.baseline_type = m.get('BaselineType')
        if m.get('Enabled') is not None:
            self.enabled = m.get('Enabled')
        self.over_time_settings = []
        if m.get('OverTimeSettings') is not None:
            for k in m.get('OverTimeSettings'):
                temp_model = ListBaselinesResponseBodyDataBaselinesOverTimeSettings()
                self.over_time_settings.append(temp_model.from_map(k))
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListBaselinesResponseBodyData(TeaModel):
    def __init__(self, baselines=None, page_number=None, page_size=None, total_count=None):
        self.baselines = baselines  # type: list[ListBaselinesResponseBodyDataBaselines]
        self.page_number = page_number  # type: str
        self.page_size = page_size  # type: str
        self.total_count = total_count  # type: str

    def validate(self):
        if self.baselines:
            for k in self.baselines:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListBaselinesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Baselines'] = []
        if self.baselines is not None:
            for k in self.baselines:
                result['Baselines'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.baselines = []
        if m.get('Baselines') is not None:
            for k in m.get('Baselines'):
                temp_model = ListBaselinesResponseBodyDataBaselines()
                self.baselines.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListBaselinesResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: ListBaselinesResponseBodyData
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListBaselinesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListBaselinesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListBaselinesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListBaselinesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListBaselinesResponse, self).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=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 = ListBaselinesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListBusinessRequest(TeaModel):
    def __init__(self, keyword=None, page_number=None, page_size=None, project_id=None, project_identifier=None):
        # The keyword that is used to perform a fuzzy match.
        self.keyword = keyword  # type: str
        # The number of the page to return.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace ID. You must configure either this parameter or the ProjectIdentifier parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace name. You must configure either this parameter or ProjectId parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListBusinessRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Keyword') is not None:
            self.keyword = m.get('Keyword')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class ListBusinessResponseBodyDataBusiness(TeaModel):
    def __init__(self, business_id=None, business_name=None, description=None, owner=None, project_id=None,
                 use_type=None):
        # The ID of the workflow.
        self.business_id = business_id  # type: long
        # The name of the workflow.
        self.business_name = business_name  # type: str
        # The description of the workflow.
        self.description = description  # type: str
        # The owner of the workflow.
        self.owner = owner  # type: str
        # The ID of the workspace to which the workflow belongs.
        self.project_id = project_id  # type: long
        # The module to which the workflow belongs. Valid values: NORMAL and MANUAL_BIZ. The value NORMAL indicates that the workflow belongs to auto triggered workflows. The value MANUAL_BIZ indicates that the workflow belongs to manually triggered workflows.
        self.use_type = use_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListBusinessResponseBodyDataBusiness, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.business_name is not None:
            result['BusinessName'] = self.business_name
        if self.description is not None:
            result['Description'] = self.description
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.use_type is not None:
            result['UseType'] = self.use_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('BusinessName') is not None:
            self.business_name = m.get('BusinessName')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('UseType') is not None:
            self.use_type = m.get('UseType')
        return self


class ListBusinessResponseBodyData(TeaModel):
    def __init__(self, business=None, page_number=None, page_size=None, total_count=None):
        # The details of the workflow.
        self.business = business  # type: list[ListBusinessResponseBodyDataBusiness]
        # The page number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries returned per page.
        self.page_size = page_size  # type: int
        # The total number of entries returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.business:
            for k in self.business:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListBusinessResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Business'] = []
        if self.business is not None:
            for k in self.business:
                result['Business'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.business = []
        if m.get('Business') is not None:
            for k in m.get('Business'):
                temp_model = ListBusinessResponseBodyDataBusiness()
                self.business.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListBusinessResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The information about the workflows returned.
        self.data = data  # type: ListBusinessResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListBusinessResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListBusinessResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListBusinessResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListBusinessResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListBusinessResponse, self).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=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 = ListBusinessResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListCalcEnginesRequest(TeaModel):
    def __init__(self, calc_engine_type=None, env_type=None, name=None, page_number=None, page_size=None,
                 project_id=None):
        self.calc_engine_type = calc_engine_type  # type: str
        self.env_type = env_type  # type: str
        self.name = name  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListCalcEnginesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.calc_engine_type is not None:
            result['CalcEngineType'] = self.calc_engine_type
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.name is not None:
            result['Name'] = self.name
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CalcEngineType') is not None:
            self.calc_engine_type = m.get('CalcEngineType')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListCalcEnginesResponseBodyDataCalcEngines(TeaModel):
    def __init__(self, binding_project_id=None, binding_project_name=None, calc_engine_type=None, dw_region=None,
                 engine_id=None, engine_info=None, env_type=None, gmt_create=None, is_default=None, name=None, region=None,
                 task_auth_type=None, tenant_id=None):
        self.binding_project_id = binding_project_id  # type: int
        self.binding_project_name = binding_project_name  # type: str
        self.calc_engine_type = calc_engine_type  # type: str
        self.dw_region = dw_region  # type: str
        self.engine_id = engine_id  # type: int
        self.engine_info = engine_info  # type: dict[str, any]
        self.env_type = env_type  # type: str
        self.gmt_create = gmt_create  # type: str
        self.is_default = is_default  # type: bool
        self.name = name  # type: str
        self.region = region  # type: str
        self.task_auth_type = task_auth_type  # type: str
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListCalcEnginesResponseBodyDataCalcEngines, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.binding_project_id is not None:
            result['BindingProjectId'] = self.binding_project_id
        if self.binding_project_name is not None:
            result['BindingProjectName'] = self.binding_project_name
        if self.calc_engine_type is not None:
            result['CalcEngineType'] = self.calc_engine_type
        if self.dw_region is not None:
            result['DwRegion'] = self.dw_region
        if self.engine_id is not None:
            result['EngineId'] = self.engine_id
        if self.engine_info is not None:
            result['EngineInfo'] = self.engine_info
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.gmt_create is not None:
            result['GmtCreate'] = self.gmt_create
        if self.is_default is not None:
            result['IsDefault'] = self.is_default
        if self.name is not None:
            result['Name'] = self.name
        if self.region is not None:
            result['Region'] = self.region
        if self.task_auth_type is not None:
            result['TaskAuthType'] = self.task_auth_type
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BindingProjectId') is not None:
            self.binding_project_id = m.get('BindingProjectId')
        if m.get('BindingProjectName') is not None:
            self.binding_project_name = m.get('BindingProjectName')
        if m.get('CalcEngineType') is not None:
            self.calc_engine_type = m.get('CalcEngineType')
        if m.get('DwRegion') is not None:
            self.dw_region = m.get('DwRegion')
        if m.get('EngineId') is not None:
            self.engine_id = m.get('EngineId')
        if m.get('EngineInfo') is not None:
            self.engine_info = m.get('EngineInfo')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('GmtCreate') is not None:
            self.gmt_create = m.get('GmtCreate')
        if m.get('IsDefault') is not None:
            self.is_default = m.get('IsDefault')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Region') is not None:
            self.region = m.get('Region')
        if m.get('TaskAuthType') is not None:
            self.task_auth_type = m.get('TaskAuthType')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListCalcEnginesResponseBodyData(TeaModel):
    def __init__(self, calc_engines=None, page_number=None, page_size=None, total_count=None):
        self.calc_engines = calc_engines  # type: list[ListCalcEnginesResponseBodyDataCalcEngines]
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.total_count = total_count  # type: int

    def validate(self):
        if self.calc_engines:
            for k in self.calc_engines:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListCalcEnginesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['CalcEngines'] = []
        if self.calc_engines is not None:
            for k in self.calc_engines:
                result['CalcEngines'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.calc_engines = []
        if m.get('CalcEngines') is not None:
            for k in m.get('CalcEngines'):
                temp_model = ListCalcEnginesResponseBodyDataCalcEngines()
                self.calc_engines.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListCalcEnginesResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        self.data = data  # type: ListCalcEnginesResponseBodyData
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListCalcEnginesResponseBody, self).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.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListCalcEnginesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListCalcEnginesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListCalcEnginesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListCalcEnginesResponse, self).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=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 = ListCalcEnginesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListConnectionsRequest(TeaModel):
    def __init__(self, connection_type=None, env_type=None, name=None, page_number=None, page_size=None,
                 project_id=None, status=None, sub_type=None):
        self.connection_type = connection_type  # type: str
        self.env_type = env_type  # type: int
        self.name = name  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        self.status = status  # type: str
        self.sub_type = sub_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListConnectionsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_type is not None:
            result['ConnectionType'] = self.connection_type
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.name is not None:
            result['Name'] = self.name
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        if self.sub_type is not None:
            result['SubType'] = self.sub_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionType') is not None:
            self.connection_type = m.get('ConnectionType')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('SubType') is not None:
            self.sub_type = m.get('SubType')
        return self


class ListConnectionsResponseBodyDataConnections(TeaModel):
    def __init__(self, binding_calc_engine_id=None, connect_status=None, connection_type=None, content=None,
                 default_engine=None, description=None, env_type=None, gmt_create=None, gmt_modified=None, id=None, name=None,
                 operator=None, project_id=None, sequence=None, shared=None, status=None, sub_type=None, tenant_id=None):
        self.binding_calc_engine_id = binding_calc_engine_id  # type: int
        self.connect_status = connect_status  # type: int
        self.connection_type = connection_type  # type: str
        self.content = content  # type: str
        self.default_engine = default_engine  # type: bool
        self.description = description  # type: str
        self.env_type = env_type  # type: int
        self.gmt_create = gmt_create  # type: str
        self.gmt_modified = gmt_modified  # type: str
        self.id = id  # type: int
        self.name = name  # type: str
        self.operator = operator  # type: str
        self.project_id = project_id  # type: int
        self.sequence = sequence  # type: int
        self.shared = shared  # type: bool
        self.status = status  # type: int
        self.sub_type = sub_type  # type: str
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListConnectionsResponseBodyDataConnections, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.binding_calc_engine_id is not None:
            result['BindingCalcEngineId'] = self.binding_calc_engine_id
        if self.connect_status is not None:
            result['ConnectStatus'] = self.connect_status
        if self.connection_type is not None:
            result['ConnectionType'] = self.connection_type
        if self.content is not None:
            result['Content'] = self.content
        if self.default_engine is not None:
            result['DefaultEngine'] = self.default_engine
        if self.description is not None:
            result['Description'] = self.description
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.gmt_create is not None:
            result['GmtCreate'] = self.gmt_create
        if self.gmt_modified is not None:
            result['GmtModified'] = self.gmt_modified
        if self.id is not None:
            result['Id'] = self.id
        if self.name is not None:
            result['Name'] = self.name
        if self.operator is not None:
            result['Operator'] = self.operator
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.sequence is not None:
            result['Sequence'] = self.sequence
        if self.shared is not None:
            result['Shared'] = self.shared
        if self.status is not None:
            result['Status'] = self.status
        if self.sub_type is not None:
            result['SubType'] = self.sub_type
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BindingCalcEngineId') is not None:
            self.binding_calc_engine_id = m.get('BindingCalcEngineId')
        if m.get('ConnectStatus') is not None:
            self.connect_status = m.get('ConnectStatus')
        if m.get('ConnectionType') is not None:
            self.connection_type = m.get('ConnectionType')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('DefaultEngine') is not None:
            self.default_engine = m.get('DefaultEngine')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('GmtCreate') is not None:
            self.gmt_create = m.get('GmtCreate')
        if m.get('GmtModified') is not None:
            self.gmt_modified = m.get('GmtModified')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Operator') is not None:
            self.operator = m.get('Operator')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Sequence') is not None:
            self.sequence = m.get('Sequence')
        if m.get('Shared') is not None:
            self.shared = m.get('Shared')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('SubType') is not None:
            self.sub_type = m.get('SubType')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListConnectionsResponseBodyData(TeaModel):
    def __init__(self, connections=None, page_number=None, page_size=None, total_count=None):
        self.connections = connections  # type: list[ListConnectionsResponseBodyDataConnections]
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.total_count = total_count  # type: int

    def validate(self):
        if self.connections:
            for k in self.connections:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListConnectionsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Connections'] = []
        if self.connections is not None:
            for k in self.connections:
                result['Connections'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.connections = []
        if m.get('Connections') is not None:
            for k in m.get('Connections'):
                temp_model = ListConnectionsResponseBodyDataConnections()
                self.connections.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListConnectionsResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        self.data = data  # type: ListConnectionsResponseBodyData
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListConnectionsResponseBody, self).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.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListConnectionsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListConnectionsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListConnectionsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListConnectionsResponse, self).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=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 = ListConnectionsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDIAlarmRulesRequest(TeaModel):
    def __init__(self, dijob_id=None, page_number=None, page_size=None):
        self.dijob_id = dijob_id  # type: long
        self.page_number = page_number  # type: long
        self.page_size = page_size  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDIAlarmRulesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        return self


class ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettingsNotificationChannels(TeaModel):
    def __init__(self, channels=None, severity=None):
        self.channels = channels  # type: list[str]
        self.severity = severity  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettingsNotificationChannels, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.channels is not None:
            result['Channels'] = self.channels
        if self.severity is not None:
            result['Severity'] = self.severity
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Channels') is not None:
            self.channels = m.get('Channels')
        if m.get('Severity') is not None:
            self.severity = m.get('Severity')
        return self


class ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettingsNotificationReceivers(TeaModel):
    def __init__(self, receiver_type=None, receiver_values=None):
        self.receiver_type = receiver_type  # type: str
        self.receiver_values = receiver_values  # type: list[str]

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettingsNotificationReceivers, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.receiver_type is not None:
            result['ReceiverType'] = self.receiver_type
        if self.receiver_values is not None:
            result['ReceiverValues'] = self.receiver_values
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ReceiverType') is not None:
            self.receiver_type = m.get('ReceiverType')
        if m.get('ReceiverValues') is not None:
            self.receiver_values = m.get('ReceiverValues')
        return self


class ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettings(TeaModel):
    def __init__(self, inhibition_interval=None, notification_channels=None, notification_receivers=None):
        self.inhibition_interval = inhibition_interval  # type: int
        self.notification_channels = notification_channels  # type: list[ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettingsNotificationChannels]
        self.notification_receivers = notification_receivers  # type: list[ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettingsNotificationReceivers]

    def validate(self):
        if self.notification_channels:
            for k in self.notification_channels:
                if k:
                    k.validate()
        if self.notification_receivers:
            for k in self.notification_receivers:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.inhibition_interval is not None:
            result['InhibitionInterval'] = self.inhibition_interval
        result['NotificationChannels'] = []
        if self.notification_channels is not None:
            for k in self.notification_channels:
                result['NotificationChannels'].append(k.to_map() if k else None)
        result['NotificationReceivers'] = []
        if self.notification_receivers is not None:
            for k in self.notification_receivers:
                result['NotificationReceivers'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InhibitionInterval') is not None:
            self.inhibition_interval = m.get('InhibitionInterval')
        self.notification_channels = []
        if m.get('NotificationChannels') is not None:
            for k in m.get('NotificationChannels'):
                temp_model = ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettingsNotificationChannels()
                self.notification_channels.append(temp_model.from_map(k))
        self.notification_receivers = []
        if m.get('NotificationReceivers') is not None:
            for k in m.get('NotificationReceivers'):
                temp_model = ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettingsNotificationReceivers()
                self.notification_receivers.append(temp_model.from_map(k))
        return self


class ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesTriggerConditions(TeaModel):
    def __init__(self, duration=None, severity=None, threshold=None):
        self.duration = duration  # type: long
        self.severity = severity  # type: str
        self.threshold = threshold  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesTriggerConditions, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.duration is not None:
            result['Duration'] = self.duration
        if self.severity is not None:
            result['Severity'] = self.severity
        if self.threshold is not None:
            result['Threshold'] = self.threshold
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Duration') is not None:
            self.duration = m.get('Duration')
        if m.get('Severity') is not None:
            self.severity = m.get('Severity')
        if m.get('Threshold') is not None:
            self.threshold = m.get('Threshold')
        return self


class ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRules(TeaModel):
    def __init__(self, dialarm_rule_id=None, dijob_id=None, description=None, enabled=None, metric_type=None,
                 notification_settings=None, trigger_conditions=None):
        self.dialarm_rule_id = dialarm_rule_id  # type: long
        self.dijob_id = dijob_id  # type: long
        self.description = description  # type: str
        self.enabled = enabled  # type: bool
        self.metric_type = metric_type  # type: str
        self.notification_settings = notification_settings  # type: ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettings
        self.trigger_conditions = trigger_conditions  # type: list[ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesTriggerConditions]

    def validate(self):
        if self.notification_settings:
            self.notification_settings.validate()
        if self.trigger_conditions:
            for k in self.trigger_conditions:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dialarm_rule_id is not None:
            result['DIAlarmRuleId'] = self.dialarm_rule_id
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.description is not None:
            result['Description'] = self.description
        if self.enabled is not None:
            result['Enabled'] = self.enabled
        if self.metric_type is not None:
            result['MetricType'] = self.metric_type
        if self.notification_settings is not None:
            result['NotificationSettings'] = self.notification_settings.to_map()
        result['TriggerConditions'] = []
        if self.trigger_conditions is not None:
            for k in self.trigger_conditions:
                result['TriggerConditions'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIAlarmRuleId') is not None:
            self.dialarm_rule_id = m.get('DIAlarmRuleId')
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Enabled') is not None:
            self.enabled = m.get('Enabled')
        if m.get('MetricType') is not None:
            self.metric_type = m.get('MetricType')
        if m.get('NotificationSettings') is not None:
            temp_model = ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesNotificationSettings()
            self.notification_settings = temp_model.from_map(m['NotificationSettings'])
        self.trigger_conditions = []
        if m.get('TriggerConditions') is not None:
            for k in m.get('TriggerConditions'):
                temp_model = ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRulesTriggerConditions()
                self.trigger_conditions.append(temp_model.from_map(k))
        return self


class ListDIAlarmRulesResponseBodyDIAlarmRulePaging(TeaModel):
    def __init__(self, dijob_alarm_rules=None, page_number=None, page_size=None, total_count=None):
        self.dijob_alarm_rules = dijob_alarm_rules  # type: list[ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRules]
        self.page_number = page_number  # type: long
        self.page_size = page_size  # type: long
        self.total_count = total_count  # type: long

    def validate(self):
        if self.dijob_alarm_rules:
            for k in self.dijob_alarm_rules:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDIAlarmRulesResponseBodyDIAlarmRulePaging, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DIJobAlarmRules'] = []
        if self.dijob_alarm_rules is not None:
            for k in self.dijob_alarm_rules:
                result['DIJobAlarmRules'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.dijob_alarm_rules = []
        if m.get('DIJobAlarmRules') is not None:
            for k in m.get('DIJobAlarmRules'):
                temp_model = ListDIAlarmRulesResponseBodyDIAlarmRulePagingDIJobAlarmRules()
                self.dijob_alarm_rules.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListDIAlarmRulesResponseBody(TeaModel):
    def __init__(self, dialarm_rule_paging=None, request_id=None):
        self.dialarm_rule_paging = dialarm_rule_paging  # type: ListDIAlarmRulesResponseBodyDIAlarmRulePaging
        self.request_id = request_id  # type: str

    def validate(self):
        if self.dialarm_rule_paging:
            self.dialarm_rule_paging.validate()

    def to_map(self):
        _map = super(ListDIAlarmRulesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dialarm_rule_paging is not None:
            result['DIAlarmRulePaging'] = self.dialarm_rule_paging.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIAlarmRulePaging') is not None:
            temp_model = ListDIAlarmRulesResponseBodyDIAlarmRulePaging()
            self.dialarm_rule_paging = temp_model.from_map(m['DIAlarmRulePaging'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListDIAlarmRulesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDIAlarmRulesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDIAlarmRulesResponse, self).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=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 = ListDIAlarmRulesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDIJobsRequest(TeaModel):
    def __init__(self, destination_data_source_type=None, job_name=None, page_number=None, page_size=None,
                 project_id=None, source_data_source_type=None):
        self.destination_data_source_type = destination_data_source_type  # type: str
        self.job_name = job_name  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        self.source_data_source_type = source_data_source_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDIJobsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.destination_data_source_type is not None:
            result['DestinationDataSourceType'] = self.destination_data_source_type
        if self.job_name is not None:
            result['JobName'] = self.job_name
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.source_data_source_type is not None:
            result['SourceDataSourceType'] = self.source_data_source_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DestinationDataSourceType') is not None:
            self.destination_data_source_type = m.get('DestinationDataSourceType')
        if m.get('JobName') is not None:
            self.job_name = m.get('JobName')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SourceDataSourceType') is not None:
            self.source_data_source_type = m.get('SourceDataSourceType')
        return self


class ListDIJobsResponseBodyDIJobPagingDIJobs(TeaModel):
    def __init__(self, dijob_id=None, destination_data_source_type=None, job_name=None, job_status=None,
                 migration_type=None, project_id=None, source_data_source_type=None):
        self.dijob_id = dijob_id  # type: long
        self.destination_data_source_type = destination_data_source_type  # type: str
        self.job_name = job_name  # type: str
        self.job_status = job_status  # type: str
        self.migration_type = migration_type  # type: str
        self.project_id = project_id  # type: long
        self.source_data_source_type = source_data_source_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDIJobsResponseBodyDIJobPagingDIJobs, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.destination_data_source_type is not None:
            result['DestinationDataSourceType'] = self.destination_data_source_type
        if self.job_name is not None:
            result['JobName'] = self.job_name
        if self.job_status is not None:
            result['JobStatus'] = self.job_status
        if self.migration_type is not None:
            result['MigrationType'] = self.migration_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.source_data_source_type is not None:
            result['SourceDataSourceType'] = self.source_data_source_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('DestinationDataSourceType') is not None:
            self.destination_data_source_type = m.get('DestinationDataSourceType')
        if m.get('JobName') is not None:
            self.job_name = m.get('JobName')
        if m.get('JobStatus') is not None:
            self.job_status = m.get('JobStatus')
        if m.get('MigrationType') is not None:
            self.migration_type = m.get('MigrationType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SourceDataSourceType') is not None:
            self.source_data_source_type = m.get('SourceDataSourceType')
        return self


class ListDIJobsResponseBodyDIJobPaging(TeaModel):
    def __init__(self, dijobs=None, page_number=None, page_size=None, total_count=None):
        self.dijobs = dijobs  # type: list[ListDIJobsResponseBodyDIJobPagingDIJobs]
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.total_count = total_count  # type: int

    def validate(self):
        if self.dijobs:
            for k in self.dijobs:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDIJobsResponseBodyDIJobPaging, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DIJobs'] = []
        if self.dijobs is not None:
            for k in self.dijobs:
                result['DIJobs'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.dijobs = []
        if m.get('DIJobs') is not None:
            for k in m.get('DIJobs'):
                temp_model = ListDIJobsResponseBodyDIJobPagingDIJobs()
                self.dijobs.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListDIJobsResponseBody(TeaModel):
    def __init__(self, dijob_paging=None, request_id=None):
        self.dijob_paging = dijob_paging  # type: ListDIJobsResponseBodyDIJobPaging
        self.request_id = request_id  # type: str

    def validate(self):
        if self.dijob_paging:
            self.dijob_paging.validate()

    def to_map(self):
        _map = super(ListDIJobsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_paging is not None:
            result['DIJobPaging'] = self.dijob_paging.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobPaging') is not None:
            temp_model = ListDIJobsResponseBodyDIJobPaging()
            self.dijob_paging = temp_model.from_map(m['DIJobPaging'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListDIJobsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDIJobsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDIJobsResponse, self).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=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 = ListDIJobsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDIProjectConfigRequest(TeaModel):
    def __init__(self, destination_type=None, project_id=None, source_type=None):
        # The type of the destination data source of the sync solution. This parameter cannot be left empty.
        # 
        # Valid values: analyticdb_for_mysql, odps, elasticsearch, holo, mysql, and polardb. You can call the ListDIProjectConfig operation to query the supported types of destination data sources.
        self.destination_type = destination_type  # type: str
        # The ID of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace ID.
        self.project_id = project_id  # type: long
        # The type of the source data source of the sync solution.
        # 
        # Valid values: oracle, mysql, polardb, datahub, drds, and analyticdb_for_mysql. You can call the ListDIProjectConfig operation to query the supported types of source data sources.
        # 
        # If you do not set this parameter, DataWorks applies the default global configuration to all the source data sources of the preceding types.
        self.source_type = source_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDIProjectConfigRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.destination_type is not None:
            result['DestinationType'] = self.destination_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.source_type is not None:
            result['SourceType'] = self.source_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DestinationType') is not None:
            self.destination_type = m.get('DestinationType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SourceType') is not None:
            self.source_type = m.get('SourceType')
        return self


class ListDIProjectConfigResponseBodyData(TeaModel):
    def __init__(self, config=None):
        # The default global configuration of sync solutions. The value indicates the processing rules of different types of DDL messages. Example:
        # 
        # {"RENAMECOLUMN":"WARNING","DROPTABLE":"WARNING","CREATETABLE":"WARNING","MODIFYCOLUMN":"WARNING","TRUNCATETABLE":"WARNING","DROPCOLUMN":"WARNING","ADDCOLUMN":"WARNING","RENAMETABLE":"WARNING"}
        # 
        # Field description:
        # 
        # *   RENAMECOLUMN: renames the column.
        # *   DROPTABLE: deletes the table.
        # *   CREATETABLE: creates a table.
        # *   MODIFYCOLUMN: changes the column data type.
        # *   TRUNCATETABLE: clears the table.
        # *   DROPCOLUMN: deletes the column.
        # *   ADDCOLUMN: creates a column.
        # *   RENAMETABLE: renames the table.
        # 
        # DataWorks processes a DDL message of a specific type based on the following policies after it receives the message:
        # 
        # *   WARNING: ignores the message and records an alert in real-time sync logs. The alert contains information about the situation that the message is ignored because of an execution error.
        # *   IGNORE: discards the message and does not send it to the destination data source.
        # *   CRITICAL: terminates the real-time sync node and sets the node status to Failed.
        # *   NORMAL: sends the message to the destination data source to process the message. Each destination data source may process DDL messages based on its own business logic. If DataWorks adopts the NORMAL policy, DataWorks only forwards DDL messages.
        self.config = config  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDIProjectConfigResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.config is not None:
            result['Config'] = self.config
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Config') is not None:
            self.config = m.get('Config')
        return self


class ListDIProjectConfigResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # The information about the query operation.
        self.data = data  # type: ListDIProjectConfigResponseBodyData
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListDIProjectConfigResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListDIProjectConfigResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListDIProjectConfigResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDIProjectConfigResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDIProjectConfigResponse, self).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=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 = ListDIProjectConfigResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDagsRequest(TeaModel):
    def __init__(self, op_seq=None, project_env=None):
        # The environment of the workspace. Valid values: PROD and DEV. PROD indicates the production environment. DEV indicates the development environment.
        self.op_seq = op_seq  # type: long
        # The HTTP status code returned.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDagsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.op_seq is not None:
            result['OpSeq'] = self.op_seq
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('OpSeq') is not None:
            self.op_seq = m.get('OpSeq')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class ListDagsResponseBodyDataDags(TeaModel):
    def __init__(self, bizdate=None, create_time=None, create_user=None, dag_id=None, finish_time=None, gmtdate=None,
                 modify_time=None, name=None, op_seq=None, project_id=None, start_time=None, status=None, type=None):
        # The name of the DAG.
        self.bizdate = bizdate  # type: long
        # The ID of the workspace.
        self.create_time = create_time  # type: long
        # The data timestamp.
        self.create_user = create_user  # type: str
        # The time at which the DAG was scheduled to run.
        self.dag_id = dag_id  # type: long
        # The time at which the DAG was created. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.finish_time = finish_time  # type: long
        # The time at which the DAG started to run.
        self.gmtdate = gmtdate  # type: long
        # The sequence number of the operation.
        self.modify_time = modify_time  # type: long
        # The time at which the DAG was last modified. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.name = name  # type: str
        self.op_seq = op_seq  # type: long
        # The ID of the DAG.
        self.project_id = project_id  # type: long
        # The user who created the DAG.
        self.start_time = start_time  # type: long
        # The time at which the DAG finished running. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.status = status  # type: str
        # The status of the DAG. Valid values: CREATED, RUNNING, FAILURE, and SUCCESS.
        self.type = type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDagsResponseBodyDataDags, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.create_user is not None:
            result['CreateUser'] = self.create_user
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.gmtdate is not None:
            result['Gmtdate'] = self.gmtdate
        if self.modify_time is not None:
            result['ModifyTime'] = self.modify_time
        if self.name is not None:
            result['Name'] = self.name
        if self.op_seq is not None:
            result['OpSeq'] = self.op_seq
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.start_time is not None:
            result['StartTime'] = self.start_time
        if self.status is not None:
            result['Status'] = self.status
        if self.type is not None:
            result['Type'] = self.type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('CreateUser') is not None:
            self.create_user = m.get('CreateUser')
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('Gmtdate') is not None:
            self.gmtdate = m.get('Gmtdate')
        if m.get('ModifyTime') is not None:
            self.modify_time = m.get('ModifyTime')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('OpSeq') is not None:
            self.op_seq = m.get('OpSeq')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('StartTime') is not None:
            self.start_time = m.get('StartTime')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class ListDagsResponseBodyData(TeaModel):
    def __init__(self, dags=None):
        # The type of the DAG. Valid values: MANUAL, SMOKE_TEST, SUPPLY_DATA, and BUSINESS_PROCESS_DAG.
        self.dags = dags  # type: list[ListDagsResponseBodyDataDags]

    def validate(self):
        if self.dags:
            for k in self.dags:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDagsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Dags'] = []
        if self.dags is not None:
            for k in self.dags:
                result['Dags'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.dags = []
        if m.get('Dags') is not None:
            for k in m.get('Dags'):
                temp_model = ListDagsResponseBodyDataDags()
                self.dags.append(temp_model.from_map(k))
        return self


class ListDagsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The entities returned.
        self.data = data  # type: ListDagsResponseBodyData
        # Indicates whether the request is successful.
        self.error_code = error_code  # type: str
        # The error code returned.
        self.error_message = error_message  # type: str
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.http_status_code = http_status_code  # type: int
        # The error message returned.
        self.request_id = request_id  # type: str
        # The details of DAGs.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListDagsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListDagsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListDagsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDagsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDagsResponse, self).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=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 = ListDagsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDataServiceApiAuthoritiesRequest(TeaModel):
    def __init__(self, api_name_keyword=None, page_number=None, page_size=None, project_id=None, tenant_id=None):
        # The keyword in the name of the API. The keyword can be used to search for the API whose name contains the keyword.
        self.api_name_keyword = api_name_keyword  # type: str
        # The number of the page to return. Pages start from page 1. Default value: 1.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApiAuthoritiesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_name_keyword is not None:
            result['ApiNameKeyword'] = self.api_name_keyword
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiNameKeyword') is not None:
            self.api_name_keyword = m.get('ApiNameKeyword')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataServiceApiAuthoritiesResponseBodyDataApiAuthorizationListAuthorizationRecords(TeaModel):
    def __init__(self, created_time=None, creator_id=None, end_time=None, project_id=None):
        # The time when the access permissions on the API were granted to other users.
        self.created_time = created_time  # type: str
        # The ID of the Alibaba Cloud account used by the user who granted other users the access permissions on the API.
        self.creator_id = creator_id  # type: str
        # The end time of the validity period of the authorization.
        self.end_time = end_time  # type: str
        # The ID of the workspace to which the access permissions on the API are granted.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApiAuthoritiesResponseBodyDataApiAuthorizationListAuthorizationRecords, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListDataServiceApiAuthoritiesResponseBodyDataApiAuthorizationList(TeaModel):
    def __init__(self, api_id=None, api_name=None, api_path=None, api_status=None, authorization_records=None,
                 created_time=None, creator_id=None, group_id=None, modified_time=None, project_id=None, tenant_id=None):
        # The ID of the API.
        self.api_id = api_id  # type: long
        # The name of the API.
        self.api_name = api_name  # type: str
        # The path of the API.
        self.api_path = api_path  # type: str
        # The status of the API. Valid values: 0 and 1. The value 0 indicates that the API is not published. The value 1 indicates that the API is published.
        self.api_status = api_status  # type: int
        # The authorization records.
        self.authorization_records = authorization_records  # type: list[ListDataServiceApiAuthoritiesResponseBodyDataApiAuthorizationListAuthorizationRecords]
        # The time when the API was created.
        self.created_time = created_time  # type: str
        # The ID of the Alibaba Cloud account used by the API owner.
        self.creator_id = creator_id  # type: str
        # The ID of the group.
        self.group_id = group_id  # type: str
        # The time when the API was last updated.
        self.modified_time = modified_time  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        if self.authorization_records:
            for k in self.authorization_records:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServiceApiAuthoritiesResponseBodyDataApiAuthorizationList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.api_name is not None:
            result['ApiName'] = self.api_name
        if self.api_path is not None:
            result['ApiPath'] = self.api_path
        if self.api_status is not None:
            result['ApiStatus'] = self.api_status
        result['AuthorizationRecords'] = []
        if self.authorization_records is not None:
            for k in self.authorization_records:
                result['AuthorizationRecords'].append(k.to_map() if k else None)
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ApiName') is not None:
            self.api_name = m.get('ApiName')
        if m.get('ApiPath') is not None:
            self.api_path = m.get('ApiPath')
        if m.get('ApiStatus') is not None:
            self.api_status = m.get('ApiStatus')
        self.authorization_records = []
        if m.get('AuthorizationRecords') is not None:
            for k in m.get('AuthorizationRecords'):
                temp_model = ListDataServiceApiAuthoritiesResponseBodyDataApiAuthorizationListAuthorizationRecords()
                self.authorization_records.append(temp_model.from_map(k))
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataServiceApiAuthoritiesResponseBodyData(TeaModel):
    def __init__(self, api_authorization_list=None, page_number=None, page_size=None, total_count=None):
        # The APIs on which other users are granted the access permissions and the authorization records.
        self.api_authorization_list = api_authorization_list  # type: list[ListDataServiceApiAuthoritiesResponseBodyDataApiAuthorizationList]
        # The page number of the returned page. The value of this parameter is the same as that of the PageNumber parameter in the request.
        self.page_number = page_number  # type: int
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The total number of entries returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.api_authorization_list:
            for k in self.api_authorization_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServiceApiAuthoritiesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ApiAuthorizationList'] = []
        if self.api_authorization_list is not None:
            for k in self.api_authorization_list:
                result['ApiAuthorizationList'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.api_authorization_list = []
        if m.get('ApiAuthorizationList') is not None:
            for k in m.get('ApiAuthorizationList'):
                temp_model = ListDataServiceApiAuthoritiesResponseBodyDataApiAuthorizationList()
                self.api_authorization_list.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListDataServiceApiAuthoritiesResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The APIs on which other users are granted the access permissions.
        self.data = data  # type: ListDataServiceApiAuthoritiesResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListDataServiceApiAuthoritiesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListDataServiceApiAuthoritiesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListDataServiceApiAuthoritiesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDataServiceApiAuthoritiesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDataServiceApiAuthoritiesResponse, self).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=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 = ListDataServiceApiAuthoritiesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDataServiceApiTestRequest(TeaModel):
    def __init__(self, api_id=None, page_size=None):
        # The ID of the DataService Studio API on which tests are performed.
        self.api_id = api_id  # type: long
        # The number of entries to return on each page. Maximum value: 100.
        self.page_size = page_size  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApiTestRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        return self


class ListDataServiceApiTestResponseBodyData(TeaModel):
    def __init__(self, api_id=None, cost_time=None, create_time=None, param_map=None, ret_code=None, ret_result=None,
                 status=None, test_id=None):
        # The ID of the DataService Studio API on which the test is performed.
        self.api_id = api_id  # type: long
        # The time that is consumed to complete the test.
        self.cost_time = cost_time  # type: int
        # The time when the test was initiated.
        self.create_time = create_time  # type: long
        # The request parameters configured for the test.
        self.param_map = param_map  # type: str
        # The status code returned for the test. If the test is not complete, this parameter is not returned.
        self.ret_code = ret_code  # type: long
        # The result returned for the test.
        self.ret_result = ret_result  # type: str
        # The status of the test. Valid values: RUNNING and FINISHED.
        self.status = status  # type: str
        # The ID of the test.
        self.test_id = test_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApiTestResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.cost_time is not None:
            result['CostTime'] = self.cost_time
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.param_map is not None:
            result['ParamMap'] = self.param_map
        if self.ret_code is not None:
            result['RetCode'] = self.ret_code
        if self.ret_result is not None:
            result['RetResult'] = self.ret_result
        if self.status is not None:
            result['Status'] = self.status
        if self.test_id is not None:
            result['TestId'] = self.test_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('CostTime') is not None:
            self.cost_time = m.get('CostTime')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('ParamMap') is not None:
            self.param_map = m.get('ParamMap')
        if m.get('RetCode') is not None:
            self.ret_code = m.get('RetCode')
        if m.get('RetResult') is not None:
            self.ret_result = m.get('RetResult')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TestId') is not None:
            self.test_id = m.get('TestId')
        return self


class ListDataServiceApiTestResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None):
        # The list of test records.
        self.data = data  # type: list[ListDataServiceApiTestResponseBodyData]
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServiceApiTestResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = ListDataServiceApiTestResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListDataServiceApiTestResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDataServiceApiTestResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDataServiceApiTestResponse, self).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=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 = ListDataServiceApiTestResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDataServiceApisRequest(TeaModel):
    def __init__(self, api_name_keyword=None, api_path_keyword=None, creator_id=None, page_number=None,
                 page_size=None, project_id=None, tenant_id=None):
        # The ID of the tenant.
        self.api_name_keyword = api_name_keyword  # type: str
        # The keyword in the name of the API. The keyword can be used to search for the API whose name contains the keyword.
        self.api_path_keyword = api_path_keyword  # type: str
        # The keyword in the path of the API. The keyword can be used to search for the API whose path contains the keyword.
        self.creator_id = creator_id  # type: str
        # The operation that you want to perform. Set the value to **ListDataServiceApis**.
        self.page_number = page_number  # type: int
        # The number of the page to return. Pages start from page 1. Default value: 1.
        self.page_size = page_size  # type: int
        # The number of entries to return on each page. Default value: 10. A maximum of 100 entries can be returned on each page.
        self.project_id = project_id  # type: long
        # The ID of the workspace.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApisRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_name_keyword is not None:
            result['ApiNameKeyword'] = self.api_name_keyword
        if self.api_path_keyword is not None:
            result['ApiPathKeyword'] = self.api_path_keyword
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiNameKeyword') is not None:
            self.api_name_keyword = m.get('ApiNameKeyword')
        if m.get('ApiPathKeyword') is not None:
            self.api_path_keyword = m.get('ApiPathKeyword')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataServiceApisResponseBodyDataApisRegistrationDetailsRegistrationErrorCodes(TeaModel):
    def __init__(self, error_code=None, error_message=None, error_solution=None):
        # The error message.
        self.error_code = error_code  # type: str
        # The error codes returned for the API generated by registration.
        self.error_message = error_message  # type: str
        # The error code.
        self.error_solution = error_solution  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApisRegistrationDetailsRegistrationErrorCodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.error_solution is not None:
            result['ErrorSolution'] = self.error_solution
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('ErrorSolution') is not None:
            self.error_solution = m.get('ErrorSolution')
        return self


class ListDataServiceApisResponseBodyDataApisRegistrationDetailsRegistrationRequestParameters(TeaModel):
    def __init__(self, column_name=None, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The request parameters of the API generated by registration.
        self.column_name = column_name  # type: str
        # The description of the parameter.
        self.default_value = default_value  # type: str
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. A value of 0 indicates the STRING data type. A value of 1 indicates the INT data type. A value of 2 indicates the LONG data type. A value of 3 indicates the FLOAT data type. A value of 4 indicates the DOUBLE data type. A value of 5 indicates the BOOLEAN data type.
        self.example_value = example_value  # type: str
        # The sample value of the parameter.
        self.is_required_parameter = is_required_parameter  # type: bool
        # The operator used for the value of the parameter. Valid values: 0, 1, 2, and 3. A value of 0 indicates that the operator is Equal. A value of 1 indicates that the operator is Like. A value of 2 indicates that the operator is Const. A value of 3 indicates that the operator is In. APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.parameter_data_type = parameter_data_type  # type: int
        # The position of the parameter. Valid values: 0, 1, 2, and 3. A value of 0 indicates that the parameter is in the URL path of the request. A value of 1 indicates that the parameter is in the Query parameter of the request URL. A value of 2 indicates that the parameter is in the request header. A value of 3 indicates that the parameter is in the request body. APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_description = parameter_description  # type: str
        # The name of the associated field. This parameter is supported only if the API is generated in wizard mode.
        self.parameter_name = parameter_name  # type: str
        # The default value of the parameter.
        self.parameter_operator = parameter_operator  # type: int
        # The name of the parameter.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApisRegistrationDetailsRegistrationRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class ListDataServiceApisResponseBodyDataApisRegistrationDetails(TeaModel):
    def __init__(self, failed_result_sample=None, registration_error_codes=None,
                 registration_request_parameters=None, service_content_type=None, service_host=None, service_path=None,
                 service_request_body_description=None, successful_result_sample=None):
        # The sample success response of the API.
        self.failed_result_sample = failed_result_sample  # type: str
        # The body of the request initiated to call the backend service.
        self.registration_error_codes = registration_error_codes  # type: list[ListDataServiceApisResponseBodyDataApisRegistrationDetailsRegistrationErrorCodes]
        # The solution used to resolve the issue.
        self.registration_request_parameters = registration_request_parameters  # type: list[ListDataServiceApisResponseBodyDataApisRegistrationDetailsRegistrationRequestParameters]
        # The URL of the backend service.
        self.service_content_type = service_content_type  # type: int
        # The details of the API generated by registration. This parameter is returned only if the API is generated by registration.
        self.service_host = service_host  # type: str
        # The format in which the response of the API request is returned. Valid values: 0 and 1. A value of 0 indicates the JSON format. A value of 1 indicates the XML format. APIs generated in wizard or script mode support the JSON format. APIs generated by registration support the JSON and XML formats.
        self.service_path = service_path  # type: str
        # The sample error response of the API.
        self.service_request_body_description = service_request_body_description  # type: str
        # The path of the backend service.
        self.successful_result_sample = successful_result_sample  # type: str

    def validate(self):
        if self.registration_error_codes:
            for k in self.registration_error_codes:
                if k:
                    k.validate()
        if self.registration_request_parameters:
            for k in self.registration_request_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApisRegistrationDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.failed_result_sample is not None:
            result['FailedResultSample'] = self.failed_result_sample
        result['RegistrationErrorCodes'] = []
        if self.registration_error_codes is not None:
            for k in self.registration_error_codes:
                result['RegistrationErrorCodes'].append(k.to_map() if k else None)
        result['RegistrationRequestParameters'] = []
        if self.registration_request_parameters is not None:
            for k in self.registration_request_parameters:
                result['RegistrationRequestParameters'].append(k.to_map() if k else None)
        if self.service_content_type is not None:
            result['ServiceContentType'] = self.service_content_type
        if self.service_host is not None:
            result['ServiceHost'] = self.service_host
        if self.service_path is not None:
            result['ServicePath'] = self.service_path
        if self.service_request_body_description is not None:
            result['ServiceRequestBodyDescription'] = self.service_request_body_description
        if self.successful_result_sample is not None:
            result['SuccessfulResultSample'] = self.successful_result_sample
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FailedResultSample') is not None:
            self.failed_result_sample = m.get('FailedResultSample')
        self.registration_error_codes = []
        if m.get('RegistrationErrorCodes') is not None:
            for k in m.get('RegistrationErrorCodes'):
                temp_model = ListDataServiceApisResponseBodyDataApisRegistrationDetailsRegistrationErrorCodes()
                self.registration_error_codes.append(temp_model.from_map(k))
        self.registration_request_parameters = []
        if m.get('RegistrationRequestParameters') is not None:
            for k in m.get('RegistrationRequestParameters'):
                temp_model = ListDataServiceApisResponseBodyDataApisRegistrationDetailsRegistrationRequestParameters()
                self.registration_request_parameters.append(temp_model.from_map(k))
        if m.get('ServiceContentType') is not None:
            self.service_content_type = m.get('ServiceContentType')
        if m.get('ServiceHost') is not None:
            self.service_host = m.get('ServiceHost')
        if m.get('ServicePath') is not None:
            self.service_path = m.get('ServicePath')
        if m.get('ServiceRequestBodyDescription') is not None:
            self.service_request_body_description = m.get('ServiceRequestBodyDescription')
        if m.get('SuccessfulResultSample') is not None:
            self.successful_result_sample = m.get('SuccessfulResultSample')
        return self


class ListDataServiceApisResponseBodyDataApisScriptDetailsScriptConnection(TeaModel):
    def __init__(self, connection_id=None, table_name=None):
        # The ID of the data source.
        self.connection_id = connection_id  # type: long
        # The name of the table in the data source.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApisScriptDetailsScriptConnection, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_id is not None:
            result['ConnectionId'] = self.connection_id
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionId') is not None:
            self.connection_id = m.get('ConnectionId')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class ListDataServiceApisResponseBodyDataApisScriptDetailsScriptRequestParameters(TeaModel):
    def __init__(self, column_name=None, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The name of the associated field. This parameter is supported only if the API is generated in wizard mode.
        self.column_name = column_name  # type: str
        # The default value of the parameter.
        self.default_value = default_value  # type: str
        # The sample value of the parameter.
        self.example_value = example_value  # type: str
        # Indicates whether the request parameter is required.
        self.is_required_parameter = is_required_parameter  # type: bool
        # The data type of the parameter. Valid values:
        # 
        # - 0: STRING
        # - 1: INT
        # - 2: LONG
        # - 3: FLOAT
        # - 4: DOUBLE
        # - 5: BOOLEAN
        self.parameter_data_type = parameter_data_type  # type: int
        # The description of the parameter.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str
        # The operator used for the value of the parameter. Valid values:
        # 
        # - 0: Equal
        # - 1: Like
        # - 2: Const
        # - 3: In
        # 
        # APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.parameter_operator = parameter_operator  # type: int
        # The position of the parameter. Valid values:
        # 
        # - 0: Path
        # - 1: Query
        # - 2: Head
        # - 3: Body
        # 
        # APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApisScriptDetailsScriptRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class ListDataServiceApisResponseBodyDataApisScriptDetailsScriptResponseParameters(TeaModel):
    def __init__(self, column_name=None, example_value=None, parameter_data_type=None, parameter_description=None,
                 parameter_name=None):
        # The name of the associated field. This parameter is supported only if the API is generated in wizard mode.
        self.column_name = column_name  # type: str
        # The sample value of the parameter.
        self.example_value = example_value  # type: str
        # The data type of the parameter. Valid values:
        # 
        # - 0: STRING
        # - 1: INT
        # - 2: LONG
        # - 3: FLOAT
        # - 4: DOUBLE
        # - 5: BOOLEAN
        self.parameter_data_type = parameter_data_type  # type: int
        # The description of the parameter.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApisScriptDetailsScriptResponseParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        return self


class ListDataServiceApisResponseBodyDataApisScriptDetails(TeaModel):
    def __init__(self, is_paged_response=None, script=None, script_connection=None, script_request_parameters=None,
                 script_response_parameters=None):
        # Indicates whether the entries are returned by page.
        self.is_paged_response = is_paged_response  # type: bool
        # The SQL script.
        self.script = script  # type: str
        # The data source information of the API generated in script mode.
        self.script_connection = script_connection  # type: ListDataServiceApisResponseBodyDataApisScriptDetailsScriptConnection
        # The request parameters of the API generated in script mode.
        self.script_request_parameters = script_request_parameters  # type: list[ListDataServiceApisResponseBodyDataApisScriptDetailsScriptRequestParameters]
        # The response parameters of the API generated in script mode.
        self.script_response_parameters = script_response_parameters  # type: list[ListDataServiceApisResponseBodyDataApisScriptDetailsScriptResponseParameters]

    def validate(self):
        if self.script_connection:
            self.script_connection.validate()
        if self.script_request_parameters:
            for k in self.script_request_parameters:
                if k:
                    k.validate()
        if self.script_response_parameters:
            for k in self.script_response_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApisScriptDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.is_paged_response is not None:
            result['IsPagedResponse'] = self.is_paged_response
        if self.script is not None:
            result['Script'] = self.script
        if self.script_connection is not None:
            result['ScriptConnection'] = self.script_connection.to_map()
        result['ScriptRequestParameters'] = []
        if self.script_request_parameters is not None:
            for k in self.script_request_parameters:
                result['ScriptRequestParameters'].append(k.to_map() if k else None)
        result['ScriptResponseParameters'] = []
        if self.script_response_parameters is not None:
            for k in self.script_response_parameters:
                result['ScriptResponseParameters'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('IsPagedResponse') is not None:
            self.is_paged_response = m.get('IsPagedResponse')
        if m.get('Script') is not None:
            self.script = m.get('Script')
        if m.get('ScriptConnection') is not None:
            temp_model = ListDataServiceApisResponseBodyDataApisScriptDetailsScriptConnection()
            self.script_connection = temp_model.from_map(m['ScriptConnection'])
        self.script_request_parameters = []
        if m.get('ScriptRequestParameters') is not None:
            for k in m.get('ScriptRequestParameters'):
                temp_model = ListDataServiceApisResponseBodyDataApisScriptDetailsScriptRequestParameters()
                self.script_request_parameters.append(temp_model.from_map(k))
        self.script_response_parameters = []
        if m.get('ScriptResponseParameters') is not None:
            for k in m.get('ScriptResponseParameters'):
                temp_model = ListDataServiceApisResponseBodyDataApisScriptDetailsScriptResponseParameters()
                self.script_response_parameters.append(temp_model.from_map(k))
        return self


class ListDataServiceApisResponseBodyDataApisWizardDetailsWizardConnection(TeaModel):
    def __init__(self, connection_id=None, table_name=None):
        # The ID of the data source.
        self.connection_id = connection_id  # type: long
        # The name of the table in the data source.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApisWizardDetailsWizardConnection, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_id is not None:
            result['ConnectionId'] = self.connection_id
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionId') is not None:
            self.connection_id = m.get('ConnectionId')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class ListDataServiceApisResponseBodyDataApisWizardDetailsWizardRequestParameters(TeaModel):
    def __init__(self, column_name=None, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The name of the associated field. This parameter is supported only if the API is generated in wizard mode.
        self.column_name = column_name  # type: str
        # The default value of the parameter.
        self.default_value = default_value  # type: str
        # The sample value of the parameter.
        self.example_value = example_value  # type: str
        # Indicates whether the request parameter is required.
        self.is_required_parameter = is_required_parameter  # type: bool
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. A value of 0 indicates the STRING data type. A value of 1 indicates the INT data type. A value of 2 indicates the LONG data type. A value of 3 indicates the FLOAT data type. A value of 4 indicates the DOUBLE data type. A value of 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description of the parameter.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str
        # The operator used for the value of the parameter. Valid values: 0, 1, 2, and 3. A value of 0 indicates that the operator is Equal. A value of 1 indicates that the operator is Like. A value of 2 indicates that the operator is Const. A value of 3 indicates that the operator is In. APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.parameter_operator = parameter_operator  # type: int
        # The position of the parameter. Valid values: 0, 1, 2, and 3. A value of 0 indicates that the parameter is in the URL path of the request. A value of 1 indicates that the parameter is in the Query parameter of the request URL. A value of 2 indicates that the parameter is in the request header. A value of 3 indicates that the parameter is in the request body. APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApisWizardDetailsWizardRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class ListDataServiceApisResponseBodyDataApisWizardDetailsWizardResponseParameters(TeaModel):
    def __init__(self, column_name=None, example_value=None, parameter_data_type=None, parameter_description=None,
                 parameter_name=None):
        # The name of the associated field. This parameter is supported only if the API is generated in wizard mode.
        self.column_name = column_name  # type: str
        # The sample value of the parameter.
        self.example_value = example_value  # type: str
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. A value of 0 indicates the STRING data type. A value of 1 indicates the INT data type. A value of 2 indicates the LONG data type. A value of 3 indicates the FLOAT data type. A value of 4 indicates the DOUBLE data type. A value of 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description of the parameter.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApisWizardDetailsWizardResponseParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        return self


class ListDataServiceApisResponseBodyDataApisWizardDetails(TeaModel):
    def __init__(self, is_paged_response=None, wizard_connection=None, wizard_request_parameters=None,
                 wizard_response_parameters=None):
        # Indicates whether the entries are returned by page.
        self.is_paged_response = is_paged_response  # type: bool
        # The data source information of the API generated in wizard mode.
        self.wizard_connection = wizard_connection  # type: ListDataServiceApisResponseBodyDataApisWizardDetailsWizardConnection
        # The request parameters of the API generated in wizard mode.
        self.wizard_request_parameters = wizard_request_parameters  # type: list[ListDataServiceApisResponseBodyDataApisWizardDetailsWizardRequestParameters]
        # The response parameters of the API generated in wizard mode.
        self.wizard_response_parameters = wizard_response_parameters  # type: list[ListDataServiceApisResponseBodyDataApisWizardDetailsWizardResponseParameters]

    def validate(self):
        if self.wizard_connection:
            self.wizard_connection.validate()
        if self.wizard_request_parameters:
            for k in self.wizard_request_parameters:
                if k:
                    k.validate()
        if self.wizard_response_parameters:
            for k in self.wizard_response_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApisWizardDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.is_paged_response is not None:
            result['IsPagedResponse'] = self.is_paged_response
        if self.wizard_connection is not None:
            result['WizardConnection'] = self.wizard_connection.to_map()
        result['WizardRequestParameters'] = []
        if self.wizard_request_parameters is not None:
            for k in self.wizard_request_parameters:
                result['WizardRequestParameters'].append(k.to_map() if k else None)
        result['WizardResponseParameters'] = []
        if self.wizard_response_parameters is not None:
            for k in self.wizard_response_parameters:
                result['WizardResponseParameters'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('IsPagedResponse') is not None:
            self.is_paged_response = m.get('IsPagedResponse')
        if m.get('WizardConnection') is not None:
            temp_model = ListDataServiceApisResponseBodyDataApisWizardDetailsWizardConnection()
            self.wizard_connection = temp_model.from_map(m['WizardConnection'])
        self.wizard_request_parameters = []
        if m.get('WizardRequestParameters') is not None:
            for k in m.get('WizardRequestParameters'):
                temp_model = ListDataServiceApisResponseBodyDataApisWizardDetailsWizardRequestParameters()
                self.wizard_request_parameters.append(temp_model.from_map(k))
        self.wizard_response_parameters = []
        if m.get('WizardResponseParameters') is not None:
            for k in m.get('WizardResponseParameters'):
                temp_model = ListDataServiceApisResponseBodyDataApisWizardDetailsWizardResponseParameters()
                self.wizard_response_parameters.append(temp_model.from_map(k))
        return self


class ListDataServiceApisResponseBodyDataApis(TeaModel):
    def __init__(self, api_id=None, api_mode=None, api_name=None, api_path=None, created_time=None, creator_id=None,
                 description=None, folder_id=None, group_id=None, modified_time=None, operator_id=None, project_id=None,
                 protocols=None, registration_details=None, request_method=None, response_content_type=None,
                 script_details=None, status=None, tenant_id=None, timeout=None, visible_range=None, wizard_details=None):
        # The status of the API. Valid values: 0 and 1. A value of 0 indicates that the API is not published. A value of 1 indicates that the API is published.
        self.api_id = api_id  # type: long
        # The ID of the API.
        self.api_mode = api_mode  # type: int
        # The time when the API was created.
        self.api_name = api_name  # type: str
        # The ID of the tenant.
        self.api_path = api_path  # type: str
        # The request method of the API. Valid values: 0, 1, 2, and 3. A value of 0 indicates the GET method. A value of 1 indicates the POST method. A value of 2 indicates the PUT method. A value of 3 indicates the DELETE method. APIs generated in wizard or script mode support the GET and POST methods. APIs generated by registration support the GET, POST, PUT, and DELETE methods.
        self.created_time = created_time  # type: str
        # The format in which the response of the API request is returned. Valid values: 0 and 1. A value of 0 indicates the JSON format. A value of 1 indicates the XML format. APIs generated in wizard or script mode support the JSON format. APIs generated by registration support the JSON and XML formats.
        self.creator_id = creator_id  # type: str
        # The ID of the API group.
        self.description = description  # type: str
        # The description of the API.
        self.folder_id = folder_id  # type: long
        # The ID of the Alibaba Cloud account used by the user who last modified the API.
        self.group_id = group_id  # type: str
        # The scope in which the API is visible. Valid values: 0 and 1. A value of 0 indicates that the API is visible within the workspace. A value of 1 indicates that the API is visible only to the API creator.
        self.modified_time = modified_time  # type: str
        # The time when the API was last modified.
        self.operator_id = operator_id  # type: str
        # The type of the API. Valid values: 0, 1, and 2. A value of 0 indicates that the API is generated in wizard mode. A value of 1 indicates that the API is generated in script mode. A value of 2 indicates that the API is generated by registration.
        self.project_id = project_id  # type: long
        # The path of the API.
        self.protocols = protocols  # type: list[int]
        # The protocols used by the API. Valid values: 0 and 1. A value of 0 indicates that the API uses HTTP. A value of 1 indicates that the API uses HTTPS. Multiple protocols are presented in a list.
        self.registration_details = registration_details  # type: ListDataServiceApisResponseBodyDataApisRegistrationDetails
        # The ID of the folder in which the API is stored.
        self.request_method = request_method  # type: int
        # The ID of the workspace.
        self.response_content_type = response_content_type  # type: int
        # The details of the API generated in script mode. This parameter is returned only if the API is generated in script mode.
        self.script_details = script_details  # type: ListDataServiceApisResponseBodyDataApisScriptDetails
        # The timeout period of the API request. Unit: milliseconds.
        self.status = status  # type: int
        # The name of the API.
        self.tenant_id = tenant_id  # type: long
        # The APIs in the development state.
        self.timeout = timeout  # type: int
        # The ID of the Alibaba Cloud account used by the creator of the API.
        self.visible_range = visible_range  # type: int
        # The details of the API generated in wizard mode. This parameter is returned only if the API is generated in wizard mode.
        self.wizard_details = wizard_details  # type: ListDataServiceApisResponseBodyDataApisWizardDetails

    def validate(self):
        if self.registration_details:
            self.registration_details.validate()
        if self.script_details:
            self.script_details.validate()
        if self.wizard_details:
            self.wizard_details.validate()

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyDataApis, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.api_mode is not None:
            result['ApiMode'] = self.api_mode
        if self.api_name is not None:
            result['ApiName'] = self.api_name
        if self.api_path is not None:
            result['ApiPath'] = self.api_path
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.description is not None:
            result['Description'] = self.description
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.operator_id is not None:
            result['OperatorId'] = self.operator_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.protocols is not None:
            result['Protocols'] = self.protocols
        if self.registration_details is not None:
            result['RegistrationDetails'] = self.registration_details.to_map()
        if self.request_method is not None:
            result['RequestMethod'] = self.request_method
        if self.response_content_type is not None:
            result['ResponseContentType'] = self.response_content_type
        if self.script_details is not None:
            result['ScriptDetails'] = self.script_details.to_map()
        if self.status is not None:
            result['Status'] = self.status
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.timeout is not None:
            result['Timeout'] = self.timeout
        if self.visible_range is not None:
            result['VisibleRange'] = self.visible_range
        if self.wizard_details is not None:
            result['WizardDetails'] = self.wizard_details.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ApiMode') is not None:
            self.api_mode = m.get('ApiMode')
        if m.get('ApiName') is not None:
            self.api_name = m.get('ApiName')
        if m.get('ApiPath') is not None:
            self.api_path = m.get('ApiPath')
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('OperatorId') is not None:
            self.operator_id = m.get('OperatorId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Protocols') is not None:
            self.protocols = m.get('Protocols')
        if m.get('RegistrationDetails') is not None:
            temp_model = ListDataServiceApisResponseBodyDataApisRegistrationDetails()
            self.registration_details = temp_model.from_map(m['RegistrationDetails'])
        if m.get('RequestMethod') is not None:
            self.request_method = m.get('RequestMethod')
        if m.get('ResponseContentType') is not None:
            self.response_content_type = m.get('ResponseContentType')
        if m.get('ScriptDetails') is not None:
            temp_model = ListDataServiceApisResponseBodyDataApisScriptDetails()
            self.script_details = temp_model.from_map(m['ScriptDetails'])
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('Timeout') is not None:
            self.timeout = m.get('Timeout')
        if m.get('VisibleRange') is not None:
            self.visible_range = m.get('VisibleRange')
        if m.get('WizardDetails') is not None:
            temp_model = ListDataServiceApisResponseBodyDataApisWizardDetails()
            self.wizard_details = temp_model.from_map(m['WizardDetails'])
        return self


class ListDataServiceApisResponseBodyData(TeaModel):
    def __init__(self, apis=None, page_number=None, page_size=None, total_count=None):
        # The total number of entries.
        self.apis = apis  # type: list[ListDataServiceApisResponseBodyDataApis]
        # The information about the APIs in the development state.
        self.page_number = page_number  # type: int
        # The page number of the returned page. The value of this parameter is the same as that of the PageNumber parameter in the request.
        self.page_size = page_size  # type: int
        # The number of entries returned per page. Default value: 10. A maximum of 100 entries can be returned on each page.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.apis:
            for k in self.apis:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServiceApisResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Apis'] = []
        if self.apis is not None:
            for k in self.apis:
                result['Apis'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.apis = []
        if m.get('Apis') is not None:
            for k in m.get('Apis'):
                temp_model = ListDataServiceApisResponseBodyDataApis()
                self.apis.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListDataServiceApisResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The error code.
        self.data = data  # type: ListDataServiceApisResponseBodyData
        # Indicates whether the request is successful.
        self.error_code = error_code  # type: str
        # The ID of the request.
        self.error_message = error_message  # type: str
        # The ID of the Alibaba Cloud account used by the creator of the API. The ID can be used to search for the API created by the creator.
        self.http_status_code = http_status_code  # type: int
        # The HTTP status code.
        self.request_id = request_id  # type: str
        # The error message.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListDataServiceApisResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListDataServiceApisResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListDataServiceApisResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDataServiceApisResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDataServiceApisResponse, self).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=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 = ListDataServiceApisResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDataServiceApplicationsRequest(TeaModel):
    def __init__(self, page_number=None, page_size=None, project_id_list=None, tenant_id=None):
        # The number of the page to return. Pages start from page 1. Default value: 1.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the workspace based on which you want to query the basic information of applications. You can specify multiple IDs. Separate them with commas (,). You must specify at least one workspace ID. You can specify a maximum of 50 workspace IDs.
        self.project_id_list = project_id_list  # type: str
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApplicationsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id_list is not None:
            result['ProjectIdList'] = self.project_id_list
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectIdList') is not None:
            self.project_id_list = m.get('ProjectIdList')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataServiceApplicationsResponseBodyDataApplications(TeaModel):
    def __init__(self, application_id=None, application_name=None, project_id=None):
        # The ID of the application.
        self.application_id = application_id  # type: long
        # The name of the application.
        self.application_name = application_name  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceApplicationsResponseBodyDataApplications, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.application_id is not None:
            result['ApplicationId'] = self.application_id
        if self.application_name is not None:
            result['ApplicationName'] = self.application_name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApplicationId') is not None:
            self.application_id = m.get('ApplicationId')
        if m.get('ApplicationName') is not None:
            self.application_name = m.get('ApplicationName')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListDataServiceApplicationsResponseBodyData(TeaModel):
    def __init__(self, applications=None, page_number=None, page_size=None, total_count=None):
        # The basic information of the applications.
        self.applications = applications  # type: list[ListDataServiceApplicationsResponseBodyDataApplications]
        # The page number of the returned page. The value of this parameter is the same as that of the PageNumber parameter in the request.
        self.page_number = page_number  # type: int
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The total number of entries returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.applications:
            for k in self.applications:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServiceApplicationsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Applications'] = []
        if self.applications is not None:
            for k in self.applications:
                result['Applications'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.applications = []
        if m.get('Applications') is not None:
            for k in m.get('Applications'):
                temp_model = ListDataServiceApplicationsResponseBodyDataApplications()
                self.applications.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListDataServiceApplicationsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The returned result.
        self.data = data  # type: ListDataServiceApplicationsResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListDataServiceApplicationsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListDataServiceApplicationsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListDataServiceApplicationsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDataServiceApplicationsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDataServiceApplicationsResponse, self).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=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 = ListDataServiceApplicationsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDataServiceAuthorizedApisRequest(TeaModel):
    def __init__(self, api_name_keyword=None, page_number=None, page_size=None, project_id=None, tenant_id=None):
        # The keyword in API names. The keyword is used to search for the APIs whose names contain the keyword.
        self.api_name_keyword = api_name_keyword  # type: str
        # The number of the page to return. Pages start from page 1. Default value: 1.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceAuthorizedApisRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_name_keyword is not None:
            result['ApiNameKeyword'] = self.api_name_keyword
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiNameKeyword') is not None:
            self.api_name_keyword = m.get('ApiNameKeyword')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataServiceAuthorizedApisResponseBodyDataApiAuthorizedList(TeaModel):
    def __init__(self, api_id=None, api_name=None, api_path=None, api_status=None, created_time=None,
                 creator_id=None, grant_created_time=None, grant_end_time=None, grant_operator_id=None, group_id=None,
                 modified_time=None, project_id=None, tenant_id=None):
        # The ID of the API.
        self.api_id = api_id  # type: long
        # The name of the API.
        self.api_name = api_name  # type: str
        # The path of the API.
        self.api_path = api_path  # type: str
        # The status of the API. Valid values: 0 and 1. The value 0 indicates that the API is not published. The value 1 indicates that the API is published.
        self.api_status = api_status  # type: int
        # The time when the API was created.
        self.created_time = created_time  # type: str
        # The ID of the Alibaba Cloud account used by the API owner.
        self.creator_id = creator_id  # type: str
        # The time when the access permissions of the API were granted.
        self.grant_created_time = grant_created_time  # type: str
        # The expiration time for the granted access permissions of the API.
        self.grant_end_time = grant_end_time  # type: str
        # The ID of the Alibaba Cloud account used by the user who granted the access permissions of the API.
        self.grant_operator_id = grant_operator_id  # type: str
        # The ID of the API group.
        self.group_id = group_id  # type: str
        # The time when the API was last updated.
        self.modified_time = modified_time  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceAuthorizedApisResponseBodyDataApiAuthorizedList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.api_name is not None:
            result['ApiName'] = self.api_name
        if self.api_path is not None:
            result['ApiPath'] = self.api_path
        if self.api_status is not None:
            result['ApiStatus'] = self.api_status
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.grant_created_time is not None:
            result['GrantCreatedTime'] = self.grant_created_time
        if self.grant_end_time is not None:
            result['GrantEndTime'] = self.grant_end_time
        if self.grant_operator_id is not None:
            result['GrantOperatorId'] = self.grant_operator_id
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ApiName') is not None:
            self.api_name = m.get('ApiName')
        if m.get('ApiPath') is not None:
            self.api_path = m.get('ApiPath')
        if m.get('ApiStatus') is not None:
            self.api_status = m.get('ApiStatus')
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('GrantCreatedTime') is not None:
            self.grant_created_time = m.get('GrantCreatedTime')
        if m.get('GrantEndTime') is not None:
            self.grant_end_time = m.get('GrantEndTime')
        if m.get('GrantOperatorId') is not None:
            self.grant_operator_id = m.get('GrantOperatorId')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataServiceAuthorizedApisResponseBodyData(TeaModel):
    def __init__(self, api_authorized_list=None, page_number=None, page_size=None, total_count=None):
        # The list of APIs that you are authorized to access.
        self.api_authorized_list = api_authorized_list  # type: list[ListDataServiceAuthorizedApisResponseBodyDataApiAuthorizedList]
        # The page number of the returned page. The value of this parameter is the same as that of the PageNumber parameter in the request.
        self.page_number = page_number  # type: int
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The total number of returned entries.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.api_authorized_list:
            for k in self.api_authorized_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServiceAuthorizedApisResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ApiAuthorizedList'] = []
        if self.api_authorized_list is not None:
            for k in self.api_authorized_list:
                result['ApiAuthorizedList'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.api_authorized_list = []
        if m.get('ApiAuthorizedList') is not None:
            for k in m.get('ApiAuthorizedList'):
                temp_model = ListDataServiceAuthorizedApisResponseBodyDataApiAuthorizedList()
                self.api_authorized_list.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListDataServiceAuthorizedApisResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The information about the APIs that you are authorized to access.
        self.data = data  # type: ListDataServiceAuthorizedApisResponseBodyData
        # The error code.
        self.error_code = error_code  # type: str
        # The error message.
        self.error_message = error_message  # type: str
        # The HTTP status code.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListDataServiceAuthorizedApisResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListDataServiceAuthorizedApisResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListDataServiceAuthorizedApisResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDataServiceAuthorizedApisResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDataServiceAuthorizedApisResponse, self).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=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 = ListDataServiceAuthorizedApisResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDataServiceFoldersRequest(TeaModel):
    def __init__(self, folder_name_keyword=None, group_id=None, page_number=None, page_size=None, project_id=None,
                 tenant_id=None):
        # The keyword in folder names. The keyword is used to search for folders whose names contain this keyword.
        self.folder_name_keyword = folder_name_keyword  # type: str
        # The ID of the business process to which the folders belong.
        self.group_id = group_id  # type: str
        # The number of the page to return. Pages start from page 1. Default value: 1.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceFoldersRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder_name_keyword is not None:
            result['FolderNameKeyword'] = self.folder_name_keyword
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FolderNameKeyword') is not None:
            self.folder_name_keyword = m.get('FolderNameKeyword')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataServiceFoldersResponseBodyFolderPagingResultFolders(TeaModel):
    def __init__(self, created_time=None, folder_id=None, folder_name=None, group_id=None, modified_time=None,
                 parent_id=None, project_id=None, tenant_id=None):
        # The time when the folder was created.
        self.created_time = created_time  # type: str
        # The ID of the folder.
        self.folder_id = folder_id  # type: long
        # The name of the folder.
        self.folder_name = folder_name  # type: str
        # The ID of the business process to which the folder belongs.
        self.group_id = group_id  # type: str
        # The time when the folder was last modified.
        self.modified_time = modified_time  # type: str
        # The ID of the parent folder. The ID of the root folder in a business process is 0, and the ID of a folder created by a user in a business process is greater than 0.
        self.parent_id = parent_id  # type: long
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceFoldersResponseBodyFolderPagingResultFolders, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.folder_name is not None:
            result['FolderName'] = self.folder_name
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.parent_id is not None:
            result['ParentId'] = self.parent_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('FolderName') is not None:
            self.folder_name = m.get('FolderName')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('ParentId') is not None:
            self.parent_id = m.get('ParentId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataServiceFoldersResponseBodyFolderPagingResult(TeaModel):
    def __init__(self, folders=None, page_number=None, page_size=None, total_count=None):
        # The folders.
        self.folders = folders  # type: list[ListDataServiceFoldersResponseBodyFolderPagingResultFolders]
        # The page number of the returned page. The value of this parameter is the same as that of the PageNumber parameter in the request.
        self.page_number = page_number  # type: int
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The total number of returned entries.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.folders:
            for k in self.folders:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServiceFoldersResponseBodyFolderPagingResult, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Folders'] = []
        if self.folders is not None:
            for k in self.folders:
                result['Folders'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.folders = []
        if m.get('Folders') is not None:
            for k in m.get('Folders'):
                temp_model = ListDataServiceFoldersResponseBodyFolderPagingResultFolders()
                self.folders.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListDataServiceFoldersResponseBody(TeaModel):
    def __init__(self, folder_paging_result=None, request_id=None):
        # The paging result for the folders.
        self.folder_paging_result = folder_paging_result  # type: ListDataServiceFoldersResponseBodyFolderPagingResult
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.folder_paging_result:
            self.folder_paging_result.validate()

    def to_map(self):
        _map = super(ListDataServiceFoldersResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder_paging_result is not None:
            result['FolderPagingResult'] = self.folder_paging_result.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FolderPagingResult') is not None:
            temp_model = ListDataServiceFoldersResponseBodyFolderPagingResult()
            self.folder_paging_result = temp_model.from_map(m['FolderPagingResult'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListDataServiceFoldersResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDataServiceFoldersResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDataServiceFoldersResponse, self).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=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 = ListDataServiceFoldersResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDataServiceGroupsRequest(TeaModel):
    def __init__(self, group_name_keyword=None, page_number=None, page_size=None, project_id=None, tenant_id=None):
        # The keyword of a business process name. The keyword is used to search for business processes whose names contain this keyword.
        self.group_name_keyword = group_name_keyword  # type: str
        # The number of the page to return. Pages start from page 1. Default value: 1.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceGroupsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.group_name_keyword is not None:
            result['GroupNameKeyword'] = self.group_name_keyword
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('GroupNameKeyword') is not None:
            self.group_name_keyword = m.get('GroupNameKeyword')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataServiceGroupsResponseBodyGroupPagingResultGroups(TeaModel):
    def __init__(self, api_gateway_group_id=None, created_time=None, creator_id=None, description=None,
                 group_id=None, group_name=None, modified_time=None, project_id=None, tenant_id=None):
        # The ID of the API group that is associated with the business process in the API Gateway console.
        self.api_gateway_group_id = api_gateway_group_id  # type: str
        # The time when the business process was created.
        self.created_time = created_time  # type: str
        # The user identifier (UID) of the creator of the business process. The value of this parameter may be empty for creators of some existing business processes.
        self.creator_id = creator_id  # type: str
        # The description of the business process.
        self.description = description  # type: str
        # The ID of the business process.
        self.group_id = group_id  # type: str
        # The name of the business process.
        self.group_name = group_name  # type: str
        # The time when the business process was modified.
        self.modified_time = modified_time  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServiceGroupsResponseBodyGroupPagingResultGroups, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_gateway_group_id is not None:
            result['ApiGatewayGroupId'] = self.api_gateway_group_id
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.description is not None:
            result['Description'] = self.description
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.group_name is not None:
            result['GroupName'] = self.group_name
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiGatewayGroupId') is not None:
            self.api_gateway_group_id = m.get('ApiGatewayGroupId')
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('GroupName') is not None:
            self.group_name = m.get('GroupName')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataServiceGroupsResponseBodyGroupPagingResult(TeaModel):
    def __init__(self, groups=None, page_number=None, page_size=None, total_count=None):
        # The business processes.
        self.groups = groups  # type: list[ListDataServiceGroupsResponseBodyGroupPagingResultGroups]
        # The page number of the returned page. The value of this parameter is the same as that of the PageNumber parameter in the request.
        self.page_number = page_number  # type: int
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The total number of entries returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.groups:
            for k in self.groups:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServiceGroupsResponseBodyGroupPagingResult, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Groups'] = []
        if self.groups is not None:
            for k in self.groups:
                result['Groups'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.groups = []
        if m.get('Groups') is not None:
            for k in m.get('Groups'):
                temp_model = ListDataServiceGroupsResponseBodyGroupPagingResultGroups()
                self.groups.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListDataServiceGroupsResponseBody(TeaModel):
    def __init__(self, group_paging_result=None, request_id=None):
        # The paging result for the business processes.
        self.group_paging_result = group_paging_result  # type: ListDataServiceGroupsResponseBodyGroupPagingResult
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.group_paging_result:
            self.group_paging_result.validate()

    def to_map(self):
        _map = super(ListDataServiceGroupsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.group_paging_result is not None:
            result['GroupPagingResult'] = self.group_paging_result.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('GroupPagingResult') is not None:
            temp_model = ListDataServiceGroupsResponseBodyGroupPagingResult()
            self.group_paging_result = temp_model.from_map(m['GroupPagingResult'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListDataServiceGroupsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDataServiceGroupsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDataServiceGroupsResponse, self).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=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 = ListDataServiceGroupsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDataServicePublishedApisRequest(TeaModel):
    def __init__(self, api_name_keyword=None, api_path_keyword=None, creator_id=None, page_number=None,
                 page_size=None, project_id=None, tenant_id=None):
        # The ID of the tenant.
        self.api_name_keyword = api_name_keyword  # type: str
        # The keyword in the name of the API. The keyword can be used to search for the API whose name contains the keyword.
        self.api_path_keyword = api_path_keyword  # type: str
        # The keyword in the path of the API. The keyword can be used to search for the API whose path contains the keyword.
        self.creator_id = creator_id  # type: str
        # The operation that you want to perform. Set the value to **ListDataServicePublishedApis**.
        self.page_number = page_number  # type: int
        # The number of the page to return. Pages start from page 1. Default value: 1.
        self.page_size = page_size  # type: int
        # The number of entries to return on each page. Default value: 10. A maximum of 100 entries can be returned on each page.
        self.project_id = project_id  # type: long
        # The ID of the workspace.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServicePublishedApisRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_name_keyword is not None:
            result['ApiNameKeyword'] = self.api_name_keyword
        if self.api_path_keyword is not None:
            result['ApiPathKeyword'] = self.api_path_keyword
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiNameKeyword') is not None:
            self.api_name_keyword = m.get('ApiNameKeyword')
        if m.get('ApiPathKeyword') is not None:
            self.api_path_keyword = m.get('ApiPathKeyword')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataServicePublishedApisResponseBodyDataApisRegistrationDetailsRegistrationErrorCodes(TeaModel):
    def __init__(self, error_code=None, error_message=None, error_solution=None):
        # The error message.
        self.error_code = error_code  # type: str
        # The error codes returned for the API generated by registration.
        self.error_message = error_message  # type: str
        # The error code.
        self.error_solution = error_solution  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisRegistrationDetailsRegistrationErrorCodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.error_solution is not None:
            result['ErrorSolution'] = self.error_solution
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('ErrorSolution') is not None:
            self.error_solution = m.get('ErrorSolution')
        return self


class ListDataServicePublishedApisResponseBodyDataApisRegistrationDetailsRegistrationRequestParameters(TeaModel):
    def __init__(self, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The description of the parameter.
        self.default_value = default_value  # type: str
        # The operator used for the value of the parameter. Valid values:
        # 
        # *   0: Equal
        # *   1: Like
        # *   2: Const
        # *   3: In
        # 
        # APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.example_value = example_value  # type: str
        # The data type of the parameter. Valid values:
        # 
        # *   0: STRING
        # *   1: INT
        # *   2: LONG
        # *   3: FLOAT
        # *   4: DOUBLE
        # *   5: BOOLEAN
        self.is_required_parameter = is_required_parameter  # type: bool
        # The sample value of the parameter.
        self.parameter_data_type = parameter_data_type  # type: int
        # The position of the parameter. Valid values:
        # 
        # *   0: Path
        # *   1: Query
        # *   2: Head
        # *   3: Body
        # 
        # APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_description = parameter_description  # type: str
        # The request parameters of the API generated by registration.
        self.parameter_name = parameter_name  # type: str
        # The default value of the parameter.
        self.parameter_operator = parameter_operator  # type: int
        # The name of the parameter.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisRegistrationDetailsRegistrationRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class ListDataServicePublishedApisResponseBodyDataApisRegistrationDetails(TeaModel):
    def __init__(self, failed_result_sample=None, registration_error_codes=None,
                 registration_request_parameters=None, service_content_type=None, service_host=None, service_path=None,
                 service_request_body_description=None, successful_result_sample=None):
        # The sample success response of the API.
        self.failed_result_sample = failed_result_sample  # type: str
        # The body of the request initiated to call the backend service.
        self.registration_error_codes = registration_error_codes  # type: list[ListDataServicePublishedApisResponseBodyDataApisRegistrationDetailsRegistrationErrorCodes]
        # The solution used to resolve the issue.
        self.registration_request_parameters = registration_request_parameters  # type: list[ListDataServicePublishedApisResponseBodyDataApisRegistrationDetailsRegistrationRequestParameters]
        # The URL of the backend service.
        self.service_content_type = service_content_type  # type: int
        # The details of the API generated by registration. This parameter is returned only if the API is generated by registration.
        self.service_host = service_host  # type: str
        # The format in which the response of the API request is returned. Valid values: 0 and 1. A value of 0 indicates the JSON format. A value of 1 indicates the XML format. APIs generated in wizard or script mode support the JSON format. APIs generated by registration support the JSON and XML formats.
        self.service_path = service_path  # type: str
        # The sample error response of the API.
        self.service_request_body_description = service_request_body_description  # type: str
        # The path of the backend service.
        self.successful_result_sample = successful_result_sample  # type: str

    def validate(self):
        if self.registration_error_codes:
            for k in self.registration_error_codes:
                if k:
                    k.validate()
        if self.registration_request_parameters:
            for k in self.registration_request_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisRegistrationDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.failed_result_sample is not None:
            result['FailedResultSample'] = self.failed_result_sample
        result['RegistrationErrorCodes'] = []
        if self.registration_error_codes is not None:
            for k in self.registration_error_codes:
                result['RegistrationErrorCodes'].append(k.to_map() if k else None)
        result['RegistrationRequestParameters'] = []
        if self.registration_request_parameters is not None:
            for k in self.registration_request_parameters:
                result['RegistrationRequestParameters'].append(k.to_map() if k else None)
        if self.service_content_type is not None:
            result['ServiceContentType'] = self.service_content_type
        if self.service_host is not None:
            result['ServiceHost'] = self.service_host
        if self.service_path is not None:
            result['ServicePath'] = self.service_path
        if self.service_request_body_description is not None:
            result['ServiceRequestBodyDescription'] = self.service_request_body_description
        if self.successful_result_sample is not None:
            result['SuccessfulResultSample'] = self.successful_result_sample
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FailedResultSample') is not None:
            self.failed_result_sample = m.get('FailedResultSample')
        self.registration_error_codes = []
        if m.get('RegistrationErrorCodes') is not None:
            for k in m.get('RegistrationErrorCodes'):
                temp_model = ListDataServicePublishedApisResponseBodyDataApisRegistrationDetailsRegistrationErrorCodes()
                self.registration_error_codes.append(temp_model.from_map(k))
        self.registration_request_parameters = []
        if m.get('RegistrationRequestParameters') is not None:
            for k in m.get('RegistrationRequestParameters'):
                temp_model = ListDataServicePublishedApisResponseBodyDataApisRegistrationDetailsRegistrationRequestParameters()
                self.registration_request_parameters.append(temp_model.from_map(k))
        if m.get('ServiceContentType') is not None:
            self.service_content_type = m.get('ServiceContentType')
        if m.get('ServiceHost') is not None:
            self.service_host = m.get('ServiceHost')
        if m.get('ServicePath') is not None:
            self.service_path = m.get('ServicePath')
        if m.get('ServiceRequestBodyDescription') is not None:
            self.service_request_body_description = m.get('ServiceRequestBodyDescription')
        if m.get('SuccessfulResultSample') is not None:
            self.successful_result_sample = m.get('SuccessfulResultSample')
        return self


class ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptConnection(TeaModel):
    def __init__(self, connection_id=None, table_name=None):
        # The ID of the data source.
        self.connection_id = connection_id  # type: long
        # The name of the table in the data source.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptConnection, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_id is not None:
            result['ConnectionId'] = self.connection_id
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionId') is not None:
            self.connection_id = m.get('ConnectionId')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptErrorCodes(TeaModel):
    def __init__(self, error_code=None, error_message=None, error_solution=None):
        # The error code.
        self.error_code = error_code  # type: str
        # The error message.
        self.error_message = error_message  # type: str
        # The solution used to resolve the issue.
        self.error_solution = error_solution  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptErrorCodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.error_solution is not None:
            result['ErrorSolution'] = self.error_solution
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('ErrorSolution') is not None:
            self.error_solution = m.get('ErrorSolution')
        return self


class ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptRequestParameters(TeaModel):
    def __init__(self, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The default value of the parameter.
        self.default_value = default_value  # type: str
        # The sample value of the parameter.
        self.example_value = example_value  # type: str
        # Indicates whether the request parameter is required.
        self.is_required_parameter = is_required_parameter  # type: bool
        # The data type of the parameter. Valid values:
        # 
        # - 0: STRING
        # - 1: INT
        # - 2: LONG
        # - 3: FLOAT
        # - 4: DOUBLE
        # - 5: BOOLEAN
        self.parameter_data_type = parameter_data_type  # type: int
        # The description of the parameter.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str
        # The operator used for the value of the parameter. Valid values:
        # 
        # - 0: Equal
        # - 1: Like
        # - 2: Const
        # - 3: In
        # 
        # APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.parameter_operator = parameter_operator  # type: int
        # The position of the parameter. Valid values:
        # 
        # - 0: Path
        # - 1: Query
        # - 2: Head
        # - 3: Body
        # 
        # APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptResponseParameters(TeaModel):
    def __init__(self, example_value=None, parameter_data_type=None, parameter_description=None,
                 parameter_name=None):
        # The sample value of the parameter.
        self.example_value = example_value  # type: str
        # The data type of the parameter. Valid values:
        # 
        # - 0: STRING
        # - 1: INT
        # - 2: LONG
        # - 3: FLOAT
        # - 4: DOUBLE
        # - 5: BOOLEAN
        self.parameter_data_type = parameter_data_type  # type: int
        # The description of the parameter.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptResponseParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        return self


class ListDataServicePublishedApisResponseBodyDataApisScriptDetails(TeaModel):
    def __init__(self, failed_result_sample=None, is_paged_response=None, script=None, script_connection=None,
                 script_error_codes=None, script_request_parameters=None, script_response_parameters=None,
                 successful_result_sample=None):
        # The sample error response of the API.
        self.failed_result_sample = failed_result_sample  # type: str
        # Indicates whether the entries are returned by page.
        self.is_paged_response = is_paged_response  # type: bool
        # The SQL script.
        self.script = script  # type: str
        # The data source information of the API generated in script mode.
        self.script_connection = script_connection  # type: ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptConnection
        # The error codes returned for the API generated in script mode.
        self.script_error_codes = script_error_codes  # type: list[ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptErrorCodes]
        # The request parameters of the API generated in script mode.
        self.script_request_parameters = script_request_parameters  # type: list[ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptRequestParameters]
        # The response parameters of the API generated in script mode.
        self.script_response_parameters = script_response_parameters  # type: list[ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptResponseParameters]
        # The sample success response of the API.
        self.successful_result_sample = successful_result_sample  # type: str

    def validate(self):
        if self.script_connection:
            self.script_connection.validate()
        if self.script_error_codes:
            for k in self.script_error_codes:
                if k:
                    k.validate()
        if self.script_request_parameters:
            for k in self.script_request_parameters:
                if k:
                    k.validate()
        if self.script_response_parameters:
            for k in self.script_response_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisScriptDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.failed_result_sample is not None:
            result['FailedResultSample'] = self.failed_result_sample
        if self.is_paged_response is not None:
            result['IsPagedResponse'] = self.is_paged_response
        if self.script is not None:
            result['Script'] = self.script
        if self.script_connection is not None:
            result['ScriptConnection'] = self.script_connection.to_map()
        result['ScriptErrorCodes'] = []
        if self.script_error_codes is not None:
            for k in self.script_error_codes:
                result['ScriptErrorCodes'].append(k.to_map() if k else None)
        result['ScriptRequestParameters'] = []
        if self.script_request_parameters is not None:
            for k in self.script_request_parameters:
                result['ScriptRequestParameters'].append(k.to_map() if k else None)
        result['ScriptResponseParameters'] = []
        if self.script_response_parameters is not None:
            for k in self.script_response_parameters:
                result['ScriptResponseParameters'].append(k.to_map() if k else None)
        if self.successful_result_sample is not None:
            result['SuccessfulResultSample'] = self.successful_result_sample
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FailedResultSample') is not None:
            self.failed_result_sample = m.get('FailedResultSample')
        if m.get('IsPagedResponse') is not None:
            self.is_paged_response = m.get('IsPagedResponse')
        if m.get('Script') is not None:
            self.script = m.get('Script')
        if m.get('ScriptConnection') is not None:
            temp_model = ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptConnection()
            self.script_connection = temp_model.from_map(m['ScriptConnection'])
        self.script_error_codes = []
        if m.get('ScriptErrorCodes') is not None:
            for k in m.get('ScriptErrorCodes'):
                temp_model = ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptErrorCodes()
                self.script_error_codes.append(temp_model.from_map(k))
        self.script_request_parameters = []
        if m.get('ScriptRequestParameters') is not None:
            for k in m.get('ScriptRequestParameters'):
                temp_model = ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptRequestParameters()
                self.script_request_parameters.append(temp_model.from_map(k))
        self.script_response_parameters = []
        if m.get('ScriptResponseParameters') is not None:
            for k in m.get('ScriptResponseParameters'):
                temp_model = ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptResponseParameters()
                self.script_response_parameters.append(temp_model.from_map(k))
        if m.get('SuccessfulResultSample') is not None:
            self.successful_result_sample = m.get('SuccessfulResultSample')
        return self


class ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardConnection(TeaModel):
    def __init__(self, connection_id=None, table_name=None):
        # The ID of the data source.
        self.connection_id = connection_id  # type: long
        # The name of the table in the data source.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardConnection, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_id is not None:
            result['ConnectionId'] = self.connection_id
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionId') is not None:
            self.connection_id = m.get('ConnectionId')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardErrorCodes(TeaModel):
    def __init__(self, error_code=None, error_message=None, error_solution=None):
        # The error code.
        self.error_code = error_code  # type: str
        # The error message.
        self.error_message = error_message  # type: str
        # The solution used to resolve the issue.
        self.error_solution = error_solution  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardErrorCodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.error_solution is not None:
            result['ErrorSolution'] = self.error_solution
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('ErrorSolution') is not None:
            self.error_solution = m.get('ErrorSolution')
        return self


class ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardRequestParameters(TeaModel):
    def __init__(self, default_value=None, example_value=None, is_required_parameter=None,
                 parameter_data_type=None, parameter_description=None, parameter_name=None, parameter_operator=None,
                 parameter_position=None):
        # The default value of the parameter.
        self.default_value = default_value  # type: str
        # The sample value of the parameter.
        self.example_value = example_value  # type: str
        # Indicates whether the request parameter is required.
        self.is_required_parameter = is_required_parameter  # type: bool
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. A value of 0 indicates the STRING data type. A value of 1 indicates the INT data type. A value of 2 indicates the LONG data type. A value of 3 indicates the FLOAT data type. A value of 4 indicates the DOUBLE data type. A value of 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description of the parameter.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str
        # The operator used for the value of the parameter. Valid values: 0, 1, 2, and 3. A value of 0 indicates that the operator is Equal. A value of 1 indicates that the operator is Like. A value of 2 indicates that the operator is Const. A value of 3 indicates that the operator is In. APIs generated in wizard mode support the Equal, Like, and In operators. APIs generated in script mode support the Equal operator. APIs generated by registration support the Equal and Const operators.
        self.parameter_operator = parameter_operator  # type: int
        # The position of the parameter. Valid values: 0, 1, 2, and 3. A value of 0 indicates that the parameter is in the URL path of the request. A value of 1 indicates that the parameter is in the Query parameter of the request URL. A value of 2 indicates that the parameter is in the request header. A value of 3 indicates that the parameter is in the request body. APIs generated in wizard or script mode support only the Query position. APIs generated by registration whose request method is GET or DELETE support the Query and Head positions. APIs generated by registration whose request method is PUT or POST support the Query, Head, and Body positions.
        self.parameter_position = parameter_position  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardRequestParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.default_value is not None:
            result['DefaultValue'] = self.default_value
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.is_required_parameter is not None:
            result['IsRequiredParameter'] = self.is_required_parameter
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        if self.parameter_operator is not None:
            result['ParameterOperator'] = self.parameter_operator
        if self.parameter_position is not None:
            result['ParameterPosition'] = self.parameter_position
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DefaultValue') is not None:
            self.default_value = m.get('DefaultValue')
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('IsRequiredParameter') is not None:
            self.is_required_parameter = m.get('IsRequiredParameter')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        if m.get('ParameterOperator') is not None:
            self.parameter_operator = m.get('ParameterOperator')
        if m.get('ParameterPosition') is not None:
            self.parameter_position = m.get('ParameterPosition')
        return self


class ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardResponseParameters(TeaModel):
    def __init__(self, example_value=None, parameter_data_type=None, parameter_description=None,
                 parameter_name=None):
        # The sample value of the parameter.
        self.example_value = example_value  # type: str
        # The data type of the parameter. Valid values: 0, 1, 2, 3, 4, and 5. A value of 0 indicates the STRING data type. A value of 1 indicates the INT data type. A value of 2 indicates the LONG data type. A value of 3 indicates the FLOAT data type. A value of 4 indicates the DOUBLE data type. A value of 5 indicates the BOOLEAN data type.
        self.parameter_data_type = parameter_data_type  # type: int
        # The description of the parameter.
        self.parameter_description = parameter_description  # type: str
        # The name of the parameter.
        self.parameter_name = parameter_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardResponseParameters, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.example_value is not None:
            result['ExampleValue'] = self.example_value
        if self.parameter_data_type is not None:
            result['ParameterDataType'] = self.parameter_data_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.parameter_name is not None:
            result['ParameterName'] = self.parameter_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ExampleValue') is not None:
            self.example_value = m.get('ExampleValue')
        if m.get('ParameterDataType') is not None:
            self.parameter_data_type = m.get('ParameterDataType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ParameterName') is not None:
            self.parameter_name = m.get('ParameterName')
        return self


class ListDataServicePublishedApisResponseBodyDataApisWizardDetails(TeaModel):
    def __init__(self, failed_result_sample=None, is_paged_response=None, successful_result_sample=None,
                 wizard_connection=None, wizard_error_codes=None, wizard_request_parameters=None, wizard_response_parameters=None):
        # The sample error response of the API.
        self.failed_result_sample = failed_result_sample  # type: str
        # Indicates whether the entries are returned by page.
        self.is_paged_response = is_paged_response  # type: bool
        # The sample success response of the API.
        self.successful_result_sample = successful_result_sample  # type: str
        # The data source information of the API generated in wizard mode.
        self.wizard_connection = wizard_connection  # type: ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardConnection
        # The error codes returned for the API generated in wizard mode.
        self.wizard_error_codes = wizard_error_codes  # type: list[ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardErrorCodes]
        # The request parameters of the API generated in wizard mode.
        self.wizard_request_parameters = wizard_request_parameters  # type: list[ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardRequestParameters]
        # The response parameters of the API generated in wizard mode.
        self.wizard_response_parameters = wizard_response_parameters  # type: list[ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardResponseParameters]

    def validate(self):
        if self.wizard_connection:
            self.wizard_connection.validate()
        if self.wizard_error_codes:
            for k in self.wizard_error_codes:
                if k:
                    k.validate()
        if self.wizard_request_parameters:
            for k in self.wizard_request_parameters:
                if k:
                    k.validate()
        if self.wizard_response_parameters:
            for k in self.wizard_response_parameters:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApisWizardDetails, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.failed_result_sample is not None:
            result['FailedResultSample'] = self.failed_result_sample
        if self.is_paged_response is not None:
            result['IsPagedResponse'] = self.is_paged_response
        if self.successful_result_sample is not None:
            result['SuccessfulResultSample'] = self.successful_result_sample
        if self.wizard_connection is not None:
            result['WizardConnection'] = self.wizard_connection.to_map()
        result['WizardErrorCodes'] = []
        if self.wizard_error_codes is not None:
            for k in self.wizard_error_codes:
                result['WizardErrorCodes'].append(k.to_map() if k else None)
        result['WizardRequestParameters'] = []
        if self.wizard_request_parameters is not None:
            for k in self.wizard_request_parameters:
                result['WizardRequestParameters'].append(k.to_map() if k else None)
        result['WizardResponseParameters'] = []
        if self.wizard_response_parameters is not None:
            for k in self.wizard_response_parameters:
                result['WizardResponseParameters'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FailedResultSample') is not None:
            self.failed_result_sample = m.get('FailedResultSample')
        if m.get('IsPagedResponse') is not None:
            self.is_paged_response = m.get('IsPagedResponse')
        if m.get('SuccessfulResultSample') is not None:
            self.successful_result_sample = m.get('SuccessfulResultSample')
        if m.get('WizardConnection') is not None:
            temp_model = ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardConnection()
            self.wizard_connection = temp_model.from_map(m['WizardConnection'])
        self.wizard_error_codes = []
        if m.get('WizardErrorCodes') is not None:
            for k in m.get('WizardErrorCodes'):
                temp_model = ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardErrorCodes()
                self.wizard_error_codes.append(temp_model.from_map(k))
        self.wizard_request_parameters = []
        if m.get('WizardRequestParameters') is not None:
            for k in m.get('WizardRequestParameters'):
                temp_model = ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardRequestParameters()
                self.wizard_request_parameters.append(temp_model.from_map(k))
        self.wizard_response_parameters = []
        if m.get('WizardResponseParameters') is not None:
            for k in m.get('WizardResponseParameters'):
                temp_model = ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardResponseParameters()
                self.wizard_response_parameters.append(temp_model.from_map(k))
        return self


class ListDataServicePublishedApisResponseBodyDataApis(TeaModel):
    def __init__(self, api_id=None, api_mode=None, api_name=None, api_path=None, created_time=None, creator_id=None,
                 description=None, group_id=None, modified_time=None, operator_id=None, project_id=None, protocols=None,
                 registration_details=None, request_method=None, response_content_type=None, script_details=None, status=None,
                 tenant_id=None, timeout=None, visible_range=None, wizard_details=None):
        # The status of the API. Valid values: 0 and 1. A value of 0 indicates that the API is not published. A value of 1 indicates that the API is published.
        self.api_id = api_id  # type: long
        # The ID of the API.
        self.api_mode = api_mode  # type: int
        # The time when the API was created.
        self.api_name = api_name  # type: str
        # The ID of the tenant.
        self.api_path = api_path  # type: str
        # The request method of the API. Valid values: 0, 1, 2, and 3. A value of 0 indicates the GET method. A value of 1 indicates the POST method. A value of 2 indicates the PUT method. A value of 3 indicates the DELETE method. APIs generated in wizard or script mode support the GET and POST methods. APIs generated by registration support the GET, POST, PUT, and DELETE methods.
        self.created_time = created_time  # type: str
        # The format in which the response of the API request is returned. Valid values: 0 and 1. A value of 0 indicates the JSON format. A value of 1 indicates the XML format. APIs generated in wizard or script mode support the JSON format. APIs generated by registration support the JSON and XML formats.
        self.creator_id = creator_id  # type: str
        # The ID of the API group.
        self.description = description  # type: str
        # The ID of the Alibaba Cloud account used by the user who last modified the API.
        self.group_id = group_id  # type: str
        # The scope in which the API is visible. Valid values: 0 and 1. A value of 0 indicates that the API is visible within the workspace. A value of 1 indicates that the API is visible only to the API creator.
        self.modified_time = modified_time  # type: str
        # The time when the API was last modified.
        self.operator_id = operator_id  # type: str
        # The type of the API. Valid values: 0, 1, and 2. A value of 0 indicates that the API is generated in wizard mode. A value of 1 indicates that the API is generated in script mode. A value of 2 indicates that the API is generated by registration.
        self.project_id = project_id  # type: long
        # The path of the API.
        self.protocols = protocols  # type: list[int]
        # The protocol used by the API. Valid values: 0 and 1. A value of 0 indicates that the API uses HTTP. A value of 1 indicates that the API uses HTTPS.
        self.registration_details = registration_details  # type: ListDataServicePublishedApisResponseBodyDataApisRegistrationDetails
        # The description of the API.
        self.request_method = request_method  # type: int
        # The ID of the workspace.
        self.response_content_type = response_content_type  # type: int
        # The details of the API generated in script mode. This parameter is returned only if the API is generated in script mode.
        self.script_details = script_details  # type: ListDataServicePublishedApisResponseBodyDataApisScriptDetails
        # The timeout period of the API request. Unit: milliseconds.
        self.status = status  # type: int
        # The name of the API.
        self.tenant_id = tenant_id  # type: long
        # The information about the APIs in the published state.
        self.timeout = timeout  # type: int
        # The ID of the Alibaba Cloud account used by the creator of the API.
        self.visible_range = visible_range  # type: int
        # The details of the API generated in wizard mode. This parameter is returned only if the API is generated in wizard mode.
        self.wizard_details = wizard_details  # type: ListDataServicePublishedApisResponseBodyDataApisWizardDetails

    def validate(self):
        if self.registration_details:
            self.registration_details.validate()
        if self.script_details:
            self.script_details.validate()
        if self.wizard_details:
            self.wizard_details.validate()

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyDataApis, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.api_mode is not None:
            result['ApiMode'] = self.api_mode
        if self.api_name is not None:
            result['ApiName'] = self.api_name
        if self.api_path is not None:
            result['ApiPath'] = self.api_path
        if self.created_time is not None:
            result['CreatedTime'] = self.created_time
        if self.creator_id is not None:
            result['CreatorId'] = self.creator_id
        if self.description is not None:
            result['Description'] = self.description
        if self.group_id is not None:
            result['GroupId'] = self.group_id
        if self.modified_time is not None:
            result['ModifiedTime'] = self.modified_time
        if self.operator_id is not None:
            result['OperatorId'] = self.operator_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.protocols is not None:
            result['Protocols'] = self.protocols
        if self.registration_details is not None:
            result['RegistrationDetails'] = self.registration_details.to_map()
        if self.request_method is not None:
            result['RequestMethod'] = self.request_method
        if self.response_content_type is not None:
            result['ResponseContentType'] = self.response_content_type
        if self.script_details is not None:
            result['ScriptDetails'] = self.script_details.to_map()
        if self.status is not None:
            result['Status'] = self.status
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.timeout is not None:
            result['Timeout'] = self.timeout
        if self.visible_range is not None:
            result['VisibleRange'] = self.visible_range
        if self.wizard_details is not None:
            result['WizardDetails'] = self.wizard_details.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ApiMode') is not None:
            self.api_mode = m.get('ApiMode')
        if m.get('ApiName') is not None:
            self.api_name = m.get('ApiName')
        if m.get('ApiPath') is not None:
            self.api_path = m.get('ApiPath')
        if m.get('CreatedTime') is not None:
            self.created_time = m.get('CreatedTime')
        if m.get('CreatorId') is not None:
            self.creator_id = m.get('CreatorId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('GroupId') is not None:
            self.group_id = m.get('GroupId')
        if m.get('ModifiedTime') is not None:
            self.modified_time = m.get('ModifiedTime')
        if m.get('OperatorId') is not None:
            self.operator_id = m.get('OperatorId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Protocols') is not None:
            self.protocols = m.get('Protocols')
        if m.get('RegistrationDetails') is not None:
            temp_model = ListDataServicePublishedApisResponseBodyDataApisRegistrationDetails()
            self.registration_details = temp_model.from_map(m['RegistrationDetails'])
        if m.get('RequestMethod') is not None:
            self.request_method = m.get('RequestMethod')
        if m.get('ResponseContentType') is not None:
            self.response_content_type = m.get('ResponseContentType')
        if m.get('ScriptDetails') is not None:
            temp_model = ListDataServicePublishedApisResponseBodyDataApisScriptDetails()
            self.script_details = temp_model.from_map(m['ScriptDetails'])
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('Timeout') is not None:
            self.timeout = m.get('Timeout')
        if m.get('VisibleRange') is not None:
            self.visible_range = m.get('VisibleRange')
        if m.get('WizardDetails') is not None:
            temp_model = ListDataServicePublishedApisResponseBodyDataApisWizardDetails()
            self.wizard_details = temp_model.from_map(m['WizardDetails'])
        return self


class ListDataServicePublishedApisResponseBodyData(TeaModel):
    def __init__(self, apis=None, page_number=None, page_size=None, total_count=None):
        # The total number of entries.
        self.apis = apis  # type: list[ListDataServicePublishedApisResponseBodyDataApis]
        # The APIs in the published state.
        self.page_number = page_number  # type: int
        # The page number of the returned page. The value of this parameter is the same as that of the PageNumber parameter in the request.
        self.page_size = page_size  # type: int
        # The number of entries returned per page. Default value: 10. A maximum of 100 entries can be returned on each page.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.apis:
            for k in self.apis:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Apis'] = []
        if self.apis is not None:
            for k in self.apis:
                result['Apis'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.apis = []
        if m.get('Apis') is not None:
            for k in m.get('Apis'):
                temp_model = ListDataServicePublishedApisResponseBodyDataApis()
                self.apis.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListDataServicePublishedApisResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The error code.
        self.data = data  # type: ListDataServicePublishedApisResponseBodyData
        # Indicates whether the request is successful.
        self.error_code = error_code  # type: str
        # The ID of the request.
        self.error_message = error_message  # type: str
        # The ID of the Alibaba Cloud account used by the creator of the API. The ID can be used to search for the API created by the creator.
        self.http_status_code = http_status_code  # type: int
        # The HTTP status code.
        self.request_id = request_id  # type: str
        # The error message.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListDataServicePublishedApisResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListDataServicePublishedApisResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDataServicePublishedApisResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDataServicePublishedApisResponse, self).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=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 = ListDataServicePublishedApisResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDataSourcesRequest(TeaModel):
    def __init__(self, data_source_type=None, env_type=None, name=None, page_number=None, page_size=None,
                 project_id=None, status=None, sub_type=None):
        # The status of the data source. Valid values:
        # 
        # *   ENABLED: The data source is accessible.
        # *   DISABLED: The data source is inaccessible.
        self.data_source_type = data_source_type  # type: str
        # The number of the page to return. The value of this parameter must be an integer greater than or equal to 1.
        self.env_type = env_type  # type: int
        # The subtype of the data source. This parameter takes effect only if the DataSourceType parameter is set to rds.
        # 
        # If the DataSourceType parameter is set to rds, this parameter can be set to mysql, sqlserver, or postgresql.
        self.name = name  # type: str
        # The ID of the request.
        self.page_number = page_number  # type: int
        # The HTTP status code returned.
        self.page_size = page_size  # type: int
        # The type of the data source. Valid values:
        # 
        # *   odps
        # *   mysql
        # *   rds
        # *   oss
        # *   sqlserver
        # *   polardb
        # *   oracle
        # *   mongodb
        # *   emr
        # *   postgresql
        # *   analyticdb_for_mysql
        # *   hybriddb_for_postgresql
        # *   holo
        self.project_id = project_id  # type: long
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.status = status  # type: str
        # The environment in which the data source is used. Valid values: 0 and 1. The value 0 indicates the development environment. The value 1 indicates the production environment.
        self.sub_type = sub_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataSourcesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.name is not None:
            result['Name'] = self.name
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        if self.sub_type is not None:
            result['SubType'] = self.sub_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('SubType') is not None:
            self.sub_type = m.get('SubType')
        return self


class ListDataSourcesResponseBodyDataDataSources(TeaModel):
    def __init__(self, binding_calc_engine_id=None, connect_status=None, content=None, data_source_type=None,
                 default_engine=None, description=None, env_type=None, gmt_create=None, gmt_modified=None, id=None, name=None,
                 operator=None, project_id=None, sequence=None, shared=None, status=None, sub_type=None, tenant_id=None):
        self.binding_calc_engine_id = binding_calc_engine_id  # type: long
        # The description of the data source.
        self.connect_status = connect_status  # type: int
        # The ID of the compute engine instance with which the data source is associated.
        self.content = content  # type: str
        # Indicates whether the compute engine instance that is associated with the data source is the default compute engine instance used by data sources of the same type.
        self.data_source_type = data_source_type  # type: str
        # The ID of the Alibaba Cloud account that is used to last modify the data source.
        self.default_engine = default_engine  # type: bool
        # The time when the data source was created. Example: Mar 17, 2021 4:09:32 PM.
        self.description = description  # type: str
        # The field that is used to sort data sources. Data sources are sorted in descending order based on the value of this parameter.
        self.env_type = env_type  # type: int
        # Indicates whether the data source is a shared data source.
        self.gmt_create = gmt_create  # type: str
        # The status of the data source. Valid values:
        # 
        # *   1: The data source is accessible.
        # *   2: The data source is inaccessible.
        self.gmt_modified = gmt_modified  # type: str
        # The ID of the tenant.
        self.id = id  # type: long
        # The ID of the data source.
        self.name = name  # type: str
        # The data connection string. The value of this parameter is in the JSON format. Sample connection strings of common data sources:
        # 
        # *   MaxCompute
        # 
        # <!---->
        # 
        #     json
        #     {
        #       "pubEndpoint": "http://service.cn.maxcompute.aliyun.com/api",
        #       "accessId": "xxxxxxx",
        #       "securityToken": null,
        #       "endpoint": "http://service.cn.maxcompute.aliyun-inc.com/api",
        #       "accessKey": "***",
        #       "name": "PRE_PROJECT_A_engine",
        #       "project": "PRE_PROJECT_A",
        #       "vpcEndpoint": "http://service.cn.maxcompute.aliyun-inc.com/api",
        #       "region": "cn-shanghai",
        #       "authType": "2"
        #     }
        # 
        # *   mysql
        # 
        # <!---->
        # 
        #     json
        #     {
        #       "configType": "1",
        #       "database": "mysql_d111b",
        #       "instanceName": "rm-xxxxxx",
        #       "password": "***",
        #       "rdsOwnerId": "12133xxxxxx",
        #       "tag": "rds",
        #       "username": "mysql_db111"
        #     }
        # 
        # *   sqlserver
        # 
        # <!---->
        # 
        #     json
        #     {
        #       "configType": "1",
        #       "jdbcUrl": "jdbc:sqlserver://rm-xxxxx.sqlserver.rds.aliyuncs.com:1433;DatabaseName=sqlserver_db1",
        #       "password": "***",
        #       "tag": "public",
        #       "username": "sqlserver_db111"
        #     }
        # 
        # *   oss
        # 
        # <!---->
        # 
        #     json
        #     {
        #       "accessId": "LTAINbR9Uxxxx",
        #       "accessKey": "***",
        #       "bucket": "bigxxx1223",
        #       "configType": "1",
        #       "endpoint": "http://oss-cn-hangzhou.aliyuncs.com",
        #       "tag": "public"
        #     }
        # 
        # *   postgresql
        # 
        # <!---->
        # 
        #     json
        #     {
        #       "configType": "1",
        #       "database": "cdp_xxx",
        #       "instanceName": "rm-xxxx",
        #       "password": "***",
        #       "rdsOwnerId": "121xxxxx",
        #       "tag": "rds",
        #       "username": "cdp_xxx"
        #     }
        # 
        # *   ads
        # 
        # <!---->
        # 
        #     json
        #     {
        #       "configType": "1",
        #       "password": "***",
        #       "schema": "ads_demo",
        #       "tag": "public",
        #       "url": "ads-xxx-xxxx.cn-hangzhou-1.ads.aliyuncs.com:3029",
        #       "username": "lslslsls"
        #     }
        self.operator = operator  # type: str
        # The time when the data source was last modified. Example: Mar 17, 2021 4:09:32 PM.
        self.project_id = project_id  # type: int
        # The type of the data source. Valid values:
        # 
        # *   odps
        # *   mysql
        # *   rds
        # *   oss
        # *   sqlserver
        # *   polardb
        # *   oracle
        # *   mongodb
        # *   emr
        # *   postgresql
        # *   analyticdb_for_mysql
        # *   hybriddb_for_postgresql
        # *   holo
        self.sequence = sequence  # type: int
        # The name of the data source.
        self.shared = shared  # type: bool
        # The subtype of the data source. This parameter takes effect only if the DataSourceType parameter is set to rds.
        # 
        # If the DataSourceType parameter is set to rds, this parameter can be set to mysql, sqlserver, or postgresql.
        self.status = status  # type: int
        # The environment in which the data source is used. Valid values:
        # 
        # *   0: development environment
        # *   1: production environment
        self.sub_type = sub_type  # type: str
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDataSourcesResponseBodyDataDataSources, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.binding_calc_engine_id is not None:
            result['BindingCalcEngineId'] = self.binding_calc_engine_id
        if self.connect_status is not None:
            result['ConnectStatus'] = self.connect_status
        if self.content is not None:
            result['Content'] = self.content
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.default_engine is not None:
            result['DefaultEngine'] = self.default_engine
        if self.description is not None:
            result['Description'] = self.description
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.gmt_create is not None:
            result['GmtCreate'] = self.gmt_create
        if self.gmt_modified is not None:
            result['GmtModified'] = self.gmt_modified
        if self.id is not None:
            result['Id'] = self.id
        if self.name is not None:
            result['Name'] = self.name
        if self.operator is not None:
            result['Operator'] = self.operator
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.sequence is not None:
            result['Sequence'] = self.sequence
        if self.shared is not None:
            result['Shared'] = self.shared
        if self.status is not None:
            result['Status'] = self.status
        if self.sub_type is not None:
            result['SubType'] = self.sub_type
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BindingCalcEngineId') is not None:
            self.binding_calc_engine_id = m.get('BindingCalcEngineId')
        if m.get('ConnectStatus') is not None:
            self.connect_status = m.get('ConnectStatus')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('DefaultEngine') is not None:
            self.default_engine = m.get('DefaultEngine')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('GmtCreate') is not None:
            self.gmt_create = m.get('GmtCreate')
        if m.get('GmtModified') is not None:
            self.gmt_modified = m.get('GmtModified')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Operator') is not None:
            self.operator = m.get('Operator')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Sequence') is not None:
            self.sequence = m.get('Sequence')
        if m.get('Shared') is not None:
            self.shared = m.get('Shared')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('SubType') is not None:
            self.sub_type = m.get('SubType')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListDataSourcesResponseBodyData(TeaModel):
    def __init__(self, data_sources=None, page_number=None, page_size=None, total_count=None):
        # The ID of the workspace to which the data source belongs.
        self.data_sources = data_sources  # type: list[ListDataSourcesResponseBodyDataDataSources]
        # The total number of data sources.
        self.page_number = page_number  # type: int
        # The data sources.
        self.page_size = page_size  # type: int
        # The status of the data source. Valid values:
        # 
        # *   1: The data source is accessible.
        # *   2: The data source is inaccessible.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.data_sources:
            for k in self.data_sources:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDataSourcesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DataSources'] = []
        if self.data_sources is not None:
            for k in self.data_sources:
                result['DataSources'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data_sources = []
        if m.get('DataSources') is not None:
            for k in m.get('DataSources'):
                temp_model = ListDataSourcesResponseBodyDataDataSources()
                self.data_sources.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListDataSourcesResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.data = data  # type: ListDataSourcesResponseBodyData
        # Indicates whether the request was successful.
        self.http_status_code = http_status_code  # type: int
        # The query result.
        self.request_id = request_id  # type: str
        # The page number of the returned page.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListDataSourcesResponseBody, self).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.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListDataSourcesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListDataSourcesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDataSourcesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDataSourcesResponse, self).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=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 = ListDataSourcesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDeploymentsRequest(TeaModel):
    def __init__(self, creator=None, end_create_time=None, end_execute_time=None, executor=None, keyword=None,
                 page_number=None, page_size=None, project_id=None, project_identifier=None, status=None):
        # The ID of the Alibaba Cloud account used by the user who created the deployment tasks.
        self.creator = creator  # type: str
        # The time when the deployment tasks to be queried were created. This value must be a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.end_create_time = end_create_time  # type: long
        # The time when the deployment tasks were run. This value must be a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.end_execute_time = end_execute_time  # type: long
        # The ID of the Alibaba Cloud account used by the user who runs the deployment tasks.
        self.executor = executor  # type: str
        # The keyword that is contained in the names of the deployment tasks. The keyword is used to search for deployment tasks in fuzzy mode.
        self.keyword = keyword  # type: str
        # The number of the page to return.
        self.page_number = page_number  # type: int
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace ID.
        # 
        # You must configure this parameter or the ProjectIdentifier parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace name.
        # 
        # You must configure this parameter or the ProjectId parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str
        # The status of the deployment tasks. Valid values:
        # 
        # *   0: The deployment tasks are ready.
        # *   1: The deployment tasks are successful.
        # *   2: The deployment tasks fail.
        # *   6: The deployment tasks are rejected.
        self.status = status  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDeploymentsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.creator is not None:
            result['Creator'] = self.creator
        if self.end_create_time is not None:
            result['EndCreateTime'] = self.end_create_time
        if self.end_execute_time is not None:
            result['EndExecuteTime'] = self.end_execute_time
        if self.executor is not None:
            result['Executor'] = self.executor
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Creator') is not None:
            self.creator = m.get('Creator')
        if m.get('EndCreateTime') is not None:
            self.end_create_time = m.get('EndCreateTime')
        if m.get('EndExecuteTime') is not None:
            self.end_execute_time = m.get('EndExecuteTime')
        if m.get('Executor') is not None:
            self.executor = m.get('Executor')
        if m.get('Keyword') is not None:
            self.keyword = m.get('Keyword')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class ListDeploymentsResponseBodyDataDeployments(TeaModel):
    def __init__(self, create_time=None, creator=None, error_message=None, execute_time=None, executor=None, id=None,
                 name=None, status=None):
        # The time when the deployment task was created.
        self.create_time = create_time  # type: long
        # The ID of the Alibaba Cloud account used by the user who created the deployment tasks.
        self.creator = creator  # type: str
        # The error message returned when the deployment task failed.
        self.error_message = error_message  # type: str
        # The time when the deployment task was run. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.execute_time = execute_time  # type: long
        # The ID of the Alibaba Cloud account used by the user who ran the deployment tasks.
        self.executor = executor  # type: str
        # The ID of the deployment task. You can call the [GetDeployment](~~173950~~) operation to query the details of the deployment task based on the ID.
        self.id = id  # type: long
        # The name of the deployment task.
        self.name = name  # type: str
        # The status of the deployment tasks. Valid values:
        # 
        # *   0: The deployment tasks are ready.
        # *   1: The deployment tasks are successful.
        # *   2: The deployment tasks fail.
        # *   6: The deployment tasks are rejected.
        self.status = status  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDeploymentsResponseBodyDataDeployments, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.creator is not None:
            result['Creator'] = self.creator
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.execute_time is not None:
            result['ExecuteTime'] = self.execute_time
        if self.executor is not None:
            result['Executor'] = self.executor
        if self.id is not None:
            result['Id'] = self.id
        if self.name is not None:
            result['Name'] = self.name
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('Creator') is not None:
            self.creator = m.get('Creator')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('ExecuteTime') is not None:
            self.execute_time = m.get('ExecuteTime')
        if m.get('Executor') is not None:
            self.executor = m.get('Executor')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class ListDeploymentsResponseBodyData(TeaModel):
    def __init__(self, deployments=None, page_number=None, page_size=None, total_count=None):
        # The information about the deployment tasks.
        self.deployments = deployments  # type: list[ListDeploymentsResponseBodyDataDeployments]
        # The page number of the returned page.
        self.page_number = page_number  # type: long
        # The number of entries returned per page.
        self.page_size = page_size  # type: long
        # The total number of entries returned.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.deployments:
            for k in self.deployments:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListDeploymentsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Deployments'] = []
        if self.deployments is not None:
            for k in self.deployments:
                result['Deployments'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.deployments = []
        if m.get('Deployments') is not None:
            for k in m.get('Deployments'):
                temp_model = ListDeploymentsResponseBodyDataDeployments()
                self.deployments.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListDeploymentsResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None):
        # The return results.
        self.data = data  # type: ListDeploymentsResponseBodyData
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListDeploymentsResponseBody, self).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=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListDeploymentsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListDeploymentsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListDeploymentsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListDeploymentsResponse, self).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=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 = ListDeploymentsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListEnabledExtensionsForProjectRequest(TeaModel):
    def __init__(self, event_code=None, file_type=None, project_id=None):
        # The ID of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console?spm=a2c4g.11186623.0.0.6b4d4941azHd2k) and go to the Workspace Management page to obtain the workspace ID.
        self.event_code = event_code  # type: str
        # The ID of the request.
        self.file_type = file_type  # type: str
        # The type of the code for the file.
        # 
        # Valid values: 6 (Shell), 10 (ODPS SQL), 11 (ODPS MR), 24 (ODPS Script), 99 (zero load), 221 (PyODPS 2), 225 (ODPS Spark), 227 (EMR Hive), 228 (EMR Spark), 229 (EMR Spark SQL), 230 (EMR MR), 239 (OSS object inspection), 257 (EMR Shell), 258 (EMR Spark Shell), 259 (EMR Presto), 260 (EMR Impala), 900 (real-time synchronization), 1089 (cross-tenant collaboration), 1091 (Hologres development), 1093 (Hologres SQL), 1100 (assignment), and 1221 (PyODPS 3).
        # 
        # You can call the [ListFileType](~~212428~~) operation to query the type of the code for the file.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListEnabledExtensionsForProjectRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.event_code is not None:
            result['EventCode'] = self.event_code
        if self.file_type is not None:
            result['FileType'] = self.file_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EventCode') is not None:
            self.event_code = m.get('EventCode')
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListEnabledExtensionsForProjectResponseBodyExtensions(TeaModel):
    def __init__(self, create_user=None, extension_code=None, extension_desc=None, extension_name=None,
                 gmt_create=None, gmt_modified=None, modify_user=None, owner=None, parameter_setting=None, tenant_id=None):
        # The modifier of the extension.
        self.create_user = create_user  # type: str
        # The name of the extension.
        self.extension_code = extension_code  # type: str
        # The owner ID.
        self.extension_desc = extension_desc  # type: str
        # The ID of the tenant.
        self.extension_name = extension_name  # type: str
        # The timestamp when extension was modified.
        self.gmt_create = gmt_create  # type: long
        self.gmt_modified = gmt_modified  # type: long
        # The description of the extension.
        self.modify_user = modify_user  # type: str
        # The parameter settings of the extension. For more information, see [Configure extension parameters](~~405354~~).
        self.owner = owner  # type: str
        # The time when the extension was created.
        self.parameter_setting = parameter_setting  # type: str
        # The creator of the extension.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListEnabledExtensionsForProjectResponseBodyExtensions, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.create_user is not None:
            result['CreateUser'] = self.create_user
        if self.extension_code is not None:
            result['ExtensionCode'] = self.extension_code
        if self.extension_desc is not None:
            result['ExtensionDesc'] = self.extension_desc
        if self.extension_name is not None:
            result['ExtensionName'] = self.extension_name
        if self.gmt_create is not None:
            result['GmtCreate'] = self.gmt_create
        if self.gmt_modified is not None:
            result['GmtModified'] = self.gmt_modified
        if self.modify_user is not None:
            result['ModifyUser'] = self.modify_user
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.parameter_setting is not None:
            result['ParameterSetting'] = self.parameter_setting
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreateUser') is not None:
            self.create_user = m.get('CreateUser')
        if m.get('ExtensionCode') is not None:
            self.extension_code = m.get('ExtensionCode')
        if m.get('ExtensionDesc') is not None:
            self.extension_desc = m.get('ExtensionDesc')
        if m.get('ExtensionName') is not None:
            self.extension_name = m.get('ExtensionName')
        if m.get('GmtCreate') is not None:
            self.gmt_create = m.get('GmtCreate')
        if m.get('GmtModified') is not None:
            self.gmt_modified = m.get('GmtModified')
        if m.get('ModifyUser') is not None:
            self.modify_user = m.get('ModifyUser')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ParameterSetting') is not None:
            self.parameter_setting = m.get('ParameterSetting')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class ListEnabledExtensionsForProjectResponseBody(TeaModel):
    def __init__(self, extensions=None, request_id=None):
        # The unique code of the extension.
        self.extensions = extensions  # type: list[ListEnabledExtensionsForProjectResponseBodyExtensions]
        # The details of the extension.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.extensions:
            for k in self.extensions:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListEnabledExtensionsForProjectResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Extensions'] = []
        if self.extensions is not None:
            for k in self.extensions:
                result['Extensions'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.extensions = []
        if m.get('Extensions') is not None:
            for k in m.get('Extensions'):
                temp_model = ListEnabledExtensionsForProjectResponseBodyExtensions()
                self.extensions.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListEnabledExtensionsForProjectResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListEnabledExtensionsForProjectResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListEnabledExtensionsForProjectResponse, self).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=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 = ListEnabledExtensionsForProjectResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListEntitiesByTagsRequest(TeaModel):
    def __init__(self, entity_type=None, next_token=None, page_size=None, tags=None):
        self.entity_type = entity_type  # type: str
        self.next_token = next_token  # type: str
        self.page_size = page_size  # type: int
        self.tags = tags  # type: list[UserEntityTag]

    def validate(self):
        if self.tags:
            for k in self.tags:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListEntitiesByTagsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.entity_type is not None:
            result['EntityType'] = self.entity_type
        if self.next_token is not None:
            result['NextToken'] = self.next_token
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        result['Tags'] = []
        if self.tags is not None:
            for k in self.tags:
                result['Tags'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EntityType') is not None:
            self.entity_type = m.get('EntityType')
        if m.get('NextToken') is not None:
            self.next_token = m.get('NextToken')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        self.tags = []
        if m.get('Tags') is not None:
            for k in m.get('Tags'):
                temp_model = UserEntityTag()
                self.tags.append(temp_model.from_map(k))
        return self


class ListEntitiesByTagsShrinkRequest(TeaModel):
    def __init__(self, entity_type=None, next_token=None, page_size=None, tags_shrink=None):
        self.entity_type = entity_type  # type: str
        self.next_token = next_token  # type: str
        self.page_size = page_size  # type: int
        self.tags_shrink = tags_shrink  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListEntitiesByTagsShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.entity_type is not None:
            result['EntityType'] = self.entity_type
        if self.next_token is not None:
            result['NextToken'] = self.next_token
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.tags_shrink is not None:
            result['Tags'] = self.tags_shrink
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EntityType') is not None:
            self.entity_type = m.get('EntityType')
        if m.get('NextToken') is not None:
            self.next_token = m.get('NextToken')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('Tags') is not None:
            self.tags_shrink = m.get('Tags')
        return self


class ListEntitiesByTagsResponseBodyData(TeaModel):
    def __init__(self, entity_list=None, next_token=None):
        self.entity_list = entity_list  # type: list[Entity]
        self.next_token = next_token  # type: str

    def validate(self):
        if self.entity_list:
            for k in self.entity_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListEntitiesByTagsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['EntityList'] = []
        if self.entity_list is not None:
            for k in self.entity_list:
                result['EntityList'].append(k.to_map() if k else None)
        if self.next_token is not None:
            result['NextToken'] = self.next_token
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.entity_list = []
        if m.get('EntityList') is not None:
            for k in m.get('EntityList'):
                temp_model = Entity()
                self.entity_list.append(temp_model.from_map(k))
        if m.get('NextToken') is not None:
            self.next_token = m.get('NextToken')
        return self


class ListEntitiesByTagsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: ListEntitiesByTagsResponseBodyData
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListEntitiesByTagsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListEntitiesByTagsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListEntitiesByTagsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListEntitiesByTagsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListEntitiesByTagsResponse, self).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=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 = ListEntitiesByTagsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListEntityTagsRequest(TeaModel):
    def __init__(self, qualified_name=None):
        self.qualified_name = qualified_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListEntityTagsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        return self


class ListEntityTagsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: list[UserEntityTag]
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListEntityTagsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = UserEntityTag()
                self.data.append(temp_model.from_map(k))
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListEntityTagsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListEntityTagsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListEntityTagsResponse, self).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=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 = ListEntityTagsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListExtensionsRequest(TeaModel):
    def __init__(self, page_number=None, page_size=None):
        # The number of entries to return on each page.
        self.page_number = page_number  # type: int
        # Id of the request
        self.page_size = page_size  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListExtensionsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        return self


class ListExtensionsResponseBodyPagingInfoExtensionsBindEventList(TeaModel):
    def __init__(self, event_code=None, event_name=None):
        self.event_code = event_code  # type: str
        # The code of the event.
        self.event_name = event_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListExtensionsResponseBodyPagingInfoExtensionsBindEventList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.event_code is not None:
            result['EventCode'] = self.event_code
        if self.event_name is not None:
            result['EventName'] = self.event_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EventCode') is not None:
            self.event_code = m.get('EventCode')
        if m.get('EventName') is not None:
            self.event_name = m.get('EventName')
        return self


class ListExtensionsResponseBodyPagingInfoExtensions(TeaModel):
    def __init__(self, bind_event_list=None, extension_code=None, extension_desc=None, extension_name=None,
                 owner=None, status=None):
        # The name of the event.
        self.bind_event_list = bind_event_list  # type: list[ListExtensionsResponseBodyPagingInfoExtensionsBindEventList]
        # The extension point events.
        self.extension_code = extension_code  # type: str
        # The name of the extension.
        self.extension_desc = extension_desc  # type: str
        # The ID of the RAM user.
        self.extension_name = extension_name  # type: str
        # The unique code of the extension.
        self.owner = owner  # type: str
        # The description of the extension.
        self.status = status  # type: int

    def validate(self):
        if self.bind_event_list:
            for k in self.bind_event_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListExtensionsResponseBodyPagingInfoExtensions, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['BindEventList'] = []
        if self.bind_event_list is not None:
            for k in self.bind_event_list:
                result['BindEventList'].append(k.to_map() if k else None)
        if self.extension_code is not None:
            result['ExtensionCode'] = self.extension_code
        if self.extension_desc is not None:
            result['ExtensionDesc'] = self.extension_desc
        if self.extension_name is not None:
            result['ExtensionName'] = self.extension_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.bind_event_list = []
        if m.get('BindEventList') is not None:
            for k in m.get('BindEventList'):
                temp_model = ListExtensionsResponseBodyPagingInfoExtensionsBindEventList()
                self.bind_event_list.append(temp_model.from_map(k))
        if m.get('ExtensionCode') is not None:
            self.extension_code = m.get('ExtensionCode')
        if m.get('ExtensionDesc') is not None:
            self.extension_desc = m.get('ExtensionDesc')
        if m.get('ExtensionName') is not None:
            self.extension_name = m.get('ExtensionName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class ListExtensionsResponseBodyPagingInfo(TeaModel):
    def __init__(self, extensions=None, page_number=None, page_size=None, total_count=None):
        # The state of the extension. Valid values:
        # 
        # 0: Testing
        # 
        # 1: Publishing
        # 
        # 3: Disabled
        # 
        # 4: Processing
        # 
        # 5: Approved
        # 
        # 6: Approve Failed
        self.extensions = extensions  # type: list[ListExtensionsResponseBodyPagingInfoExtensions]
        # The number of entries returned per page.
        self.page_number = page_number  # type: int
        # The total number of entries returned.
        self.page_size = page_size  # type: int
        # The extensions.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.extensions:
            for k in self.extensions:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListExtensionsResponseBodyPagingInfo, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Extensions'] = []
        if self.extensions is not None:
            for k in self.extensions:
                result['Extensions'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.extensions = []
        if m.get('Extensions') is not None:
            for k in m.get('Extensions'):
                temp_model = ListExtensionsResponseBodyPagingInfoExtensions()
                self.extensions.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListExtensionsResponseBody(TeaModel):
    def __init__(self, paging_info=None, request_id=None):
        # The page number of the returned page.
        self.paging_info = paging_info  # type: ListExtensionsResponseBodyPagingInfo
        # The extensions returned on pages.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.paging_info:
            self.paging_info.validate()

    def to_map(self):
        _map = super(ListExtensionsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.paging_info is not None:
            result['PagingInfo'] = self.paging_info.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PagingInfo') is not None:
            temp_model = ListExtensionsResponseBodyPagingInfo()
            self.paging_info = temp_model.from_map(m['PagingInfo'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListExtensionsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListExtensionsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListExtensionsResponse, self).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=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 = ListExtensionsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListFileTypeRequest(TeaModel):
    def __init__(self, keyword=None, locale=None, page_number=None, page_size=None, project_id=None,
                 project_identifier=None):
        # The name of the node type. You can log on to the DataWorks console, go to the DataStudio page, and then view the name of a specific node type on the left side of the page. Take note of the following items when you use this parameter:
        # 
        # *   You can view the English or Chinese name of a specific node type, but the language specified by this parameter to present the name must be the same as the language specified by the Locale parameter.
        # *   Fuzzy match is supported.
        # *   If this parameter is not specified, the names of all node types are returned.
        self.keyword = keyword  # type: str
        # The language that you use for the query. Valid values: zh-CN and en-US.
        self.locale = locale  # type: str
        # The number of the page to return.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace ID. You must configure either this parameter or the ProjectIdentifier parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace name.
        # 
        # You must configure either the ProjectId or ProjectIdentifier parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListFileTypeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        if self.locale is not None:
            result['Locale'] = self.locale
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Keyword') is not None:
            self.keyword = m.get('Keyword')
        if m.get('Locale') is not None:
            self.locale = m.get('Locale')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class ListFileTypeResponseBodyNodeTypeInfoListNodeTypeInfo(TeaModel):
    def __init__(self, node_type=None, node_type_name=None):
        # The code of the node type.
        # 
        # The codes and names of node types have the following mappings:
        # 
        # 6 (Shell), 10 (ODPS SQL), 11 (ODPS MR), 23 (Data Integration), 24 (ODPS Script), 99 (zero load), 221 (PyODPS 2), 225 (ODPS Spark), 227 (EMR Hive), 228 (EMR Spark), 229 (EMR Spark SQL), 230 (EMR MR), 239 (OSS object inspection), 257 (EMR Shell), 258 (EMR Spark Shell), 259 (EMR Presto), 260 (EMR Impala), 900 (real-time synchronization), 1089 (cross-tenant collaboration), 1091 (Hologres development), 1093 (Hologres SQL), 1100 (assignment), and 1221 (PyODPS 3)
        self.node_type = node_type  # type: int
        # The name of the node type.
        # 
        # The codes and names of node types have the following mappings:
        # 
        # 6 (Shell), 10 (ODPS SQL), 11 (ODPS MR), 23 (Data Integration), 24 (ODPS Script), 99 (zero load), 221 (PyODPS 2), 225 (ODPS Spark), 227 (EMR Hive), 228 (EMR Spark), 229 (EMR Spark SQL), 230 (EMR MR), 239 (OSS object inspection), 257 (EMR Shell), 258 (EMR Spark Shell), 259 (EMR Presto), 260 (EMR Impala), 900 (real-time synchronization), 1089 (cross-tenant collaboration), 1091 (Hologres development), 1093 (Hologres SQL), 1100 (assignment), and 1221 (PyODPS 3)
        self.node_type_name = node_type_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListFileTypeResponseBodyNodeTypeInfoListNodeTypeInfo, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_type is not None:
            result['NodeType'] = self.node_type
        if self.node_type_name is not None:
            result['NodeTypeName'] = self.node_type_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeType') is not None:
            self.node_type = m.get('NodeType')
        if m.get('NodeTypeName') is not None:
            self.node_type_name = m.get('NodeTypeName')
        return self


class ListFileTypeResponseBodyNodeTypeInfoList(TeaModel):
    def __init__(self, node_type_info=None, page_number=None, page_size=None, total_count=None):
        # The information of the node type.
        self.node_type_info = node_type_info  # type: list[ListFileTypeResponseBodyNodeTypeInfoListNodeTypeInfo]
        # The page number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries returned per page.
        self.page_size = page_size  # type: int
        # The total number of entries returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.node_type_info:
            for k in self.node_type_info:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListFileTypeResponseBodyNodeTypeInfoList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['NodeTypeInfo'] = []
        if self.node_type_info is not None:
            for k in self.node_type_info:
                result['NodeTypeInfo'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.node_type_info = []
        if m.get('NodeTypeInfo') is not None:
            for k in m.get('NodeTypeInfo'):
                temp_model = ListFileTypeResponseBodyNodeTypeInfoListNodeTypeInfo()
                self.node_type_info.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListFileTypeResponseBody(TeaModel):
    def __init__(self, node_type_info_list=None, request_id=None):
        # The information of the node types.
        self.node_type_info_list = node_type_info_list  # type: ListFileTypeResponseBodyNodeTypeInfoList
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.node_type_info_list:
            self.node_type_info_list.validate()

    def to_map(self):
        _map = super(ListFileTypeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_type_info_list is not None:
            result['NodeTypeInfoList'] = self.node_type_info_list.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeTypeInfoList') is not None:
            temp_model = ListFileTypeResponseBodyNodeTypeInfoList()
            self.node_type_info_list = temp_model.from_map(m['NodeTypeInfoList'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListFileTypeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListFileTypeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListFileTypeResponse, self).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=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 = ListFileTypeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListFileVersionsRequest(TeaModel):
    def __init__(self, file_id=None, page_number=None, page_size=None, project_id=None, project_identifier=None):
        # The ID of the file. You can call the [ListFiles](~~173942~~) operation to query the ID.
        self.file_id = file_id  # type: long
        # The number of the page to return.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value:10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the DataWorks workspace. You can click the Workspace Manage icon in the upper-right corner of the DataStudio page to go to the Workspace Management page and view the workspace ID.
        self.project_id = project_id  # type: long
        # The unique identifier of the DataWorks workspace. You can click the identifier in the upper-left corner of the DataStudio page to switch to another workspace.
        # 
        # You must specify either this parameter or ProjectId to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListFileVersionsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class ListFileVersionsResponseBodyDataFileVersions(TeaModel):
    def __init__(self, change_type=None, comment=None, commit_time=None, commit_user=None, file_content=None,
                 file_name=None, file_property_content=None, file_version=None, is_current_prod=None, node_content=None,
                 node_id=None, status=None, use_type=None):
        # The type of the change to the file of the current version. Valid values: CREATE, UPDATE, and DELETE.
        self.change_type = change_type  # type: str
        # The description of the file version.
        self.comment = comment  # type: str
        # The time when the file version was created. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.commit_time = commit_time  # type: long
        # The ID of the Alibaba Cloud account used to create the file of the current version.
        self.commit_user = commit_user  # type: str
        # The code in the file of the current version.
        self.file_content = file_content  # type: str
        # The name of the file of the current version.
        self.file_name = file_name  # type: str
        # The basic information about the file of the current version.
        self.file_property_content = file_property_content  # type: str
        # The version of the file.
        self.file_version = file_version  # type: int
        # Indicates whether the file version is the same as the latest file version in the production environment.
        self.is_current_prod = is_current_prod  # type: bool
        # The scheduling configurations for the node that corresponds to the file of the current version.
        self.node_content = node_content  # type: str
        # The ID of the auto triggered node that corresponds to the file of the current version.
        self.node_id = node_id  # type: long
        # The status of the file of the current version. Valid values: COMMITTING, COMMITTED, CHECK_OK, PACKAGED, DEPLOYING, DEPLOYED, and CANCELLED.
        self.status = status  # type: str
        # The functional module to which the file belongs. Valid values: NORMAL, MANUAL, MANUAL_BIZ, SKIP, ADHOCQUERY, and COMPONENT. The value SKIP indicates that the node corresponding to the file is run in dry-run mode.
        self.use_type = use_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListFileVersionsResponseBodyDataFileVersions, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.change_type is not None:
            result['ChangeType'] = self.change_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.commit_time is not None:
            result['CommitTime'] = self.commit_time
        if self.commit_user is not None:
            result['CommitUser'] = self.commit_user
        if self.file_content is not None:
            result['FileContent'] = self.file_content
        if self.file_name is not None:
            result['FileName'] = self.file_name
        if self.file_property_content is not None:
            result['FilePropertyContent'] = self.file_property_content
        if self.file_version is not None:
            result['FileVersion'] = self.file_version
        if self.is_current_prod is not None:
            result['IsCurrentProd'] = self.is_current_prod
        if self.node_content is not None:
            result['NodeContent'] = self.node_content
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.status is not None:
            result['Status'] = self.status
        if self.use_type is not None:
            result['UseType'] = self.use_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ChangeType') is not None:
            self.change_type = m.get('ChangeType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CommitTime') is not None:
            self.commit_time = m.get('CommitTime')
        if m.get('CommitUser') is not None:
            self.commit_user = m.get('CommitUser')
        if m.get('FileContent') is not None:
            self.file_content = m.get('FileContent')
        if m.get('FileName') is not None:
            self.file_name = m.get('FileName')
        if m.get('FilePropertyContent') is not None:
            self.file_property_content = m.get('FilePropertyContent')
        if m.get('FileVersion') is not None:
            self.file_version = m.get('FileVersion')
        if m.get('IsCurrentProd') is not None:
            self.is_current_prod = m.get('IsCurrentProd')
        if m.get('NodeContent') is not None:
            self.node_content = m.get('NodeContent')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('UseType') is not None:
            self.use_type = m.get('UseType')
        return self


class ListFileVersionsResponseBodyData(TeaModel):
    def __init__(self, file_versions=None, page_number=None, page_size=None, total_count=None):
        # The details of the file version.
        self.file_versions = file_versions  # type: list[ListFileVersionsResponseBodyDataFileVersions]
        # The page number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries returned per page.
        self.page_size = page_size  # type: int
        # The total number of entries returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.file_versions:
            for k in self.file_versions:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListFileVersionsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['FileVersions'] = []
        if self.file_versions is not None:
            for k in self.file_versions:
                result['FileVersions'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.file_versions = []
        if m.get('FileVersions') is not None:
            for k in m.get('FileVersions'):
                temp_model = ListFileVersionsResponseBodyDataFileVersions()
                self.file_versions.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListFileVersionsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The file versions returned.
        self.data = data  # type: ListFileVersionsResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListFileVersionsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListFileVersionsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListFileVersionsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListFileVersionsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListFileVersionsResponse, self).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=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 = ListFileVersionsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListFilesRequest(TeaModel):
    def __init__(self, exact_file_name=None, file_folder_path=None, file_id_in=None, file_types=None, keyword=None,
                 need_absolute_folder_path=None, need_content=None, node_id=None, owner=None, page_number=None, page_size=None,
                 project_id=None, project_identifier=None, use_type=None):
        self.exact_file_name = exact_file_name  # type: str
        # The path of the files.
        self.file_folder_path = file_folder_path  # type: str
        self.file_id_in = file_id_in  # type: str
        # The types of the code in the files.
        # 
        # Valid values: 6 (Shell), 10 (ODPS SQL), 11 (ODPS MR), 23 (Data Integration), 24 (ODPS Script), 97 (PAI), 98 (node group), 99 (zero load), 221 (PyODPS 2), 225 (ODPS Spark), 227 (EMR Hive), 228 (EMR Spark), 229 (EMR Spark SQL), 230 (EMR MR), 239 (OSS object inspection), 257 (EMR Shell), 258 (EMR Spark Shell), 259 (EMR Presto), 260 (EMR Impala), 900 (real-time synchronization), 1002 (PAI inner node), 1089 (cross-tenant collaboration), 1091 (Hologres development), 1093 (Hologres SQL), 1100 (assignment), 1106 (for-each), and 1221 (PyODPS 3).
        self.file_types = file_types  # type: str
        # The keyword in the file names. The keyword is used to perform a fuzzy match. You can specify a keyword to query all files whose names contain the keyword.
        self.keyword = keyword  # type: str
        self.need_absolute_folder_path = need_absolute_folder_path  # type: bool
        self.need_content = need_content  # type: bool
        # The ID of the node that is scheduled. You can call the [ListNodes](~~173979~~) operation to query the ID of the node.
        self.node_id = node_id  # type: long
        # The owner of the files.
        self.owner = owner  # type: str
        # The number of the page to return.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace ID.
        # 
        # You must configure either the ProjectId or ProjectIdentifier parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace name.
        # 
        # You must configure either the ProjectId or ProjectIdentifier parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str
        # The module to which the files belong. Valid values:
        # 
        # *   NORMAL: The files are used for DataStudio.
        # *   MANUAL: The files are used for manually triggered nodes.
        # *   MANUAL_BIZ: The files are used for manually triggered workflows.
        # *   SKIP: The files are used for dry-run nodes in DataStudio.
        # *   ADHOCQUERY: The files are used for ad hoc queries.
        # *   COMPONENT: The files are used for snippets.
        self.use_type = use_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListFilesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.exact_file_name is not None:
            result['ExactFileName'] = self.exact_file_name
        if self.file_folder_path is not None:
            result['FileFolderPath'] = self.file_folder_path
        if self.file_id_in is not None:
            result['FileIdIn'] = self.file_id_in
        if self.file_types is not None:
            result['FileTypes'] = self.file_types
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        if self.need_absolute_folder_path is not None:
            result['NeedAbsoluteFolderPath'] = self.need_absolute_folder_path
        if self.need_content is not None:
            result['NeedContent'] = self.need_content
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.use_type is not None:
            result['UseType'] = self.use_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ExactFileName') is not None:
            self.exact_file_name = m.get('ExactFileName')
        if m.get('FileFolderPath') is not None:
            self.file_folder_path = m.get('FileFolderPath')
        if m.get('FileIdIn') is not None:
            self.file_id_in = m.get('FileIdIn')
        if m.get('FileTypes') is not None:
            self.file_types = m.get('FileTypes')
        if m.get('Keyword') is not None:
            self.keyword = m.get('Keyword')
        if m.get('NeedAbsoluteFolderPath') is not None:
            self.need_absolute_folder_path = m.get('NeedAbsoluteFolderPath')
        if m.get('NeedContent') is not None:
            self.need_content = m.get('NeedContent')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('UseType') is not None:
            self.use_type = m.get('UseType')
        return self


class ListFilesResponseBodyDataFiles(TeaModel):
    def __init__(self, absolute_folder_path=None, auto_parsing=None, biz_id=None, business_id=None,
                 commit_status=None, connection_name=None, content=None, create_time=None, create_user=None, current_version=None,
                 file_description=None, file_folder_id=None, file_id=None, file_name=None, file_type=None, is_max_compute=None,
                 last_edit_time=None, last_edit_user=None, node_id=None, owner=None, parent_id=None, use_type=None):
        self.absolute_folder_path = absolute_folder_path  # type: str
        # Specifies whether the automatic parsing feature is enabled for the file. Valid values:
        # 
        # *   true: The automatic parsing feature is enabled for the file.
        # *   false: The automatic parsing feature is not enabled for the file.
        # 
        # This parameter is equivalent to the Analyze Code parameter in the Dependencies section of the Properties panel in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.auto_parsing = auto_parsing  # type: bool
        # The ID of the workflow to which the file belongs. This parameter is deprecated and replaced by the BusinessId parameter.
        self.biz_id = biz_id  # type: long
        # The ID of the workflow to which the file belongs.
        self.business_id = business_id  # type: long
        # Indicates whether the latest code in the file is committed. Valid values: 0 and 1. The value 0 indicates that the latest code in the file is not committed. The value 1 indicates that the latest code in the file is committed.
        self.commit_status = commit_status  # type: int
        # The ID of the compute engine instance that is used to run the node that corresponds to the file.
        self.connection_name = connection_name  # type: str
        # This parameter is deprecated. You can call the [GetFile](~~173954#doc-api-dataworks-public-GetFile~~) operation to query the details of the file.
        self.content = content  # type: str
        # The time when the file was created. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.create_time = create_time  # type: long
        # The ID of the Alibaba Cloud account that is used to create the file.
        self.create_user = create_user  # type: str
        # The latest version number of the file.
        self.current_version = current_version  # type: int
        # The description of the file.
        self.file_description = file_description  # type: str
        # The ID of the folder to which the file belongs.
        self.file_folder_id = file_folder_id  # type: str
        # The ID of the file.
        self.file_id = file_id  # type: long
        # The name of the file.
        self.file_name = file_name  # type: str
        # The type of the code in the file. Valid values: 6 (Shell), 10 (ODPS SQL), 11 (ODPS MR), 23 (Data Integration), 24 (ODPS Script), 99 (zero load), 221 (PyODPS 2), 225 (ODPS Spark), 227 (EMR Hive), 228 (EMR Spark), 229 (EMR Spark SQL), 230 (EMR MR), 239 (OSS object inspection), 257 (EMR Shell), 258 (EMR Spark Shell), 259 (EMR Presto), 260 (EMR Impala), 900 (real-time synchronization), 1089 (cross-tenant collaboration), 1091 (Hologres development), 1093 (Hologres SQL), 1100 (assignment), and 1221 (PyODPS 3).
        self.file_type = file_type  # type: int
        # Indicates whether the file needs to be uploaded to MaxCompute if the file is a MaxCompute resource file.
        # 
        # This parameter is returned only if the file is a MaxCompute resource file.
        self.is_max_compute = is_max_compute  # type: bool
        # The time when the file was last modified. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.last_edit_time = last_edit_time  # type: long
        # The ID of the Alibaba Cloud account that is used to last modify the file.
        self.last_edit_user = last_edit_user  # type: str
        # The ID of the auto triggered node that is generated in the scheduling system after the file is committed.
        self.node_id = node_id  # type: long
        # The ID of the Alibaba Cloud account used by the file owner.
        self.owner = owner  # type: str
        # The ID of the node group file to which the current file belongs. This parameter is returned only if the current file is an inner file of the node group file.
        self.parent_id = parent_id  # type: long
        # The module to which the file belongs. Valid values:
        # 
        # *   NORMAL: The file is used for DataStudio.
        # *   MANUAL: The file is used for a manually triggered node.
        # *   MANUAL_BIZ: The file is used for a manually triggered workflow.
        # *   SKIP: The files is used for a dry-run node in DataStudio.
        # *   ADHOCQUERY: The file is used for an ad hoc query.
        # *   COMPONENT: The file is used for a snippet.
        self.use_type = use_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListFilesResponseBodyDataFiles, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.absolute_folder_path is not None:
            result['AbsoluteFolderPath'] = self.absolute_folder_path
        if self.auto_parsing is not None:
            result['AutoParsing'] = self.auto_parsing
        if self.biz_id is not None:
            result['BizId'] = self.biz_id
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.commit_status is not None:
            result['CommitStatus'] = self.commit_status
        if self.connection_name is not None:
            result['ConnectionName'] = self.connection_name
        if self.content is not None:
            result['Content'] = self.content
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.create_user is not None:
            result['CreateUser'] = self.create_user
        if self.current_version is not None:
            result['CurrentVersion'] = self.current_version
        if self.file_description is not None:
            result['FileDescription'] = self.file_description
        if self.file_folder_id is not None:
            result['FileFolderId'] = self.file_folder_id
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.file_name is not None:
            result['FileName'] = self.file_name
        if self.file_type is not None:
            result['FileType'] = self.file_type
        if self.is_max_compute is not None:
            result['IsMaxCompute'] = self.is_max_compute
        if self.last_edit_time is not None:
            result['LastEditTime'] = self.last_edit_time
        if self.last_edit_user is not None:
            result['LastEditUser'] = self.last_edit_user
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.parent_id is not None:
            result['ParentId'] = self.parent_id
        if self.use_type is not None:
            result['UseType'] = self.use_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AbsoluteFolderPath') is not None:
            self.absolute_folder_path = m.get('AbsoluteFolderPath')
        if m.get('AutoParsing') is not None:
            self.auto_parsing = m.get('AutoParsing')
        if m.get('BizId') is not None:
            self.biz_id = m.get('BizId')
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('CommitStatus') is not None:
            self.commit_status = m.get('CommitStatus')
        if m.get('ConnectionName') is not None:
            self.connection_name = m.get('ConnectionName')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('CreateUser') is not None:
            self.create_user = m.get('CreateUser')
        if m.get('CurrentVersion') is not None:
            self.current_version = m.get('CurrentVersion')
        if m.get('FileDescription') is not None:
            self.file_description = m.get('FileDescription')
        if m.get('FileFolderId') is not None:
            self.file_folder_id = m.get('FileFolderId')
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('FileName') is not None:
            self.file_name = m.get('FileName')
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        if m.get('IsMaxCompute') is not None:
            self.is_max_compute = m.get('IsMaxCompute')
        if m.get('LastEditTime') is not None:
            self.last_edit_time = m.get('LastEditTime')
        if m.get('LastEditUser') is not None:
            self.last_edit_user = m.get('LastEditUser')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ParentId') is not None:
            self.parent_id = m.get('ParentId')
        if m.get('UseType') is not None:
            self.use_type = m.get('UseType')
        return self


class ListFilesResponseBodyData(TeaModel):
    def __init__(self, files=None, page_number=None, page_size=None, total_count=None):
        # The details of the files.
        self.files = files  # type: list[ListFilesResponseBodyDataFiles]
        # The page number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries returned per page.
        self.page_size = page_size  # type: int
        # The total number of entries returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.files:
            for k in self.files:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListFilesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Files'] = []
        if self.files is not None:
            for k in self.files:
                result['Files'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.files = []
        if m.get('Files') is not None:
            for k in m.get('Files'):
                temp_model = ListFilesResponseBodyDataFiles()
                self.files.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListFilesResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The files returned.
        self.data = data  # type: ListFilesResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can troubleshoot errors based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListFilesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListFilesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListFilesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListFilesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListFilesResponse, self).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=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 = ListFilesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListFoldersRequest(TeaModel):
    def __init__(self, page_number=None, page_size=None, parent_folder_path=None, project_id=None,
                 project_identifier=None):
        # The number of the page to return.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The path of the parent folder.
        self.parent_folder_path = parent_folder_path  # type: str
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID. You must specify either this parameter or ProjectIdentifier to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Settings panel to obtain the name. You must specify either this parameter or ProjectId to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListFoldersRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.parent_folder_path is not None:
            result['ParentFolderPath'] = self.parent_folder_path
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ParentFolderPath') is not None:
            self.parent_folder_path = m.get('ParentFolderPath')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class ListFoldersResponseBodyDataFolders(TeaModel):
    def __init__(self, folder_id=None, folder_path=None):
        # The ID of the folder.
        self.folder_id = folder_id  # type: str
        # The path of the folder.
        self.folder_path = folder_path  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListFoldersResponseBodyDataFolders, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.folder_path is not None:
            result['FolderPath'] = self.folder_path
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('FolderPath') is not None:
            self.folder_path = m.get('FolderPath')
        return self


class ListFoldersResponseBodyData(TeaModel):
    def __init__(self, folders=None, page_number=None, page_size=None, total_count=None):
        # The details of the folder.
        self.folders = folders  # type: list[ListFoldersResponseBodyDataFolders]
        # The page number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries on the returned page.
        self.page_size = page_size  # type: int
        # The total number of entries returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.folders:
            for k in self.folders:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListFoldersResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Folders'] = []
        if self.folders is not None:
            for k in self.folders:
                result['Folders'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.folders = []
        if m.get('Folders') is not None:
            for k in m.get('Folders'):
                temp_model = ListFoldersResponseBodyDataFolders()
                self.folders.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListFoldersResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The folders returned.
        self.data = data  # type: ListFoldersResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListFoldersResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListFoldersResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListFoldersResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListFoldersResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListFoldersResponse, self).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=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 = ListFoldersResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListInnerNodesRequest(TeaModel):
    def __init__(self, node_name=None, outer_node_id=None, page_number=None, page_size=None, program_type=None,
                 project_env=None, project_id=None):
        # The ID of the node group to which the inner nodes belong.
        self.node_name = node_name  # type: str
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.outer_node_id = outer_node_id  # type: long
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_number = page_number  # type: int
        # The ID of the workspace.
        self.page_size = page_size  # type: int
        # The number of the page to return. Minimum value: 1. Maximum value: 100.
        self.program_type = program_type  # type: str
        # The name of the node to which the inner nodes belong.
        self.project_env = project_env  # type: str
        # The environment in which the node is run. Valid values: DEV and PROD. Default value: PROD.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListInnerNodesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.outer_node_id is not None:
            result['OuterNodeId'] = self.outer_node_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('OuterNodeId') is not None:
            self.outer_node_id = m.get('OuterNodeId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListInnerNodesResponseBodyPagingNodes(TeaModel):
    def __init__(self, baseline_id=None, business_id=None, connection=None, cron_express=None, description=None,
                 dqc_description=None, dqc_type=None, node_id=None, node_name=None, owner_id=None, param_values=None, priority=None,
                 program_type=None, project_id=None, repeat_interval=None, repeatability=None, res_group_name=None,
                 scheduler_type=None):
        # The description of the inner node.
        self.baseline_id = baseline_id  # type: long
        # The table and partition filter expression in Data Quality that are associated with the inner node.
        self.business_id = business_id  # type: long
        # The values of other parameters related to the inner node.
        self.connection = connection  # type: str
        # The ID of the inner node.
        self.cron_express = cron_express  # type: str
        # The name of the inner node.
        self.description = description  # type: str
        # The cron expression.
        self.dqc_description = dqc_description  # type: str
        # The ID of the baseline with which the inner node is associated.
        self.dqc_type = dqc_type  # type: str
        self.node_id = node_id  # type: long
        # The name of the resource group.
        self.node_name = node_name  # type: str
        # The connection string.
        self.owner_id = owner_id  # type: str
        # Indicates whether the node is associated with Data Quality. Valid values: 0 and 1. The value 0 indicates that the node is associated with Data Quality. The value 1 indicates that the node is not associated with Data Quality.
        self.param_values = param_values  # type: str
        # The ID of the owner of the inner node.
        self.priority = priority  # type: int
        # The priority of the inner node. Valid values: 1, 3, 5, 7, and 8.
        self.program_type = program_type  # type: str
        # The type of the inner node.
        self.project_id = project_id  # type: long
        # Indicates whether the inner node can be rerun.
        self.repeat_interval = repeat_interval  # type: long
        # The ID of the workspace.
        self.repeatability = repeatability  # type: bool
        # The ID of the workflow.
        self.res_group_name = res_group_name  # type: str
        # The interval at which the inner node is rerun after the inner node fails to be run.
        self.scheduler_type = scheduler_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListInnerNodesResponseBodyPagingNodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.connection is not None:
            result['Connection'] = self.connection
        if self.cron_express is not None:
            result['CronExpress'] = self.cron_express
        if self.description is not None:
            result['Description'] = self.description
        if self.dqc_description is not None:
            result['DqcDescription'] = self.dqc_description
        if self.dqc_type is not None:
            result['DqcType'] = self.dqc_type
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.param_values is not None:
            result['ParamValues'] = self.param_values
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.repeat_interval is not None:
            result['RepeatInterval'] = self.repeat_interval
        if self.repeatability is not None:
            result['Repeatability'] = self.repeatability
        if self.res_group_name is not None:
            result['ResGroupName'] = self.res_group_name
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('Connection') is not None:
            self.connection = m.get('Connection')
        if m.get('CronExpress') is not None:
            self.cron_express = m.get('CronExpress')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('DqcDescription') is not None:
            self.dqc_description = m.get('DqcDescription')
        if m.get('DqcType') is not None:
            self.dqc_type = m.get('DqcType')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('ParamValues') is not None:
            self.param_values = m.get('ParamValues')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RepeatInterval') is not None:
            self.repeat_interval = m.get('RepeatInterval')
        if m.get('Repeatability') is not None:
            self.repeatability = m.get('Repeatability')
        if m.get('ResGroupName') is not None:
            self.res_group_name = m.get('ResGroupName')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        return self


class ListInnerNodesResponseBodyPaging(TeaModel):
    def __init__(self, nodes=None, page_number=None, page_size=None, total_count=None):
        # The scheduling type of the inner node. Valid values:
        # 
        # *   NORMAL: The inner node is an auto triggered node.
        # *   MANUAL: The inner node is a manually triggered node. Manually triggered nodes cannot be automatically triggered.
        # *   PAUSE: The inner node is a paused node.
        # *   SKIP: The inner node is a dry-run node. Dry-run nodes are started as scheduled but the scheduling system sets the status of the nodes to succeeded when the scheduling system starts to run the nodes.
        self.nodes = nodes  # type: list[ListInnerNodesResponseBodyPagingNodes]
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_number = page_number  # type: int
        # The total number of inner nodes returned.
        self.page_size = page_size  # type: int
        # The list of inner nodes.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.nodes:
            for k in self.nodes:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListInnerNodesResponseBodyPaging, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Nodes'] = []
        if self.nodes is not None:
            for k in self.nodes:
                result['Nodes'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.nodes = []
        if m.get('Nodes') is not None:
            for k in m.get('Nodes'):
                temp_model = ListInnerNodesResponseBodyPagingNodes()
                self.nodes.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListInnerNodesResponseBody(TeaModel):
    def __init__(self, paging=None, request_id=None, success=None):
        # The page number of the returned page.
        self.paging = paging  # type: ListInnerNodesResponseBodyPaging
        # Indicates whether the request is successful.
        self.request_id = request_id  # type: str
        # The paging information.
        self.success = success  # type: bool

    def validate(self):
        if self.paging:
            self.paging.validate()

    def to_map(self):
        _map = super(ListInnerNodesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.paging is not None:
            result['Paging'] = self.paging.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Paging') is not None:
            temp_model = ListInnerNodesResponseBodyPaging()
            self.paging = temp_model.from_map(m['Paging'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListInnerNodesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListInnerNodesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListInnerNodesResponse, self).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=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 = ListInnerNodesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListInstanceAmountRequest(TeaModel):
    def __init__(self, begin_date=None, end_date=None, project_id=None):
        # The beginning of the time range to query, accurate to the day. Specify the time in the ISO 8601 standard in the yyyy-MM-ddTHH:mm:ssZ format. The time must be in UTC.
        self.begin_date = begin_date  # type: str
        # The end of the time range to query, accurate to the day. Specify the time in the ISO 8601 standard in the yyyy-MM-ddTHH:mm:ssZ format. The time must be in UTC.
        self.end_date = end_date  # type: str
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListInstanceAmountRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.begin_date is not None:
            result['BeginDate'] = self.begin_date
        if self.end_date is not None:
            result['EndDate'] = self.end_date
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BeginDate') is not None:
            self.begin_date = m.get('BeginDate')
        if m.get('EndDate') is not None:
            self.end_date = m.get('EndDate')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListInstanceAmountResponseBodyInstanceCounts(TeaModel):
    def __init__(self, count=None, date=None):
        # The number of auto triggered node instances.
        self.count = count  # type: int
        # The data timestamp at which the number of auto triggered node instances was obtained. This value is a UNIX timestamp.
        self.date = date  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListInstanceAmountResponseBodyInstanceCounts, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.date is not None:
            result['Date'] = self.date
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('Date') is not None:
            self.date = m.get('Date')
        return self


class ListInstanceAmountResponseBody(TeaModel):
    def __init__(self, instance_counts=None, request_id=None):
        # The trend of the number of auto triggered node instances within the specified period of time.
        self.instance_counts = instance_counts  # type: list[ListInstanceAmountResponseBodyInstanceCounts]
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.instance_counts:
            for k in self.instance_counts:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListInstanceAmountResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['InstanceCounts'] = []
        if self.instance_counts is not None:
            for k in self.instance_counts:
                result['InstanceCounts'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.instance_counts = []
        if m.get('InstanceCounts') is not None:
            for k in m.get('InstanceCounts'):
                temp_model = ListInstanceAmountResponseBodyInstanceCounts()
                self.instance_counts.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListInstanceAmountResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListInstanceAmountResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListInstanceAmountResponse, self).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=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 = ListInstanceAmountResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListInstanceHistoryRequest(TeaModel):
    def __init__(self, instance_id=None, project_env=None):
        # The environment of the workspace. Valid values: PROD (production environment) and DEV (development environment).By default, data of instances in the production environment is queried.
        self.instance_id = instance_id  # type: long
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListInstanceHistoryRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class ListInstanceHistoryResponseBodyInstances(TeaModel):
    def __init__(self, begin_running_time=None, begin_wait_res_time=None, begin_wait_time_time=None, bizdate=None,
                 create_time=None, cyc_time=None, dag_id=None, dag_type=None, error_message=None, finish_time=None,
                 instance_history_id=None, instance_id=None, modify_time=None, node_id=None, node_name=None, status=None, task_type=None):
        # The time when the running of the node was complete. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since the epoch time January 1, 1970, 00:00:00 UTC.
        self.begin_running_time = begin_running_time  # type: long
        # The data timestamp of the instance. In most cases, the value is one day before the time when the instance was run.
        self.begin_wait_res_time = begin_wait_res_time  # type: long
        # The ID of the node that generates the instance.
        self.begin_wait_time_time = begin_wait_time_time  # type: long
        # The name of the node.
        self.bizdate = bizdate  # type: long
        # The ID of the workflow.
        self.create_time = create_time  # type: long
        # The time when the instance started to be run. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since the epoch time January 1, 1970, 00:00:00 UTC.
        self.cyc_time = cyc_time  # type: long
        # The type of the node. Valid values:
        # 
        # *   NORMAL(0): The node is an auto triggered node. The scheduling system regularly runs the node.
        # *   MANUAL(1): The node is a manually triggered node. The scheduling system does not regularly run the node.
        # *   PAUSE(2): The node is a frozen node. The scheduling system regularly runs the node but sets the status of the node to failed when the scheduling system starts to run the node.
        # *   SKIP(3): The node is a dry-run node. The scheduling system regularly runs the node but sets the status of the node to succeeded when the scheduling system starts to run the node.
        # *   SKIP_UNCHOOSE(4): The node is an unselected node in a temporary workflow. This type of node exists only in temporary workflows. The scheduling system sets the status of the node to succeeded when the scheduling system starts to run the node.
        # *   SKIP_CYCLE(5): The node is a node that is scheduled by week or month and is waiting for the scheduling time to arrive. The scheduling system regularly runs the node but sets the status of the node to succeeded when the scheduling system starts to run the node.
        # *   CONDITION_UNCHOOSE(6): The node is not selected by its ancestor branch node and is run as a dry-run node.
        # *   REALTIME_DEPRECATED(7): The node has instances that are generated in real time but deprecated. The scheduling system sets the status of the node to succeeded.
        self.dag_id = dag_id  # type: long
        # The time when the node was last modified.
        self.dag_type = dag_type  # type: str
        # The time when the instance was generated.
        self.error_message = error_message  # type: str
        # The error message that is returned for the instance. This parameter is deprecated. You can call the GetInstanceLog operation to query the error information related to the node.
        self.finish_time = finish_time  # type: long
        self.instance_history_id = instance_history_id  # type: long
        # The time when the instance started to wait for resources.
        self.instance_id = instance_id  # type: long
        # The ID of the instance.
        self.modify_time = modify_time  # type: long
        # The historical record number of the instance.
        self.node_id = node_id  # type: long
        # The time when the instance started to wait to be scheduled.
        self.node_name = node_name  # type: str
        # The time when the node started to be run. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since the epoch time January 1, 1970, 00:00:00 UTC.
        self.status = status  # type: str
        # Indicates whether the instance is associated with a monitoring rule in Data Quality (DQC). Valid values:
        # 
        # *   0: The instance is associated with a monitoring rule in Data Quality.
        # *   1: The instance is not associated with a monitoring rule in Data Quality.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListInstanceHistoryResponseBodyInstances, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.begin_running_time is not None:
            result['BeginRunningTime'] = self.begin_running_time
        if self.begin_wait_res_time is not None:
            result['BeginWaitResTime'] = self.begin_wait_res_time
        if self.begin_wait_time_time is not None:
            result['BeginWaitTimeTime'] = self.begin_wait_time_time
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.cyc_time is not None:
            result['CycTime'] = self.cyc_time
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.dag_type is not None:
            result['DagType'] = self.dag_type
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.instance_history_id is not None:
            result['InstanceHistoryId'] = self.instance_history_id
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.modify_time is not None:
            result['ModifyTime'] = self.modify_time
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.status is not None:
            result['Status'] = self.status
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BeginRunningTime') is not None:
            self.begin_running_time = m.get('BeginRunningTime')
        if m.get('BeginWaitResTime') is not None:
            self.begin_wait_res_time = m.get('BeginWaitResTime')
        if m.get('BeginWaitTimeTime') is not None:
            self.begin_wait_time_time = m.get('BeginWaitTimeTime')
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('CycTime') is not None:
            self.cyc_time = m.get('CycTime')
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('DagType') is not None:
            self.dag_type = m.get('DagType')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('InstanceHistoryId') is not None:
            self.instance_history_id = m.get('InstanceHistoryId')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ModifyTime') is not None:
            self.modify_time = m.get('ModifyTime')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class ListInstanceHistoryResponseBody(TeaModel):
    def __init__(self, instances=None, request_id=None, success=None):
        # The status of the node that generates the instance. Valid values:
        # 
        # *   NOT_RUN: The node is not run.
        # *   WAIT_TIME: The node is waiting for the scheduling time to arrive.
        # *   WAIT_RESOURCE: The node is waiting for resources.
        # *   RUNNING: The node is running.
        # *   CHECKING: Data quality is being checked for the node.
        # *   CHECKING_CONDITION: Branch conditions are being checked for the node.
        # *   FAILURE: The node fails to be run.
        # *   SUCCESS: The node is successfully run.
        self.instances = instances  # type: list[ListInstanceHistoryResponseBodyInstances]
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.request_id = request_id  # type: str
        # The instance list.
        self.success = success  # type: bool

    def validate(self):
        if self.instances:
            for k in self.instances:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListInstanceHistoryResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Instances'] = []
        if self.instances is not None:
            for k in self.instances:
                result['Instances'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.instances = []
        if m.get('Instances') is not None:
            for k in m.get('Instances'):
                temp_model = ListInstanceHistoryResponseBodyInstances()
                self.instances.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListInstanceHistoryResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListInstanceHistoryResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListInstanceHistoryResponse, self).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=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 = ListInstanceHistoryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListInstancesRequest(TeaModel):
    def __init__(self, begin_bizdate=None, biz_name=None, bizdate=None, dag_id=None, end_bizdate=None, node_id=None,
                 node_name=None, owner=None, page_number=None, page_size=None, program_type=None, project_env=None,
                 project_id=None, status=None):
        # The parameters related to the node.
        self.begin_bizdate = begin_bizdate  # type: str
        # The ID of the instance.
        self.biz_name = biz_name  # type: str
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.bizdate = bizdate  # type: str
        # The environment of the workspace. Valid values: PROD and DEV. The value PROD indicates the production environment. The value DEV indicates the development environment.
        self.dag_id = dag_id  # type: long
        # The ID of the workflow.
        self.end_bizdate = end_bizdate  # type: str
        # Indicates whether the instance is associated with a monitoring rule in Data Quality. Valid values:
        # 
        # *   0: The instance is associated with a monitoring rule in Data Quality.
        # *   1: The instance is not associated with a monitoring rule in Data Quality.
        self.node_id = node_id  # type: long
        # Indicates whether the node can be rerun.
        self.node_name = node_name  # type: str
        # The connection string.
        self.owner = owner  # type: str
        # The operation that you want to perform.
        self.page_number = page_number  # type: int
        # The ID of the node.
        self.page_size = page_size  # type: int
        # The error code returned.
        self.program_type = program_type  # type: str
        # The time when the node was last modified.
        self.project_env = project_env  # type: str
        # The ID of the baseline.
        self.project_id = project_id  # type: long
        # The time when the instance started to wait to be scheduled.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListInstancesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.begin_bizdate is not None:
            result['BeginBizdate'] = self.begin_bizdate
        if self.biz_name is not None:
            result['BizName'] = self.biz_name
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.end_bizdate is not None:
            result['EndBizdate'] = self.end_bizdate
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BeginBizdate') is not None:
            self.begin_bizdate = m.get('BeginBizdate')
        if m.get('BizName') is not None:
            self.biz_name = m.get('BizName')
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('EndBizdate') is not None:
            self.end_bizdate = m.get('EndBizdate')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class ListInstancesResponseBodyDataInstances(TeaModel):
    def __init__(self, baseline_id=None, begin_running_time=None, begin_wait_res_time=None,
                 begin_wait_time_time=None, bizdate=None, business_id=None, connection=None, create_time=None, create_user=None,
                 cyc_time=None, dag_id=None, dag_type=None, dqc_description=None, dqc_type=None, error_message=None,
                 finish_time=None, instance_id=None, modify_time=None, node_id=None, node_name=None, param_values=None,
                 priority=None, related_flow_id=None, repeat_interval=None, repeatability=None, status=None,
                 task_rerun_time=None, task_type=None):
        # The type of the workflow. Valid values:
        # 
        # *   DAILY: The workflow is used to run auto triggered nodes.
        # *   MANUAL: The workflow is used to run manually triggered nodes.
        # *   SMOKE_TEST: The workflow is used to perform smoke testing.
        # *   SUPPLY_DATA: The workflow is used to backfill data.
        self.baseline_id = baseline_id  # type: long
        # The time when the instance started to run.
        self.begin_running_time = begin_running_time  # type: long
        # The time when the node stopped running.
        self.begin_wait_res_time = begin_wait_res_time  # type: long
        # The ID of the request. You can use the ID to locate logs and troubleshoot issues.
        self.begin_wait_time_time = begin_wait_time_time  # type: long
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        # 
        # You cannot specify the sorting method for the instances to be returned by this operation. By default, the instances are sorted in descending order of the time when the instances were created.
        self.bizdate = bizdate  # type: long
        # The ID of the workflow to which the node belongs.
        self.business_id = business_id  # type: long
        # The number of times the node can be rerun. The value of this parameter can be empty or an integer that is greater than or equal to 0.
        # 
        # *   If the value of this parameter is empty, the number of times that the node can be rerun is not specified.
        # *   If the value of this parameter is 0, the node cannot be rerun.
        # *   If the value of this parameter is a positive integer such as n, the node can be rerun n times. For example, if the value of this parameter is 1, the node can be rerun once. If the value of this parameter is 2, the node can be rerun twice.
        self.connection = connection  # type: str
        # The interval at which the node is rerun after the node fails to run. Unit: milliseconds.
        self.create_time = create_time  # type: long
        # The ID of the node. You can call the [ListNodes](~~173979~~) operation to query the ID of the node.
        self.create_user = create_user  # type: str
        # The error message returned.
        self.cyc_time = cyc_time  # type: long
        # The time when the instance started to wait for resources.
        self.dag_id = dag_id  # type: long
        # The data timestamp of the instance. In most cases, the value is one day before the time when the instance was run.
        self.dag_type = dag_type  # type: str
        # The operation that you want to perform.
        self.dqc_description = dqc_description  # type: str
        # The status of the node. Valid values:
        # 
        # *   NOT_RUN: The node is not run.
        # *   WAIT_TIME: The node is waiting for the scheduling time to arrive.
        # *   WAIT_RESOURCE: The node is waiting for resources.
        # *   RUNNING: The node is running.
        # *   CHECKING: Data quality is being checked for the node.
        # *   CHECKING_CONDITION: Branch conditions are being checked for the node.
        # *   FAILURE: The node fails to run.
        # *   SUCCESS: The node is successfully run.
        self.dqc_type = dqc_type  # type: int
        # The name of the account that is used to run the instance. For example, if an account named Test was used to run the instance to backfill data, the value of this parameter is Test.
        self.error_message = error_message  # type: str
        # The ID of the Alibaba Cloud account used by the workspace administrator. You can log on to the Alibaba Cloud Management Console and view the ID on the Security Settings page of the Account Center console.
        self.finish_time = finish_time  # type: long
        # The number of the page to return. Minimum value:1. Maximum value: 100.
        self.instance_id = instance_id  # type: long
        # The name of the workflow. You can call the [ListBusiness](~~173945~~) operation to query the name of the workflow.
        self.modify_time = modify_time  # type: long
        # The environment of the workspace. Valid values: PROD and DEV. The value PROD indicates the production environment. The value DEV indicates the development environment.
        self.node_id = node_id  # type: long
        # The ID of the workflow.
        self.node_name = node_name  # type: str
        # The table and partition filter expression in Data Quality that are associated with the node.
        self.param_values = param_values  # type: str
        # The total number of instances.
        self.priority = priority  # type: int
        # The type of the node. You can call the [ListNodes](~~173979~~) operation to query the type of the node.
        self.related_flow_id = related_flow_id  # type: long
        # The scheduling type of the node. Valid values:
        # 
        # *   NORMAL(0): The node is an auto triggered node. The scheduling system regularly runs the node.
        # 
        # *   MANUAL(1): The node is a manually triggered node. The scheduling system does not regularly run the node.
        # 
        # *   PAUSE(2): The node is a frozen node. The scheduling system regularly runs the node but sets the status of the node to failed when the scheduling system starts to run the node.
        # 
        # *   SKIP(3): The node is a dry-run node. The scheduling system regularly runs the node but sets the status of the node to succeeded when the scheduling system starts to run the node.
        # 
        # *   SKIP_UNCHOOSE(4): The node is an unselected node in a temporary workflow. This type of node exists only in temporary workflows. The scheduling system sets the status of the node to succeeded when the scheduling system starts to run the node.
        # 
        # *   SKIP_CYCLE(5): The node is a node that is scheduled by week or month and is waiting for the scheduling time to arrive. The scheduling system regularly runs the node but sets the status of the node to succeeded when the scheduling system starts to run the node.
        # 
        # *   CONDITION_UNCHOOSE(6): The node is not selected by its ancestor branch node and is run as a dry-run node.
        # 
        #     REALTIME_DEPRECATED(7): The node has instances that are generated in real time but deprecated. The scheduling system sets the status of the node to succeeded.
        self.repeat_interval = repeat_interval  # type: long
        # The status of the node. Valid values:
        # 
        # *   NOT_RUN: The node is not run.
        # *   WAIT_TIME: The node is waiting for the scheduling time to arrive.
        # *   WAIT_RESOURCE: The node is waiting for resources.
        # *   RUNNING: The node is running.
        # *   CHECKING: Data quality is being checked for the node.
        # *   CHECKING_CONDITION: Branch conditions are being checked for the node.
        # *   FAILURE: The node fails to run.
        # *   SUCCESS: The node is successfully run.
        self.repeatability = repeatability  # type: bool
        # The data timestamp of the instances that you want to query. Specify the timestamp in the yyyy-MM-dd HH:mm:ss format.
        self.status = status  # type: str
        # The ID of the workspace. You can call the [ListProjects](~~178393~~) operation to query the ID of the workspace.
        self.task_rerun_time = task_rerun_time  # type: int
        # The information about the instances.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListInstancesResponseBodyDataInstances, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.begin_running_time is not None:
            result['BeginRunningTime'] = self.begin_running_time
        if self.begin_wait_res_time is not None:
            result['BeginWaitResTime'] = self.begin_wait_res_time
        if self.begin_wait_time_time is not None:
            result['BeginWaitTimeTime'] = self.begin_wait_time_time
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.connection is not None:
            result['Connection'] = self.connection
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.create_user is not None:
            result['CreateUser'] = self.create_user
        if self.cyc_time is not None:
            result['CycTime'] = self.cyc_time
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.dag_type is not None:
            result['DagType'] = self.dag_type
        if self.dqc_description is not None:
            result['DqcDescription'] = self.dqc_description
        if self.dqc_type is not None:
            result['DqcType'] = self.dqc_type
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.modify_time is not None:
            result['ModifyTime'] = self.modify_time
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.param_values is not None:
            result['ParamValues'] = self.param_values
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.related_flow_id is not None:
            result['RelatedFlowId'] = self.related_flow_id
        if self.repeat_interval is not None:
            result['RepeatInterval'] = self.repeat_interval
        if self.repeatability is not None:
            result['Repeatability'] = self.repeatability
        if self.status is not None:
            result['Status'] = self.status
        if self.task_rerun_time is not None:
            result['TaskRerunTime'] = self.task_rerun_time
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BeginRunningTime') is not None:
            self.begin_running_time = m.get('BeginRunningTime')
        if m.get('BeginWaitResTime') is not None:
            self.begin_wait_res_time = m.get('BeginWaitResTime')
        if m.get('BeginWaitTimeTime') is not None:
            self.begin_wait_time_time = m.get('BeginWaitTimeTime')
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('Connection') is not None:
            self.connection = m.get('Connection')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('CreateUser') is not None:
            self.create_user = m.get('CreateUser')
        if m.get('CycTime') is not None:
            self.cyc_time = m.get('CycTime')
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('DagType') is not None:
            self.dag_type = m.get('DagType')
        if m.get('DqcDescription') is not None:
            self.dqc_description = m.get('DqcDescription')
        if m.get('DqcType') is not None:
            self.dqc_type = m.get('DqcType')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ModifyTime') is not None:
            self.modify_time = m.get('ModifyTime')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('ParamValues') is not None:
            self.param_values = m.get('ParamValues')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('RelatedFlowId') is not None:
            self.related_flow_id = m.get('RelatedFlowId')
        if m.get('RepeatInterval') is not None:
            self.repeat_interval = m.get('RepeatInterval')
        if m.get('Repeatability') is not None:
            self.repeatability = m.get('Repeatability')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskRerunTime') is not None:
            self.task_rerun_time = m.get('TaskRerunTime')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class ListInstancesResponseBodyData(TeaModel):
    def __init__(self, instances=None, page_number=None, page_size=None, total_count=None):
        # The name of the node. You can call the [ListNodes](~~173979~~) operation to query the name of the node.
        self.instances = instances  # type: list[ListInstancesResponseBodyDataInstances]
        # The time when the node was scheduled to run.
        self.page_number = page_number  # type: int
        # The end of the time range to query. Specify the time in the yyyy-MM-dd HH:mm:ss format.
        self.page_size = page_size  # type: int
        # The priority of the instance. Valid values: 1, 3, 5, 7, and 8.
        # 
        # A greater value indicates a higher priority. Default value: 1.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.instances:
            for k in self.instances:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListInstancesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Instances'] = []
        if self.instances is not None:
            for k in self.instances:
                result['Instances'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.instances = []
        if m.get('Instances') is not None:
            for k in m.get('Instances'):
                temp_model = ListInstancesResponseBodyDataInstances()
                self.instances.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListInstancesResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the node. You can call the [ListNodes](~~173979~~) operation to query the ID of the node.
        self.data = data  # type: ListInstancesResponseBodyData
        # The HTTP status code returned.
        self.error_code = error_code  # type: str
        # The page number of the returned page.
        self.error_message = error_message  # type: str
        # The error message that is returned for the instance.
        # 
        # This parameter is deprecated. You can call the [GetInstanceLog](~~173983~~) operation to query the error information related to the node.
        self.http_status_code = http_status_code  # type: int
        # The name of the node.
        self.request_id = request_id  # type: str
        # The beginning of the time range to query. Specify the time in the yyyy-MM-dd HH:mm:ss format.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListInstancesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListInstancesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListInstancesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListInstancesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListInstancesResponse, self).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=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 = ListInstancesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListLineageRequest(TeaModel):
    def __init__(self, direction=None, entity_qualified_name=None, keyword=None, next_token=None, page_size=None):
        self.direction = direction  # type: str
        self.entity_qualified_name = entity_qualified_name  # type: str
        self.keyword = keyword  # type: str
        self.next_token = next_token  # type: str
        self.page_size = page_size  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListLineageRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.direction is not None:
            result['Direction'] = self.direction
        if self.entity_qualified_name is not None:
            result['EntityQualifiedName'] = self.entity_qualified_name
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        if self.next_token is not None:
            result['NextToken'] = self.next_token
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Direction') is not None:
            self.direction = m.get('Direction')
        if m.get('EntityQualifiedName') is not None:
            self.entity_qualified_name = m.get('EntityQualifiedName')
        if m.get('Keyword') is not None:
            self.keyword = m.get('Keyword')
        if m.get('NextToken') is not None:
            self.next_token = m.get('NextToken')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        return self


class ListLineageResponseBodyDataDataEntityListRelationList(TeaModel):
    def __init__(self, channel=None, datasource=None, guid=None, type=None):
        self.channel = channel  # type: str
        self.datasource = datasource  # type: str
        self.guid = guid  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListLineageResponseBodyDataDataEntityListRelationList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.channel is not None:
            result['Channel'] = self.channel
        if self.datasource is not None:
            result['Datasource'] = self.datasource
        if self.guid is not None:
            result['Guid'] = self.guid
        if self.type is not None:
            result['Type'] = self.type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Channel') is not None:
            self.channel = m.get('Channel')
        if m.get('Datasource') is not None:
            self.datasource = m.get('Datasource')
        if m.get('Guid') is not None:
            self.guid = m.get('Guid')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class ListLineageResponseBodyDataDataEntityList(TeaModel):
    def __init__(self, create_timestamp=None, entity=None, relation_list=None):
        self.create_timestamp = create_timestamp  # type: long
        self.entity = entity  # type: Entity
        self.relation_list = relation_list  # type: list[ListLineageResponseBodyDataDataEntityListRelationList]

    def validate(self):
        if self.entity:
            self.entity.validate()
        if self.relation_list:
            for k in self.relation_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListLineageResponseBodyDataDataEntityList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.create_timestamp is not None:
            result['CreateTimestamp'] = self.create_timestamp
        if self.entity is not None:
            result['Entity'] = self.entity.to_map()
        result['RelationList'] = []
        if self.relation_list is not None:
            for k in self.relation_list:
                result['RelationList'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreateTimestamp') is not None:
            self.create_timestamp = m.get('CreateTimestamp')
        if m.get('Entity') is not None:
            temp_model = Entity()
            self.entity = temp_model.from_map(m['Entity'])
        self.relation_list = []
        if m.get('RelationList') is not None:
            for k in m.get('RelationList'):
                temp_model = ListLineageResponseBodyDataDataEntityListRelationList()
                self.relation_list.append(temp_model.from_map(k))
        return self


class ListLineageResponseBodyData(TeaModel):
    def __init__(self, data_entity_list=None, next_token=None):
        self.data_entity_list = data_entity_list  # type: list[ListLineageResponseBodyDataDataEntityList]
        self.next_token = next_token  # type: str

    def validate(self):
        if self.data_entity_list:
            for k in self.data_entity_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListLineageResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DataEntityList'] = []
        if self.data_entity_list is not None:
            for k in self.data_entity_list:
                result['DataEntityList'].append(k.to_map() if k else None)
        if self.next_token is not None:
            result['NextToken'] = self.next_token
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data_entity_list = []
        if m.get('DataEntityList') is not None:
            for k in m.get('DataEntityList'):
                temp_model = ListLineageResponseBodyDataDataEntityList()
                self.data_entity_list.append(temp_model.from_map(k))
        if m.get('NextToken') is not None:
            self.next_token = m.get('NextToken')
        return self


class ListLineageResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: ListLineageResponseBodyData
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListLineageResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListLineageResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListLineageResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListLineageResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListLineageResponse, self).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=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 = ListLineageResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListManualDagInstancesRequest(TeaModel):
    def __init__(self, dag_id=None, project_env=None, project_name=None):
        # The ID of the directed acyclic graph (DAG) for the manually triggered workflow. You can call the [RunManualDagNodes](~~212830~~) operation to obtain the ID.
        self.dag_id = dag_id  # type: str
        # The environment of the workspace. Valid values: PROD and DEV. A value of PROD indicates the production environment. A value of DEV indicates the development environment.
        self.project_env = project_env  # type: str
        # The name of the workspace to which the manually triggered workflow belongs. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to view the name.
        self.project_name = project_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListManualDagInstancesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class ListManualDagInstancesResponseBodyInstances(TeaModel):
    def __init__(self, begin_running_time=None, begin_wait_res_time=None, begin_wait_time_time=None, biz_date=None,
                 create_time=None, create_user=None, cyc_time=None, dag_id=None, dag_type=None, finish_time=None,
                 instance_id=None, modify_time=None, node_id=None, node_name=None, param_values=None, status=None,
                 task_type=None):
        # The time when the node started to run. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.begin_running_time = begin_running_time  # type: long
        # The time when the node started to wait for resources. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.begin_wait_res_time = begin_wait_res_time  # type: long
        # The time when the node started to wait to be scheduled. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.begin_wait_time_time = begin_wait_time_time  # type: long
        # The data timestamp of the instance. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC. In most cases, the value indicates one day before the time when the node was run.
        self.biz_date = biz_date  # type: long
        # The time when the node was created. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.create_time = create_time  # type: long
        # The name of the account used to run the instance. For example, if an account named Test was used to run the instance to backfill data, the value of this parameter is Test.
        self.create_user = create_user  # type: str
        # The time when the node was scheduled to run. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.cyc_time = cyc_time  # type: long
        # The ID of the DAG for the manually triggered workflow.
        self.dag_id = dag_id  # type: long
        # The identifier of the manually triggered workflow.
        self.dag_type = dag_type  # type: str
        # The time when the node stopped running. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.finish_time = finish_time  # type: long
        # The ID of the instance in the manually triggered workflow.
        self.instance_id = instance_id  # type: long
        # The time when the node was last modified. This value is a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        self.modify_time = modify_time  # type: long
        # The ID of the node in the manually triggered workflow.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The parameters related to the instance.
        self.param_values = param_values  # type: str
        # The status of the node. Valid values:
        # 
        # *   NOT_RUN: The node is not run.
        # *   WAIT_TIME: The node is waiting for its scheduled time to arrive.
        # *   WAIT_RESOURCE: The node is waiting for resources.
        # *   RUNNING: The node is running.
        # *   CHECKING: Data quality is being checked for the node.
        # *   CHECKING_CONDITION: Branch conditions are being checked for the node.
        # *   FAILURE: The node fails to run.
        # *   SUCCESS: The node is run as expected.
        self.status = status  # type: str
        # The scheduling type of the node. Valid values:
        # 
        # *   NORMAL(0): The node is an auto triggered node. It is run on a regular basis.
        # *   MANUAL(1): The node is a manually triggered node. It is not run on a regular basis.
        # *   PAUSE(2): The node is a frozen node. The scheduling system still runs the node on a regular basis but sets it to Failed when the scheduling system starts to run the node.
        # *   SKIP(3): The node is a dry-run node. The scheduling system still runs the node on a regular basis but sets it to Succeeded when the scheduling system starts to run the node.
        # *   SKIP_UNCHOOSE(4): The node is an unselected node in a temporary workflow. This type of node exists only in temporary workflows. The scheduling system sets the node to Succeeded when the scheduling system starts to run the node.
        # *   SKIP_CYCLE(5): The node is a node that is scheduled by week or month and is waiting for its scheduled time. The scheduling system still runs the node on a regular basis but sets it to Succeeded when the scheduling system starts to run the node.
        # *   CONDITION_UNCHOOSE(6): The node is not selected by its ancestor branch node and is run as a dry-run node.
        # *   REALTIME_DEPRECATED(7): The node has instances generated in real time but deprecated. The scheduling system directly sets the node to Succeeded.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListManualDagInstancesResponseBodyInstances, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.begin_running_time is not None:
            result['BeginRunningTime'] = self.begin_running_time
        if self.begin_wait_res_time is not None:
            result['BeginWaitResTime'] = self.begin_wait_res_time
        if self.begin_wait_time_time is not None:
            result['BeginWaitTimeTime'] = self.begin_wait_time_time
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.create_user is not None:
            result['CreateUser'] = self.create_user
        if self.cyc_time is not None:
            result['CycTime'] = self.cyc_time
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.dag_type is not None:
            result['DagType'] = self.dag_type
        if self.finish_time is not None:
            result['FinishTime'] = self.finish_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.modify_time is not None:
            result['ModifyTime'] = self.modify_time
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.param_values is not None:
            result['ParamValues'] = self.param_values
        if self.status is not None:
            result['Status'] = self.status
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BeginRunningTime') is not None:
            self.begin_running_time = m.get('BeginRunningTime')
        if m.get('BeginWaitResTime') is not None:
            self.begin_wait_res_time = m.get('BeginWaitResTime')
        if m.get('BeginWaitTimeTime') is not None:
            self.begin_wait_time_time = m.get('BeginWaitTimeTime')
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('CreateUser') is not None:
            self.create_user = m.get('CreateUser')
        if m.get('CycTime') is not None:
            self.cyc_time = m.get('CycTime')
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('DagType') is not None:
            self.dag_type = m.get('DagType')
        if m.get('FinishTime') is not None:
            self.finish_time = m.get('FinishTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ModifyTime') is not None:
            self.modify_time = m.get('ModifyTime')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('ParamValues') is not None:
            self.param_values = m.get('ParamValues')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class ListManualDagInstancesResponseBody(TeaModel):
    def __init__(self, instances=None, request_id=None):
        # The instances in the manually triggered workflow.
        self.instances = instances  # type: list[ListManualDagInstancesResponseBodyInstances]
        # The ID of the request. You can use the ID to search for logs and troubleshoot issues based on the logs.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.instances:
            for k in self.instances:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListManualDagInstancesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Instances'] = []
        if self.instances is not None:
            for k in self.instances:
                result['Instances'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.instances = []
        if m.get('Instances') is not None:
            for k in m.get('Instances'):
                temp_model = ListManualDagInstancesResponseBodyInstances()
                self.instances.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListManualDagInstancesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListManualDagInstancesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListManualDagInstancesResponse, self).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=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 = ListManualDagInstancesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListMetaCollectionEntitiesRequest(TeaModel):
    def __init__(self, collection_qualified_name=None, entity_type=None, keyword=None, next_token=None,
                 page_size=None):
        # The type of the entities.
        # 
        # For example, if this parameter is set to maxcompute-table, the entity is a MaxCompute table.
        self.collection_qualified_name = collection_qualified_name  # type: str
        # The search keyword.
        self.entity_type = entity_type  # type: str
        # The paging information. This parameter specifies the start point of the query.
        self.keyword = keyword  # type: str
        # The number of entries to return on each page.
        self.next_token = next_token  # type: str
        # The object returned.
        self.page_size = page_size  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListMetaCollectionEntitiesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.collection_qualified_name is not None:
            result['CollectionQualifiedName'] = self.collection_qualified_name
        if self.entity_type is not None:
            result['EntityType'] = self.entity_type
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        if self.next_token is not None:
            result['NextToken'] = self.next_token
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CollectionQualifiedName') is not None:
            self.collection_qualified_name = m.get('CollectionQualifiedName')
        if m.get('EntityType') is not None:
            self.entity_type = m.get('EntityType')
        if m.get('Keyword') is not None:
            self.keyword = m.get('Keyword')
        if m.get('NextToken') is not None:
            self.next_token = m.get('NextToken')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        return self


class ListMetaCollectionEntitiesResponseBodyData(TeaModel):
    def __init__(self, entity_list=None, next_token=None):
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.entity_list = entity_list  # type: list[Entity]
        # The entities.
        self.next_token = next_token  # type: str

    def validate(self):
        if self.entity_list:
            for k in self.entity_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListMetaCollectionEntitiesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['EntityList'] = []
        if self.entity_list is not None:
            for k in self.entity_list:
                result['EntityList'].append(k.to_map() if k else None)
        if self.next_token is not None:
            result['NextToken'] = self.next_token
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.entity_list = []
        if m.get('EntityList') is not None:
            for k in m.get('EntityList'):
                temp_model = Entity()
                self.entity_list.append(temp_model.from_map(k))
        if m.get('NextToken') is not None:
            self.next_token = m.get('NextToken')
        return self


class ListMetaCollectionEntitiesResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The token that is used for the next query.
        self.data = data  # type: ListMetaCollectionEntitiesResponseBodyData
        # The error message returned.
        self.error_code = error_code  # type: str
        # The HTTP status code returned.
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        # Indicates whether the request was successful. Valid values:
        # 
        # true: The request was successful.
        # 
        # false: The request failed.
        self.request_id = request_id  # type: str
        # The error code returned.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListMetaCollectionEntitiesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListMetaCollectionEntitiesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListMetaCollectionEntitiesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListMetaCollectionEntitiesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListMetaCollectionEntitiesResponse, self).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=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 = ListMetaCollectionEntitiesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListMetaCollectionsRequest(TeaModel):
    def __init__(self, administrator=None, collection_type=None, creator=None, follower=None, keyword=None,
                 next_token=None, order_by=None, page_size=None, parent_qualified_name=None):
        # The ID of the collection follower.
        self.administrator = administrator  # type: str
        # The ID of the collection creator.
        self.collection_type = collection_type  # type: str
        # The ID of the collection administrator.
        self.creator = creator  # type: str
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.follower = follower  # type: str
        # The name of the sorting field.
        self.keyword = keyword  # type: str
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.next_token = next_token  # type: str
        # ALBUM: data album
        # 
        # ALBUM_CATEGORY: category in a data album
        self.order_by = order_by  # type: str
        # The keyword.
        self.page_size = page_size  # type: int
        # The paging information. This parameter specifies the start point of the query.
        self.parent_qualified_name = parent_qualified_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListMetaCollectionsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.administrator is not None:
            result['Administrator'] = self.administrator
        if self.collection_type is not None:
            result['CollectionType'] = self.collection_type
        if self.creator is not None:
            result['Creator'] = self.creator
        if self.follower is not None:
            result['Follower'] = self.follower
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        if self.next_token is not None:
            result['NextToken'] = self.next_token
        if self.order_by is not None:
            result['OrderBy'] = self.order_by
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.parent_qualified_name is not None:
            result['ParentQualifiedName'] = self.parent_qualified_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Administrator') is not None:
            self.administrator = m.get('Administrator')
        if m.get('CollectionType') is not None:
            self.collection_type = m.get('CollectionType')
        if m.get('Creator') is not None:
            self.creator = m.get('Creator')
        if m.get('Follower') is not None:
            self.follower = m.get('Follower')
        if m.get('Keyword') is not None:
            self.keyword = m.get('Keyword')
        if m.get('NextToken') is not None:
            self.next_token = m.get('NextToken')
        if m.get('OrderBy') is not None:
            self.order_by = m.get('OrderBy')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ParentQualifiedName') is not None:
            self.parent_qualified_name = m.get('ParentQualifiedName')
        return self


class ListMetaCollectionsResponseBodyData(TeaModel):
    def __init__(self, collection_list=None, next_token=None):
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.collection_list = collection_list  # type: list[Collection]
        # The collections.
        self.next_token = next_token  # type: str

    def validate(self):
        if self.collection_list:
            for k in self.collection_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListMetaCollectionsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['CollectionList'] = []
        if self.collection_list is not None:
            for k in self.collection_list:
                result['CollectionList'].append(k.to_map() if k else None)
        if self.next_token is not None:
            result['NextToken'] = self.next_token
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.collection_list = []
        if m.get('CollectionList') is not None:
            for k in m.get('CollectionList'):
                temp_model = Collection()
                self.collection_list.append(temp_model.from_map(k))
        if m.get('NextToken') is not None:
            self.next_token = m.get('NextToken')
        return self


class ListMetaCollectionsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The token that is used for the next query.
        self.data = data  # type: ListMetaCollectionsResponseBodyData
        # The error message returned.
        self.error_code = error_code  # type: str
        # The HTTP status code returned.
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        # The object returned.
        self.request_id = request_id  # type: str
        # The error code returned.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListMetaCollectionsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListMetaCollectionsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListMetaCollectionsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListMetaCollectionsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListMetaCollectionsResponse, self).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=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 = ListMetaCollectionsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListMetaDBRequest(TeaModel):
    def __init__(self, cluster_id=None, data_source_type=None, page_num=None, page_size=None, project_id=None):
        # The information of the metadatabases.
        self.cluster_id = cluster_id  # type: str
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.data_source_type = data_source_type  # type: str
        # The ID of the E-MapReduce (EMR) cluster. You can log on to the [EMR console](https://emr.console.aliyun.com/?spm=a2c4g.11186623.0.0.965cc5c2GeiHet#/cn-hangzhou) to obtain the ID.
        self.page_num = page_num  # type: int
        # The ID of the request.
        self.page_size = page_size  # type: int
        # The number of the page to return.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListMetaDBRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.page_num is not None:
            result['PageNum'] = self.page_num
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('PageNum') is not None:
            self.page_num = m.get('PageNum')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListMetaDBResponseBodyDatabaseInfoDbList(TeaModel):
    def __init__(self, create_time_stamp=None, location=None, modified_time_stamp=None, name=None, owner_id=None,
                 type=None, uuid=None):
        # The timestamp at which the metadatabase was updated.
        self.create_time_stamp = create_time_stamp  # type: long
        self.location = location  # type: str
        # The ID of the metadatabase owner.
        self.modified_time_stamp = modified_time_stamp  # type: long
        # The URL of the metadatabase.
        self.name = name  # type: str
        self.owner_id = owner_id  # type: str
        # The universally unique identifier (UUID) of the metadatabase.
        self.type = type  # type: str
        # The name of the metadatabase.
        self.uuid = uuid  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListMetaDBResponseBodyDatabaseInfoDbList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.create_time_stamp is not None:
            result['CreateTimeStamp'] = self.create_time_stamp
        if self.location is not None:
            result['Location'] = self.location
        if self.modified_time_stamp is not None:
            result['ModifiedTimeStamp'] = self.modified_time_stamp
        if self.name is not None:
            result['Name'] = self.name
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.type is not None:
            result['Type'] = self.type
        if self.uuid is not None:
            result['UUID'] = self.uuid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreateTimeStamp') is not None:
            self.create_time_stamp = m.get('CreateTimeStamp')
        if m.get('Location') is not None:
            self.location = m.get('Location')
        if m.get('ModifiedTimeStamp') is not None:
            self.modified_time_stamp = m.get('ModifiedTimeStamp')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        if m.get('UUID') is not None:
            self.uuid = m.get('UUID')
        return self


class ListMetaDBResponseBodyDatabaseInfo(TeaModel):
    def __init__(self, db_list=None, total_count=None):
        # The timestamp at which the metadatabase was created. You can convert the timestamp to the related date based on the time zone that you use.
        self.db_list = db_list  # type: list[ListMetaDBResponseBodyDatabaseInfoDbList]
        # The type of the metadatabase.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.db_list:
            for k in self.db_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListMetaDBResponseBodyDatabaseInfo, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DbList'] = []
        if self.db_list is not None:
            for k in self.db_list:
                result['DbList'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.db_list = []
        if m.get('DbList') is not None:
            for k in m.get('DbList'):
                temp_model = ListMetaDBResponseBodyDatabaseInfoDbList()
                self.db_list.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListMetaDBResponseBody(TeaModel):
    def __init__(self, database_info=None, request_id=None):
        # The list of metadatabases.
        self.database_info = database_info  # type: ListMetaDBResponseBodyDatabaseInfo
        # The total number of the metadatabases.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.database_info:
            self.database_info.validate()

    def to_map(self):
        _map = super(ListMetaDBResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.database_info is not None:
            result['DatabaseInfo'] = self.database_info.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DatabaseInfo') is not None:
            temp_model = ListMetaDBResponseBodyDatabaseInfo()
            self.database_info = temp_model.from_map(m['DatabaseInfo'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListMetaDBResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListMetaDBResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListMetaDBResponse, self).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=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 = ListMetaDBResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListMigrationsRequest(TeaModel):
    def __init__(self, migration_type=None, owner=None, page_number=None, page_size=None, project_id=None):
        # The ID of the owner.
        self.migration_type = migration_type  # type: str
        # The number of the page to return.
        self.owner = owner  # type: str
        # The number of entries to return on each page. Maximum value: 100.
        self.page_number = page_number  # type: int
        # The ID of the request.
        self.page_size = page_size  # type: int
        # The type of the migration task. Valid values: IMPORT and EXPORT.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListMigrationsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.migration_type is not None:
            result['MigrationType'] = self.migration_type
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('MigrationType') is not None:
            self.migration_type = m.get('MigrationType')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListMigrationsResponseBodyDataMigrations(TeaModel):
    def __init__(self, create_time=None, create_user=None, create_user_name=None, description=None,
                 download_url=None, id=None, message=None, migration_type=None, name=None, package_type=None, project_id=None,
                 status=None, tenant_id=None, update_time=None, update_user=None, update_user_name=None):
        # The time when the migration task was last updated.
        self.create_time = create_time  # type: long
        # The name of the user who created the migration task.
        self.create_user = create_user  # type: str
        # The ID of the user who last updated the migration task.
        self.create_user_name = create_user_name  # type: str
        # The page number of the returned page.
        self.description = description  # type: str
        # The description of the export task.
        self.download_url = download_url  # type: str
        # The name of the migration task.
        self.id = id  # type: long
        # The URL that is used to download the package of the export task. You can use the URL to download the package of the export task.
        self.message = message  # type: str
        # The time when the migration task was created.
        self.migration_type = migration_type  # type: str
        # The type of the import or export package. Valid values:
        # 
        # *   DWMA (standard format)
        # *   DATAWORKS_MODEL (standard format)
        # *   DATAWORKS_V2 (Apsara Stack DataWorks V3.6.1 to V3.11)
        # *   DATAWORKS_V3 (Apsara Stack DataWorks V3.12 and later)
        # 
        # The DWMA and DATAWORKS_MODEL types are interchangeable.
        self.name = name  # type: str
        # The type of the migration task.
        # 
        # *   IMPORT
        # *   EXPORT
        self.package_type = package_type  # type: str
        # The ID of the tenant.
        self.project_id = project_id  # type: long
        # The error message returned.
        self.status = status  # type: str
        # The status of the migration task. Valid values:
        # 
        # *   INIT: The migration task is in the initial state.
        # *   EDITING: The migration task is being edited.
        # *   RUNNING: The migration task is running.
        # *   FAILURE: The migration task fails to run.
        # *   SUCCESS: The migration task is successfully run.
        self.tenant_id = tenant_id  # type: long
        # The ID of the user who created the migration task.
        self.update_time = update_time  # type: long
        # The name of the user who last updated the migration task.
        self.update_user = update_user  # type: str
        # The ID of the DataWorks workspace to which the task belongs.
        self.update_user_name = update_user_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListMigrationsResponseBodyDataMigrations, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.create_user is not None:
            result['CreateUser'] = self.create_user
        if self.create_user_name is not None:
            result['CreateUserName'] = self.create_user_name
        if self.description is not None:
            result['Description'] = self.description
        if self.download_url is not None:
            result['DownloadUrl'] = self.download_url
        if self.id is not None:
            result['Id'] = self.id
        if self.message is not None:
            result['Message'] = self.message
        if self.migration_type is not None:
            result['MigrationType'] = self.migration_type
        if self.name is not None:
            result['Name'] = self.name
        if self.package_type is not None:
            result['PackageType'] = self.package_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.update_time is not None:
            result['UpdateTime'] = self.update_time
        if self.update_user is not None:
            result['UpdateUser'] = self.update_user
        if self.update_user_name is not None:
            result['UpdateUserName'] = self.update_user_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('CreateUser') is not None:
            self.create_user = m.get('CreateUser')
        if m.get('CreateUserName') is not None:
            self.create_user_name = m.get('CreateUserName')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('DownloadUrl') is not None:
            self.download_url = m.get('DownloadUrl')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('MigrationType') is not None:
            self.migration_type = m.get('MigrationType')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('PackageType') is not None:
            self.package_type = m.get('PackageType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('UpdateTime') is not None:
            self.update_time = m.get('UpdateTime')
        if m.get('UpdateUser') is not None:
            self.update_user = m.get('UpdateUser')
        if m.get('UpdateUserName') is not None:
            self.update_user_name = m.get('UpdateUserName')
        return self


class ListMigrationsResponseBodyData(TeaModel):
    def __init__(self, migrations=None, page_number=None, page_size=None, total_count=None):
        # The ID of the primary key.
        self.migrations = migrations  # type: list[ListMigrationsResponseBodyDataMigrations]
        # The number of entries returned per page. Default value: 10. Maximum value: 50.
        self.page_number = page_number  # type: int
        # The total number of entries returned.
        self.page_size = page_size  # type: int
        self.total_count = total_count  # type: int

    def validate(self):
        if self.migrations:
            for k in self.migrations:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListMigrationsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Migrations'] = []
        if self.migrations is not None:
            for k in self.migrations:
                result['Migrations'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.migrations = []
        if m.get('Migrations') is not None:
            for k in m.get('Migrations'):
                temp_model = ListMigrationsResponseBodyDataMigrations()
                self.migrations.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListMigrationsResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # The list of migration tasks.
        self.data = data  # type: ListMigrationsResponseBodyData
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.request_id = request_id  # type: str
        # The data returned.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListMigrationsResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListMigrationsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListMigrationsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListMigrationsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListMigrationsResponse, self).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=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 = ListMigrationsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListNodeIORequest(TeaModel):
    def __init__(self, io_type=None, node_id=None, project_env=None):
        self.io_type = io_type  # type: str
        self.node_id = node_id  # type: long
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListNodeIORequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.io_type is not None:
            result['IoType'] = self.io_type
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('IoType') is not None:
            self.io_type = m.get('IoType')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class ListNodeIOResponseBodyData(TeaModel):
    def __init__(self, data=None, node_id=None, table_name=None):
        self.data = data  # type: str
        self.node_id = node_id  # type: long
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListNodeIOResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class ListNodeIOResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: list[ListNodeIOResponseBodyData]
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListNodeIOResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = ListNodeIOResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListNodeIOResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListNodeIOResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListNodeIOResponse, self).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=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 = ListNodeIOResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListNodeInputOrOutputRequest(TeaModel):
    def __init__(self, io_type=None, node_id=None, project_env=None):
        # The type of node that you want to query. Valid values:
        # 
        # *   input: ancestor nodes
        # *   output: descendant nodes
        self.io_type = io_type  # type: str
        # The ID of the node. You can call the [ListNodes](~~173979~~) operation to query the node ID.
        self.node_id = node_id  # type: long
        # The environment of the workspace. Valid values: DEV and PROD. A value of DEV indicates the development environment. A value of PROD indicates the production environment.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListNodeInputOrOutputRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.io_type is not None:
            result['IoType'] = self.io_type
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('IoType') is not None:
            self.io_type = m.get('IoType')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class ListNodeInputOrOutputResponseBodyData(TeaModel):
    def __init__(self, data=None, node_id=None, table_name=None):
        # The name of the ancestor or descendant node.
        self.data = data  # type: str
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The name of the associated table.
        self.table_name = table_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListNodeInputOrOutputResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.table_name is not None:
            result['TableName'] = self.table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class ListNodeInputOrOutputResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ancestor or descendant nodes.
        self.data = data  # type: list[ListNodeInputOrOutputResponseBodyData]
        # The error code returned if the request fails.
        self.error_code = error_code  # type: str
        # The error message returned if the request fails.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListNodeInputOrOutputResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = ListNodeInputOrOutputResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListNodeInputOrOutputResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListNodeInputOrOutputResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListNodeInputOrOutputResponse, self).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=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 = ListNodeInputOrOutputResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListNodesRequest(TeaModel):
    def __init__(self, biz_name=None, node_name=None, owner=None, page_number=None, page_size=None,
                 program_type=None, project_env=None, project_id=None):
        # The error code returned.
        self.biz_name = biz_name  # type: str
        # The ID of the baseline with which the node is associated.
        self.node_name = node_name  # type: str
        # The description of the node.
        self.owner = owner  # type: str
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_number = page_number  # type: int
        # The ID of the workspace.
        self.page_size = page_size  # type: int
        # The operation that you want to perform. Set the value to **ListNodes**.
        self.program_type = program_type  # type: str
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.project_env = project_env  # type: str
        # The ID of the owner.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListNodesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_name is not None:
            result['BizName'] = self.biz_name
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizName') is not None:
            self.biz_name = m.get('BizName')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListNodesResponseBodyDataNodes(TeaModel):
    def __init__(self, baseline_id=None, business_id=None, connection=None, cron_express=None, description=None,
                 dqc_description=None, dqc_type=None, file_type=None, node_id=None, node_name=None, owner_id=None, param_values=None,
                 priority=None, program_type=None, project_id=None, related_flow_id=None, repeat_interval=None,
                 repeatability=None, res_group_identifier=None, res_group_name=None, scheduler_type=None):
        # The number of the page to return. Minimum value: 1. Maximum value: 100.
        self.baseline_id = baseline_id  # type: long
        # The operation that you want to perform. Set the value to **ListNodes**.
        self.business_id = business_id  # type: long
        # The name of the resource group.
        self.connection = connection  # type: str
        # The name of the workflow.
        self.cron_express = cron_express  # type: str
        # The priority for running the node. Valid values: 1, 3, 5, 7, and 8.
        self.description = description  # type: str
        # The ID of the owner.
        self.dqc_description = dqc_description  # type: str
        # The connection string.
        self.dqc_type = dqc_type  # type: int
        self.file_type = file_type  # type: int
        # The types of the nodes. You can call the [ListNodes](~~173979~~) operation to query the type of the node.
        self.node_id = node_id  # type: long
        # The total number of nodes returned.
        self.node_name = node_name  # type: str
        # The additional parameters.
        self.owner_id = owner_id  # type: str
        # The type of the node.
        self.param_values = param_values  # type: str
        # The ID of the owner.
        self.priority = priority  # type: int
        # The error message returned.
        self.program_type = program_type  # type: str
        # The information about the nodes.
        self.project_id = project_id  # type: long
        # The table and partition filter expression in Data Quality that are associated with the node.
        self.related_flow_id = related_flow_id  # type: long
        # The environment of the workspace. Valid values: PROD and DEV.
        self.repeat_interval = repeat_interval  # type: long
        # The name of the node.
        self.repeatability = repeatability  # type: bool
        self.res_group_identifier = res_group_identifier  # type: str
        # The ID of the workflow.
        self.res_group_name = res_group_name  # type: str
        # The types of the nodes. You can call the [ListNodes](~~173979~~) operation to query the type of the node.
        self.scheduler_type = scheduler_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListNodesResponseBodyDataNodes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.connection is not None:
            result['Connection'] = self.connection
        if self.cron_express is not None:
            result['CronExpress'] = self.cron_express
        if self.description is not None:
            result['Description'] = self.description
        if self.dqc_description is not None:
            result['DqcDescription'] = self.dqc_description
        if self.dqc_type is not None:
            result['DqcType'] = self.dqc_type
        if self.file_type is not None:
            result['FileType'] = self.file_type
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.param_values is not None:
            result['ParamValues'] = self.param_values
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.related_flow_id is not None:
            result['RelatedFlowId'] = self.related_flow_id
        if self.repeat_interval is not None:
            result['RepeatInterval'] = self.repeat_interval
        if self.repeatability is not None:
            result['Repeatability'] = self.repeatability
        if self.res_group_identifier is not None:
            result['ResGroupIdentifier'] = self.res_group_identifier
        if self.res_group_name is not None:
            result['ResGroupName'] = self.res_group_name
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('Connection') is not None:
            self.connection = m.get('Connection')
        if m.get('CronExpress') is not None:
            self.cron_express = m.get('CronExpress')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('DqcDescription') is not None:
            self.dqc_description = m.get('DqcDescription')
        if m.get('DqcType') is not None:
            self.dqc_type = m.get('DqcType')
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('ParamValues') is not None:
            self.param_values = m.get('ParamValues')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RelatedFlowId') is not None:
            self.related_flow_id = m.get('RelatedFlowId')
        if m.get('RepeatInterval') is not None:
            self.repeat_interval = m.get('RepeatInterval')
        if m.get('Repeatability') is not None:
            self.repeatability = m.get('Repeatability')
        if m.get('ResGroupIdentifier') is not None:
            self.res_group_identifier = m.get('ResGroupIdentifier')
        if m.get('ResGroupName') is not None:
            self.res_group_name = m.get('ResGroupName')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        return self


class ListNodesResponseBodyData(TeaModel):
    def __init__(self, nodes=None, page_number=None, page_size=None, total_count=None):
        # The scheduling type of the node. Valid values:
        # 
        # *   NORMAL: indicates that the node is a normal auto triggered node.
        # *   MANUAL: indicates that the node is a manually triggered node.
        # *   PAUSE: indicates that the node is a paused node.
        # *   SKIP: indicates that the node is a dry-run node. Dry-run nodes are started as scheduled but the system sets the status of the nodes to successful when it starts to run them.
        self.nodes = nodes  # type: list[ListNodesResponseBodyDataNodes]
        # The name of the node.
        self.page_number = page_number  # type: int
        # The cron expression returned.
        self.page_size = page_size  # type: int
        # The name of the workflow.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.nodes:
            for k in self.nodes:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListNodesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Nodes'] = []
        if self.nodes is not None:
            for k in self.nodes:
                result['Nodes'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.nodes = []
        if m.get('Nodes') is not None:
            for k in m.get('Nodes'):
                temp_model = ListNodesResponseBodyDataNodes()
                self.nodes.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListNodesResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the associated workflow.
        self.data = data  # type: ListNodesResponseBodyData
        # The HTTP status code returned.
        self.error_code = error_code  # type: str
        # The page number of the returned page.
        self.error_message = error_message  # type: str
        # The interval at which the node is rerun after the node fails to run.
        self.http_status_code = http_status_code  # type: int
        # The list of nodes.
        self.request_id = request_id  # type: str
        # Indicates whether the node can be rerun.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListNodesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListNodesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListNodesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListNodesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListNodesResponse, self).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=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 = ListNodesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListNodesByBaselineRequest(TeaModel):
    def __init__(self, baseline_id=None):
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.baseline_id = baseline_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListNodesByBaselineRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        return self


class ListNodesByBaselineResponseBodyData(TeaModel):
    def __init__(self, node_id=None, node_name=None, owner=None, project_id=None):
        self.node_id = node_id  # type: long
        # The ID of the workspace to which the node belongs.
        self.node_name = node_name  # type: str
        # The ID of the node.
        self.owner = owner  # type: str
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListNodesByBaselineResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListNodesByBaselineResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The name of the node.
        self.data = data  # type: list[ListNodesByBaselineResponseBodyData]
        # The nodes in the baseline.
        self.error_code = error_code  # type: str
        # Indicates whether the request is successful.
        self.error_message = error_message  # type: str
        # The error message returned.
        self.http_status_code = http_status_code  # type: int
        # The error code returned.
        self.request_id = request_id  # type: str
        # The ID of the Alibaba Cloud account used by the node owner.
        self.success = success  # type: str

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListNodesByBaselineResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = ListNodesByBaselineResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListNodesByBaselineResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListNodesByBaselineResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListNodesByBaselineResponse, self).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=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 = ListNodesByBaselineResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListNodesByOutputRequest(TeaModel):
    def __init__(self, outputs=None, project_env=None):
        # The output name of the node. You can specify multiple output names. In this case, separate them with commas (,).
        self.outputs = outputs  # type: str
        # The environment type. Valid values: PROD and DEV. The value PROD indicates the production environment. The value DEV indicates the development environment.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListNodesByOutputRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.outputs is not None:
            result['Outputs'] = self.outputs
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Outputs') is not None:
            self.outputs = m.get('Outputs')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class ListNodesByOutputResponseBodyDataNodeList(TeaModel):
    def __init__(self, baseline_id=None, connection=None, cron_express=None, description=None, dqc_description=None,
                 dqc_type=None, file_type=None, node_id=None, node_name=None, owner_id=None, param_values=None, priority=None,
                 program_type=None, project_id=None, related_flow_id=None, repeat_interval=None, repeatability=None,
                 res_group_name=None, scheduler_type=None):
        # The ID of the baseline.
        self.baseline_id = baseline_id  # type: long
        # The name of the data source.
        self.connection = connection  # type: str
        # The cron expression.
        self.cron_express = cron_express  # type: str
        # The description of the node.
        self.description = description  # type: str
        # The table and partition filter expression in Data Quality that are associated with the node.
        self.dqc_description = dqc_description  # type: str
        # Indicates whether the node is associated with Data Quality. Valid values: 0 and 1. The value 0 indicates that node is associated with Data Quality, and the value 1 indicates that the node is not associated with Data Quality.
        self.dqc_type = dqc_type  # type: int
        # The type of the node.
        # 
        # Valid values:
        # 
        # 6 (Shell node), 10 (ODPS SQL node), 11 (ODPS MR node), 23 (Data Integration node), 24 (ODPS Script node), 99 (zero-load node), 221 (PyODPS 2 node), 225 (ODPS Spark node), 227 (EMR Hive node), 228 (EMR Spark node), 229 (EMR Spark SQL node), 230 (EMR MR node), 239 (OSS object inspection node), 257 (EMR Shell node), 258 (EMR Spark Shell node), 259 (EMR Presto node), 260 (EMR Impala node), 900 (real-time synchronization node), 1089 (cross-tenant collaboration node), 1091 (Hologres development node), 1093 (Hologres SQL node), 1100 (assignment node), and 1221 (PyODPS 3 node).
        self.file_type = file_type  # type: str
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The ID of the node owner.
        self.owner_id = owner_id  # type: str
        # The values of the scheduling parameters configured for the node.
        self.param_values = param_values  # type: str
        # The priority of the node. Valid values: 1, 3, 5, 7, and 8. A large value indicates a high priority. Default value: 1.
        self.priority = priority  # type: int
        # The type of the node. This parameter is deprecated. For more information about node types, see the valid values of FileType.
        self.program_type = program_type  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The ID of the associated workflow.
        self.related_flow_id = related_flow_id  # type: long
        # The interval at which the node is rerun after the node fails to run.
        self.repeat_interval = repeat_interval  # type: int
        # Indicates whether the node can be rerun.
        self.repeatability = repeatability  # type: bool
        # The name of the resource group.
        self.res_group_name = res_group_name  # type: str
        # The scheduling type of the node. Valid values:
        # 
        # *   NORAMAL: The node is an auto triggered node. The node is scheduled on a regular basis.
        # *   MANUAL: The node is a manually triggered node. The node is not scheduled on a regular basis.
        # *   PAUSE: The node is a frozen node. The system schedules the node on a regular basis but sets it to FAILURE when the system starts to schedule it.
        # *   SKIP: The node is a dry-run node. The system schedules the node on a regular basis but sets it to SUCCESS when the system starts to schedule it.
        self.scheduler_type = scheduler_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListNodesByOutputResponseBodyDataNodeList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.connection is not None:
            result['Connection'] = self.connection
        if self.cron_express is not None:
            result['CronExpress'] = self.cron_express
        if self.description is not None:
            result['Description'] = self.description
        if self.dqc_description is not None:
            result['DqcDescription'] = self.dqc_description
        if self.dqc_type is not None:
            result['DqcType'] = self.dqc_type
        if self.file_type is not None:
            result['FileType'] = self.file_type
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.param_values is not None:
            result['ParamValues'] = self.param_values
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.related_flow_id is not None:
            result['RelatedFlowId'] = self.related_flow_id
        if self.repeat_interval is not None:
            result['RepeatInterval'] = self.repeat_interval
        if self.repeatability is not None:
            result['Repeatability'] = self.repeatability
        if self.res_group_name is not None:
            result['ResGroupName'] = self.res_group_name
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('Connection') is not None:
            self.connection = m.get('Connection')
        if m.get('CronExpress') is not None:
            self.cron_express = m.get('CronExpress')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('DqcDescription') is not None:
            self.dqc_description = m.get('DqcDescription')
        if m.get('DqcType') is not None:
            self.dqc_type = m.get('DqcType')
        if m.get('FileType') is not None:
            self.file_type = m.get('FileType')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('ParamValues') is not None:
            self.param_values = m.get('ParamValues')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RelatedFlowId') is not None:
            self.related_flow_id = m.get('RelatedFlowId')
        if m.get('RepeatInterval') is not None:
            self.repeat_interval = m.get('RepeatInterval')
        if m.get('Repeatability') is not None:
            self.repeatability = m.get('Repeatability')
        if m.get('ResGroupName') is not None:
            self.res_group_name = m.get('ResGroupName')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        return self


class ListNodesByOutputResponseBodyData(TeaModel):
    def __init__(self, node_list=None, output=None):
        # The information of the nodes returned.
        self.node_list = node_list  # type: list[ListNodesByOutputResponseBodyDataNodeList]
        # The output name of the current node.
        self.output = output  # type: str

    def validate(self):
        if self.node_list:
            for k in self.node_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListNodesByOutputResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['NodeList'] = []
        if self.node_list is not None:
            for k in self.node_list:
                result['NodeList'].append(k.to_map() if k else None)
        if self.output is not None:
            result['Output'] = self.output
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.node_list = []
        if m.get('NodeList') is not None:
            for k in m.get('NodeList'):
                temp_model = ListNodesByOutputResponseBodyDataNodeList()
                self.node_list.append(temp_model.from_map(k))
        if m.get('Output') is not None:
            self.output = m.get('Output')
        return self


class ListNodesByOutputResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The nodes returned.
        self.data = data  # type: list[ListNodesByOutputResponseBodyData]
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to locate logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListNodesByOutputResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = ListNodesByOutputResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListNodesByOutputResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListNodesByOutputResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListNodesByOutputResponse, self).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=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 = ListNodesByOutputResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListPermissionApplyOrdersRequest(TeaModel):
    def __init__(self, end_time=None, engine_type=None, flow_status=None, max_compute_project_name=None,
                 order_type=None, page_num=None, page_size=None, query_type=None, start_time=None, table_name=None,
                 workspace_id=None):
        # The end time. You can query all permission request orders that have been submitted before the time. The parameter value is a UNIX timestamp. If you do not specify the parameter, all permission request orders that are submitted before the current time are queried.
        self.end_time = end_time  # type: long
        # The type of the compute engine with which the permission request order is associated. The parameter value is odps and cannot be changed. This value indicates that you can request permissions only on fields of tables in MaxCompute compute engine instances.
        self.engine_type = engine_type  # type: str
        # The status of the permission request order. Valid values:
        # 
        # *   1: pending approval
        # *   2: approved and authorized
        # *   3: approved but authorization failed
        # *   4: rejected
        self.flow_status = flow_status  # type: int
        # The name of the MaxCompute project to which the permission request order belongs. If you do not specify the parameter, the permission request orders of all MaxCompute projects are returned.
        self.max_compute_project_name = max_compute_project_name  # type: str
        # The type of the permission request order. The parameter value is 1 and cannot be changed. This value indicates ACL-based authorization.
        self.order_type = order_type  # type: int
        # The number of the page to return. Pages start from page 1. Default value: 1.
        self.page_num = page_num  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The query type of the permission request order. Valid values:
        # 
        # *   0: The permission request orders you submitted.
        # *   1: The permission request orders you approved.
        self.query_type = query_type  # type: int
        # The start time. You can query all permission request orders that have been submitted after the time. The parameter value is a UNIX timestamp. If you do not specify the parameter, all permission request orders are queried.
        self.start_time = start_time  # type: long
        # The name of the table with which the permission request order is associated. If you do not specify the parameter, the permission request orders of all tables are returned.
        self.table_name = table_name  # type: str
        # The ID of the DataWorks workspace to which the permission request order belongs. If you do not specify the parameter, the permission request orders of all workspaces are returned. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID.
        self.workspace_id = workspace_id  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListPermissionApplyOrdersRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.engine_type is not None:
            result['EngineType'] = self.engine_type
        if self.flow_status is not None:
            result['FlowStatus'] = self.flow_status
        if self.max_compute_project_name is not None:
            result['MaxComputeProjectName'] = self.max_compute_project_name
        if self.order_type is not None:
            result['OrderType'] = self.order_type
        if self.page_num is not None:
            result['PageNum'] = self.page_num
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.query_type is not None:
            result['QueryType'] = self.query_type
        if self.start_time is not None:
            result['StartTime'] = self.start_time
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.workspace_id is not None:
            result['WorkspaceId'] = self.workspace_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('EngineType') is not None:
            self.engine_type = m.get('EngineType')
        if m.get('FlowStatus') is not None:
            self.flow_status = m.get('FlowStatus')
        if m.get('MaxComputeProjectName') is not None:
            self.max_compute_project_name = m.get('MaxComputeProjectName')
        if m.get('OrderType') is not None:
            self.order_type = m.get('OrderType')
        if m.get('PageNum') is not None:
            self.page_num = m.get('PageNum')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('QueryType') is not None:
            self.query_type = m.get('QueryType')
        if m.get('StartTime') is not None:
            self.start_time = m.get('StartTime')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


class ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContentProjectMetaObjectMetaList(TeaModel):
    def __init__(self, actions=None, object_name=None):
        # The permission that you wanted to request. If you wanted to request multiple permissions at the same time, separate them with commas (,).
        # 
        # You can request only the following permissions: Select, Describe, Drop, Alter, Update, and Download.
        self.actions = actions  # type: list[str]
        # The name of the table on which you requested permissions.
        self.object_name = object_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContentProjectMetaObjectMetaList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.actions is not None:
            result['Actions'] = self.actions
        if self.object_name is not None:
            result['ObjectName'] = self.object_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Actions') is not None:
            self.actions = m.get('Actions')
        if m.get('ObjectName') is not None:
            self.object_name = m.get('ObjectName')
        return self


class ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContentProjectMeta(TeaModel):
    def __init__(self, object_meta_list=None, workspace_name=None):
        # The information about the object on which you requested permissions.
        self.object_meta_list = object_meta_list  # type: list[ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContentProjectMetaObjectMetaList]
        # The name of the DataWorks workspace that was associated with the MaxCompute project in which you requested permissions on a table.
        self.workspace_name = workspace_name  # type: str

    def validate(self):
        if self.object_meta_list:
            for k in self.object_meta_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContentProjectMeta, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ObjectMetaList'] = []
        if self.object_meta_list is not None:
            for k in self.object_meta_list:
                result['ObjectMetaList'].append(k.to_map() if k else None)
        if self.workspace_name is not None:
            result['WorkspaceName'] = self.workspace_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.object_meta_list = []
        if m.get('ObjectMetaList') is not None:
            for k in m.get('ObjectMetaList'):
                temp_model = ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContentProjectMetaObjectMetaList()
                self.object_meta_list.append(temp_model.from_map(k))
        if m.get('WorkspaceName') is not None:
            self.workspace_name = m.get('WorkspaceName')
        return self


class ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContent(TeaModel):
    def __init__(self, apply_reason=None, order_type=None, project_meta=None):
        # The reason for your request. The administrator determines whether to approve the request based on the reason.
        self.apply_reason = apply_reason  # type: str
        # The type of the permission request order. The parameter value is 1 and cannot be changed. This value indicates ACL-based authorization.
        self.order_type = order_type  # type: int
        # The content of the object on which you requested permissions.
        self.project_meta = project_meta  # type: ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContentProjectMeta

    def validate(self):
        if self.project_meta:
            self.project_meta.validate()

    def to_map(self):
        _map = super(ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContent, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.apply_reason is not None:
            result['ApplyReason'] = self.apply_reason
        if self.order_type is not None:
            result['OrderType'] = self.order_type
        if self.project_meta is not None:
            result['ProjectMeta'] = self.project_meta.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApplyReason') is not None:
            self.apply_reason = m.get('ApplyReason')
        if m.get('OrderType') is not None:
            self.order_type = m.get('OrderType')
        if m.get('ProjectMeta') is not None:
            temp_model = ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContentProjectMeta()
            self.project_meta = temp_model.from_map(m['ProjectMeta'])
        return self


class ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrder(TeaModel):
    def __init__(self, apply_base_id=None, apply_timestamp=None, approve_content=None, flow_id=None,
                 flow_status=None):
        # The unique ID of the Alibaba Cloud account that was used to submit the permission request order.
        self.apply_base_id = apply_base_id  # type: str
        # The time when the permission request order was submitted. The parameter value is a UNIX timestamp.
        self.apply_timestamp = apply_timestamp  # type: long
        # The content of the permission request order.
        self.approve_content = approve_content  # type: ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContent
        # The ID of the permission request order.
        self.flow_id = flow_id  # type: str
        # The status of the permission request order. Valid values:
        # 
        # *   1: pending approval
        # *   2: approved and authorized
        # *   3: approved but authorization failed
        # *   4: rejected
        self.flow_status = flow_status  # type: int

    def validate(self):
        if self.approve_content:
            self.approve_content.validate()

    def to_map(self):
        _map = super(ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrder, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.apply_base_id is not None:
            result['ApplyBaseId'] = self.apply_base_id
        if self.apply_timestamp is not None:
            result['ApplyTimestamp'] = self.apply_timestamp
        if self.approve_content is not None:
            result['ApproveContent'] = self.approve_content.to_map()
        if self.flow_id is not None:
            result['FlowId'] = self.flow_id
        if self.flow_status is not None:
            result['FlowStatus'] = self.flow_status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApplyBaseId') is not None:
            self.apply_base_id = m.get('ApplyBaseId')
        if m.get('ApplyTimestamp') is not None:
            self.apply_timestamp = m.get('ApplyTimestamp')
        if m.get('ApproveContent') is not None:
            temp_model = ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContent()
            self.approve_content = temp_model.from_map(m['ApproveContent'])
        if m.get('FlowId') is not None:
            self.flow_id = m.get('FlowId')
        if m.get('FlowStatus') is not None:
            self.flow_status = m.get('FlowStatus')
        return self


class ListPermissionApplyOrdersResponseBodyApplyOrders(TeaModel):
    def __init__(self, apply_order=None, page_number=None, page_size=None, total_count=None):
        # The list of the permission request orders.
        self.apply_order = apply_order  # type: list[ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrder]
        # The number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries returned per page.
        self.page_size = page_size  # type: int
        # The total number of permission request orders returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.apply_order:
            for k in self.apply_order:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListPermissionApplyOrdersResponseBodyApplyOrders, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ApplyOrder'] = []
        if self.apply_order is not None:
            for k in self.apply_order:
                result['ApplyOrder'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.apply_order = []
        if m.get('ApplyOrder') is not None:
            for k in m.get('ApplyOrder'):
                temp_model = ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrder()
                self.apply_order.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListPermissionApplyOrdersResponseBody(TeaModel):
    def __init__(self, apply_orders=None, request_id=None):
        # The query results returned by page.
        self.apply_orders = apply_orders  # type: ListPermissionApplyOrdersResponseBodyApplyOrders
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.apply_orders:
            self.apply_orders.validate()

    def to_map(self):
        _map = super(ListPermissionApplyOrdersResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.apply_orders is not None:
            result['ApplyOrders'] = self.apply_orders.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApplyOrders') is not None:
            temp_model = ListPermissionApplyOrdersResponseBodyApplyOrders()
            self.apply_orders = temp_model.from_map(m['ApplyOrders'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListPermissionApplyOrdersResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListPermissionApplyOrdersResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListPermissionApplyOrdersResponse, self).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=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 = ListPermissionApplyOrdersResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListProgramTypeCountRequest(TeaModel):
    def __init__(self, project_env=None, project_id=None):
        # The environment of the workspace, including projects in PROD and DEV.
        self.project_env = project_env  # type: str
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProgramTypeCountRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListProgramTypeCountResponseBodyProgramTypeAndCounts(TeaModel):
    def __init__(self, count=None, program_type=None):
        # The number of nodes.
        self.count = count  # type: int
        # The type of the node.
        self.program_type = program_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProgramTypeCountResponseBodyProgramTypeAndCounts, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        return self


class ListProgramTypeCountResponseBody(TeaModel):
    def __init__(self, program_type_and_counts=None, request_id=None):
        # The type and number of nodes.
        self.program_type_and_counts = program_type_and_counts  # type: list[ListProgramTypeCountResponseBodyProgramTypeAndCounts]
        # The ID of the request, which is used to locate logs and troubleshoot problems.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.program_type_and_counts:
            for k in self.program_type_and_counts:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListProgramTypeCountResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ProgramTypeAndCounts'] = []
        if self.program_type_and_counts is not None:
            for k in self.program_type_and_counts:
                result['ProgramTypeAndCounts'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.program_type_and_counts = []
        if m.get('ProgramTypeAndCounts') is not None:
            for k in m.get('ProgramTypeAndCounts'):
                temp_model = ListProgramTypeCountResponseBodyProgramTypeAndCounts()
                self.program_type_and_counts.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListProgramTypeCountResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListProgramTypeCountResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListProgramTypeCountResponse, self).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=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 = ListProgramTypeCountResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListProjectIdsRequest(TeaModel):
    def __init__(self, user_id=None):
        # The ID of the specific Alibaba Cloud account. You can log on to the [DataWorks](https://workbench.data.aliyun.com/console) console and move the pointer over the profile picture in the upper-right corner to view the ID.
        self.user_id = user_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProjectIdsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.user_id is not None:
            result['UserId'] = self.user_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('UserId') is not None:
            self.user_id = m.get('UserId')
        return self


class ListProjectIdsResponseBody(TeaModel):
    def __init__(self, project_ids=None, request_id=None):
        # The IDs of the DataWorks workspaces.
        # 
        # The IDs of the workspaces on which the specific Alibaba Cloud account has permissions were returned. In this example, a single workspace ID is used.
        self.project_ids = project_ids  # type: list[long]
        # The ID of the request. You can troubleshoot errors based on the ID.
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProjectIdsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_ids is not None:
            result['ProjectIds'] = self.project_ids
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectIds') is not None:
            self.project_ids = m.get('ProjectIds')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListProjectIdsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListProjectIdsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListProjectIdsResponse, self).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=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 = ListProjectIdsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListProjectMembersRequest(TeaModel):
    def __init__(self, page_number=None, page_size=None, project_id=None):
        # The ID of the request.
        self.page_number = page_number  # type: int
        # The results that are returned.
        self.page_size = page_size  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProjectMembersRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListProjectMembersResponseBodyDataProjectMemberListProjectRoleList(TeaModel):
    def __init__(self, project_role_code=None, project_role_id=None, project_role_name=None,
                 project_role_type=None):
        self.project_role_code = project_role_code  # type: str
        # The name of the role.
        # 
        # DataWorks provides built-in roles and allows you to create custom roles based on your business requirements. For more information about roles, see [Overview of users, roles, and permissions](~~295463~~).
        self.project_role_id = project_role_id  # type: int
        self.project_role_name = project_role_name  # type: str
        # The code of the role.
        # 
        # DataWorks provides built-in roles and allows you to create custom roles based on your business requirements. For more information about roles, see [Overview of users, roles, and permissions](~~295463~~).
        self.project_role_type = project_role_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProjectMembersResponseBodyDataProjectMemberListProjectRoleList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_role_code is not None:
            result['ProjectRoleCode'] = self.project_role_code
        if self.project_role_id is not None:
            result['ProjectRoleId'] = self.project_role_id
        if self.project_role_name is not None:
            result['ProjectRoleName'] = self.project_role_name
        if self.project_role_type is not None:
            result['ProjectRoleType'] = self.project_role_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectRoleCode') is not None:
            self.project_role_code = m.get('ProjectRoleCode')
        if m.get('ProjectRoleId') is not None:
            self.project_role_id = m.get('ProjectRoleId')
        if m.get('ProjectRoleName') is not None:
            self.project_role_name = m.get('ProjectRoleName')
        if m.get('ProjectRoleType') is not None:
            self.project_role_type = m.get('ProjectRoleType')
        return self


class ListProjectMembersResponseBodyDataProjectMemberList(TeaModel):
    def __init__(self, nick=None, project_member_id=None, project_member_name=None, project_member_type=None,
                 project_role_list=None, status=None):
        # The type of the member. Valid values:
        # 
        # *   1: USER_ALIYUN, which indicates that the member is an Alibaba Cloud account.
        # *   5: USER_UBACCOUNT, which indicates that the member is a RAM user.
        # *   6: USER_STS_ROLE, which indicates that the member is a RAM role.
        self.nick = nick  # type: str
        # The name of the member.
        self.project_member_id = project_member_id  # type: str
        # The roles that are assigned to the member.
        self.project_member_name = project_member_name  # type: str
        # The ID of the role.
        self.project_member_type = project_member_type  # type: str
        # The type of the role. Valid values:
        # 
        # *   0: SYSTEM, which indicates that the role is a built-in role.
        # *   2: USER_CUSTOM, which indicates that the role is a custom role.
        self.project_role_list = project_role_list  # type: list[ListProjectMembersResponseBodyDataProjectMemberListProjectRoleList]
        # The nickname of the member.
        self.status = status  # type: str

    def validate(self):
        if self.project_role_list:
            for k in self.project_role_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListProjectMembersResponseBodyDataProjectMemberList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.nick is not None:
            result['Nick'] = self.nick
        if self.project_member_id is not None:
            result['ProjectMemberId'] = self.project_member_id
        if self.project_member_name is not None:
            result['ProjectMemberName'] = self.project_member_name
        if self.project_member_type is not None:
            result['ProjectMemberType'] = self.project_member_type
        result['ProjectRoleList'] = []
        if self.project_role_list is not None:
            for k in self.project_role_list:
                result['ProjectRoleList'].append(k.to_map() if k else None)
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Nick') is not None:
            self.nick = m.get('Nick')
        if m.get('ProjectMemberId') is not None:
            self.project_member_id = m.get('ProjectMemberId')
        if m.get('ProjectMemberName') is not None:
            self.project_member_name = m.get('ProjectMemberName')
        if m.get('ProjectMemberType') is not None:
            self.project_member_type = m.get('ProjectMemberType')
        self.project_role_list = []
        if m.get('ProjectRoleList') is not None:
            for k in m.get('ProjectRoleList'):
                temp_model = ListProjectMembersResponseBodyDataProjectMemberListProjectRoleList()
                self.project_role_list.append(temp_model.from_map(k))
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class ListProjectMembersResponseBodyData(TeaModel):
    def __init__(self, page_number=None, page_size=None, project_member_list=None, total_count=None):
        # The total number of entries returned.
        self.page_number = page_number  # type: int
        # The information of members in the DataWorks workspace.
        self.page_size = page_size  # type: int
        # The ID of the member.
        self.project_member_list = project_member_list  # type: list[ListProjectMembersResponseBodyDataProjectMemberList]
        # The status of the member. Valid values:
        # 
        # *   0: NORMAL, which indicates that the member is in a normal state.
        # *   1: FORBIDDEN, which indicates that the member is disabled.
        # *   2: DELETED, which indicates that the member is deleted.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.project_member_list:
            for k in self.project_member_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListProjectMembersResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        result['ProjectMemberList'] = []
        if self.project_member_list is not None:
            for k in self.project_member_list:
                result['ProjectMemberList'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        self.project_member_list = []
        if m.get('ProjectMemberList') is not None:
            for k in m.get('ProjectMemberList'):
                temp_model = ListProjectMembersResponseBodyDataProjectMemberList()
                self.project_member_list.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListProjectMembersResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None):
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.data = data  # type: ListProjectMembersResponseBodyData
        # The page number of the returned page.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListProjectMembersResponseBody, self).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=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListProjectMembersResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListProjectMembersResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListProjectMembersResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListProjectMembersResponse, self).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=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 = ListProjectMembersResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListProjectRolesRequest(TeaModel):
    def __init__(self, project_id=None):
        # Dataworks ID of the region where the workspace is located.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProjectRolesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListProjectRolesResponseBodyProjectRoleList(TeaModel):
    def __init__(self, project_role_code=None, project_role_id=None, project_role_name=None,
                 project_role_type=None):
        self.project_role_code = project_role_code  # type: str
        # The role type of the workspace. Valid values:
        self.project_role_id = project_role_id  # type: int
        # The role Code of the workspace.
        self.project_role_name = project_role_name  # type: str
        # The role name of the workspace.
        self.project_role_type = project_role_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProjectRolesResponseBodyProjectRoleList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_role_code is not None:
            result['ProjectRoleCode'] = self.project_role_code
        if self.project_role_id is not None:
            result['ProjectRoleId'] = self.project_role_id
        if self.project_role_name is not None:
            result['ProjectRoleName'] = self.project_role_name
        if self.project_role_type is not None:
            result['ProjectRoleType'] = self.project_role_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectRoleCode') is not None:
            self.project_role_code = m.get('ProjectRoleCode')
        if m.get('ProjectRoleId') is not None:
            self.project_role_id = m.get('ProjectRoleId')
        if m.get('ProjectRoleName') is not None:
            self.project_role_name = m.get('ProjectRoleName')
        if m.get('ProjectRoleType') is not None:
            self.project_role_type = m.get('ProjectRoleType')
        return self


class ListProjectRolesResponseBody(TeaModel):
    def __init__(self, project_role_list=None, request_id=None):
        # The role ID of the workspace.
        self.project_role_list = project_role_list  # type: list[ListProjectRolesResponseBodyProjectRoleList]
        # The roles of the workspace.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.project_role_list:
            for k in self.project_role_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListProjectRolesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ProjectRoleList'] = []
        if self.project_role_list is not None:
            for k in self.project_role_list:
                result['ProjectRoleList'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.project_role_list = []
        if m.get('ProjectRoleList') is not None:
            for k in m.get('ProjectRoleList'):
                temp_model = ListProjectRolesResponseBodyProjectRoleList()
                self.project_role_list.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListProjectRolesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListProjectRolesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListProjectRolesResponse, self).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=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 = ListProjectRolesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListProjectsRequestTags(TeaModel):
    def __init__(self, key=None, value=None):
        # The ID of the request.
        self.key = key  # type: str
        # The results that are returned.
        self.value = value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProjectsRequestTags, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class ListProjectsRequest(TeaModel):
    def __init__(self, page_number=None, page_size=None, resource_manager_resource_group_id=None, tags=None):
        # The ID of the resource group.
        self.page_number = page_number  # type: int
        # The tags.
        self.page_size = page_size  # type: int
        # The tag key.
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        # The tag value.
        self.tags = tags  # type: list[ListProjectsRequestTags]

    def validate(self):
        if self.tags:
            for k in self.tags:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListProjectsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.resource_manager_resource_group_id is not None:
            result['ResourceManagerResourceGroupId'] = self.resource_manager_resource_group_id
        result['Tags'] = []
        if self.tags is not None:
            for k in self.tags:
                result['Tags'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ResourceManagerResourceGroupId') is not None:
            self.resource_manager_resource_group_id = m.get('ResourceManagerResourceGroupId')
        self.tags = []
        if m.get('Tags') is not None:
            for k in m.get('Tags'):
                temp_model = ListProjectsRequestTags()
                self.tags.append(temp_model.from_map(k))
        return self


class ListProjectsShrinkRequest(TeaModel):
    def __init__(self, page_number=None, page_size=None, resource_manager_resource_group_id=None, tags_shrink=None):
        # The ID of the resource group.
        self.page_number = page_number  # type: int
        # The tags.
        self.page_size = page_size  # type: int
        # The tag key.
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        # The tag value.
        self.tags_shrink = tags_shrink  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProjectsShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.resource_manager_resource_group_id is not None:
            result['ResourceManagerResourceGroupId'] = self.resource_manager_resource_group_id
        if self.tags_shrink is not None:
            result['Tags'] = self.tags_shrink
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ResourceManagerResourceGroupId') is not None:
            self.resource_manager_resource_group_id = m.get('ResourceManagerResourceGroupId')
        if m.get('Tags') is not None:
            self.tags_shrink = m.get('Tags')
        return self


class ListProjectsResponseBodyPageResultProjectListTags(TeaModel):
    def __init__(self, key=None, value=None):
        # Indicates whether the Development role is disabled. Valid values:
        # 
        # *   false: enabled
        # *   true: disabled
        # *   Default value: false
        self.key = key  # type: str
        # Indicates whether a proxy account is used to access the MaxCompute compute engine associated with the workspace.
        self.value = value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProjectsResponseBodyPageResultProjectListTags, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class ListProjectsResponseBodyPageResultProjectList(TeaModel):
    def __init__(self, disable_development=None, is_default=None, project_description=None, project_id=None,
                 project_identifier=None, project_name=None, project_owner_base_id=None, project_status=None,
                 project_status_code=None, resource_manager_resource_group_id=None, table_privacy_mode=None, tags=None,
                 use_proxy_odps_account=None):
        # Indicates whether the MaxCompute tables in the workspace are visible to the users within a tenant. Valid values:
        # 
        # *   0: invisible
        # *   1: visible
        self.disable_development = disable_development  # type: bool
        self.is_default = is_default  # type: int
        # The ID of the resource group.
        self.project_description = project_description  # type: str
        # The ID of the user used by the workspace owner.
        self.project_id = project_id  # type: long
        # The description of the workspace.
        self.project_identifier = project_identifier  # type: str
        # The ID of the workspace.
        self.project_name = project_name  # type: str
        # The tags.
        self.project_owner_base_id = project_owner_base_id  # type: str
        # The identifier of the workspace.
        self.project_status = project_status  # type: int
        # The name of the workspace.
        self.project_status_code = project_status_code  # type: str
        # The tag key.
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        self.table_privacy_mode = table_privacy_mode  # type: int
        # The tag value.
        self.tags = tags  # type: list[ListProjectsResponseBodyPageResultProjectListTags]
        # Indicates whether the workspace is a default workspace. Valid values:
        # 
        # *   1: The workspace is a default workspace.
        # *   0: The workspace is not a default workspace.
        self.use_proxy_odps_account = use_proxy_odps_account  # type: bool

    def validate(self):
        if self.tags:
            for k in self.tags:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListProjectsResponseBodyPageResultProjectList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.disable_development is not None:
            result['DisableDevelopment'] = self.disable_development
        if self.is_default is not None:
            result['IsDefault'] = self.is_default
        if self.project_description is not None:
            result['ProjectDescription'] = self.project_description
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.project_owner_base_id is not None:
            result['ProjectOwnerBaseId'] = self.project_owner_base_id
        if self.project_status is not None:
            result['ProjectStatus'] = self.project_status
        if self.project_status_code is not None:
            result['ProjectStatusCode'] = self.project_status_code
        if self.resource_manager_resource_group_id is not None:
            result['ResourceManagerResourceGroupId'] = self.resource_manager_resource_group_id
        if self.table_privacy_mode is not None:
            result['TablePrivacyMode'] = self.table_privacy_mode
        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.use_proxy_odps_account is not None:
            result['UseProxyOdpsAccount'] = self.use_proxy_odps_account
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DisableDevelopment') is not None:
            self.disable_development = m.get('DisableDevelopment')
        if m.get('IsDefault') is not None:
            self.is_default = m.get('IsDefault')
        if m.get('ProjectDescription') is not None:
            self.project_description = m.get('ProjectDescription')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('ProjectOwnerBaseId') is not None:
            self.project_owner_base_id = m.get('ProjectOwnerBaseId')
        if m.get('ProjectStatus') is not None:
            self.project_status = m.get('ProjectStatus')
        if m.get('ProjectStatusCode') is not None:
            self.project_status_code = m.get('ProjectStatusCode')
        if m.get('ResourceManagerResourceGroupId') is not None:
            self.resource_manager_resource_group_id = m.get('ResourceManagerResourceGroupId')
        if m.get('TablePrivacyMode') is not None:
            self.table_privacy_mode = m.get('TablePrivacyMode')
        self.tags = []
        if m.get('Tags') is not None:
            for k in m.get('Tags'):
                temp_model = ListProjectsResponseBodyPageResultProjectListTags()
                self.tags.append(temp_model.from_map(k))
        if m.get('UseProxyOdpsAccount') is not None:
            self.use_proxy_odps_account = m.get('UseProxyOdpsAccount')
        return self


class ListProjectsResponseBodyPageResult(TeaModel):
    def __init__(self, page_number=None, page_size=None, project_list=None, total_count=None):
        # The total number of entries returned.
        self.page_number = page_number  # type: int
        # The DataWorks workspaces returned.
        self.page_size = page_size  # type: int
        # The status of the workspace. Valid values:
        # 
        # *   0: AVAILABLE, which indicates that the workspace is running as expected.
        # *   1: DELETED, which indicates that the workspace is deleted.
        # *   2: INITIALIZING, which indicates that the workspace is being initialized.
        # *   3: INIT_FAILED, which indicates that the workspace fails to be initialized.
        # *   4: FORBIDDEN, which indicates that the workspace is manually disabled.
        # *   5: DELETING, which indicates that the workspace is being deleted.
        # *   6: DEL_FAILED, which indicates that the workspace fails to be deleted.
        # *   7: FROZEN, which indicates that the workspace is frozen due to overdue payments.
        # *   8: UPDATING, which indicates that the workspace is being updated. After you associate a compute engine with the workspace, the system initializes compute engine and updates the workspace.
        # *   9: UPDATE_FAILED, which indicates that the workspace fails to be updated.
        self.project_list = project_list  # type: list[ListProjectsResponseBodyPageResultProjectList]
        # The status code of the workspace. Valid values:
        # 
        # *   AVAILABLE: 0, which indicates that the workspace is running as expected.
        # *   DELETED: 1, which indicates that the workspace is deleted.
        # *   INITIALIZING: 2, which indicates that the workspace is being initialized.
        # *   INIT_FAILED: 3, which indicates that the workspace fails to be initialized.
        # *   FORBIDDEN: 4, which indicates that the workspace is manually disabled.
        # *   DELETING: 5, which indicates that the workspace is being deleted.
        # *   DEL_FAILED: 6, which indicates that the workspace fails to be deleted.
        # *   FROZEN: 7, which indicates that the workspace is frozen due to overdue payments.
        # *   UPDATING: 8, which indicates that the workspace is being updated. After you associate a compute engine with the workspace, the system initializes compute engine and updates the workspace.
        # *   UPDATE_FAILED: 9, which indicates that the workspace fails to be updated.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.project_list:
            for k in self.project_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListProjectsResponseBodyPageResult, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        result['ProjectList'] = []
        if self.project_list is not None:
            for k in self.project_list:
                result['ProjectList'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        self.project_list = []
        if m.get('ProjectList') is not None:
            for k in m.get('ProjectList'):
                temp_model = ListProjectsResponseBodyPageResultProjectList()
                self.project_list.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListProjectsResponseBody(TeaModel):
    def __init__(self, page_result=None, request_id=None):
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_result = page_result  # type: ListProjectsResponseBodyPageResult
        # The page number of the returned page.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.page_result:
            self.page_result.validate()

    def to_map(self):
        _map = super(ListProjectsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_result is not None:
            result['PageResult'] = self.page_result.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageResult') is not None:
            temp_model = ListProjectsResponseBodyPageResult()
            self.page_result = temp_model.from_map(m['PageResult'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListProjectsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListProjectsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListProjectsResponse, self).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=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 = ListProjectsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListQualityResultsByEntityRequest(TeaModel):
    def __init__(self, end_date=None, entity_id=None, page_number=None, page_size=None, project_id=None,
                 project_name=None, start_date=None):
        # The name of the compute engine instance or data source. You can obtain the name from data source configurations.
        self.end_date = end_date  # type: str
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.entity_id = entity_id  # type: int
        # The error message returned.
        self.page_number = page_number  # type: int
        # The HTTP status code returned.
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        # The ID of the request.
        self.project_name = project_name  # type: str
        # The number of the page to return.
        self.start_date = start_date  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListQualityResultsByEntityRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.end_date is not None:
            result['EndDate'] = self.end_date
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.start_date is not None:
            result['StartDate'] = self.start_date
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EndDate') is not None:
            self.end_date = m.get('EndDate')
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('StartDate') is not None:
            self.start_date = m.get('StartDate')
        return self


class ListQualityResultsByEntityResponseBodyDataRuleChecksReferenceValue(TeaModel):
    def __init__(self, biz_date=None, discrete_property=None, single_check_result=None, threshold=None, value=None):
        # The sample values.
        self.biz_date = biz_date  # type: str
        # The monitoring result.
        self.discrete_property = discrete_property  # type: str
        # The values of the sample field that are grouped by using the GROUP BY clause. For example, the values of the Gender field are grouped by using the GROUP BY clause. In this case, the values of DiscreteProperty are Male, Female, and null.
        self.single_check_result = single_check_result  # type: int
        # The data timestamp. If the monitored business entity is offline data, the value is usually one day before the monitoring is performed.
        self.threshold = threshold  # type: float
        # The threshold.
        self.value = value  # type: float

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListQualityResultsByEntityResponseBodyDataRuleChecksReferenceValue, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.discrete_property is not None:
            result['DiscreteProperty'] = self.discrete_property
        if self.single_check_result is not None:
            result['SingleCheckResult'] = self.single_check_result
        if self.threshold is not None:
            result['Threshold'] = self.threshold
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('DiscreteProperty') is not None:
            self.discrete_property = m.get('DiscreteProperty')
        if m.get('SingleCheckResult') is not None:
            self.single_check_result = m.get('SingleCheckResult')
        if m.get('Threshold') is not None:
            self.threshold = m.get('Threshold')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class ListQualityResultsByEntityResponseBodyDataRuleChecksSampleValue(TeaModel):
    def __init__(self, biz_date=None, discrete_property=None, value=None):
        self.biz_date = biz_date  # type: str
        self.discrete_property = discrete_property  # type: str
        self.value = value  # type: float

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListQualityResultsByEntityResponseBodyDataRuleChecksSampleValue, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.discrete_property is not None:
            result['DiscreteProperty'] = self.discrete_property
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('DiscreteProperty') is not None:
            self.discrete_property = m.get('DiscreteProperty')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class ListQualityResultsByEntityResponseBodyDataRuleChecks(TeaModel):
    def __init__(self, actual_expression=None, begin_time=None, biz_date=None, block_type=None, check_result=None,
                 check_result_status=None, checker_id=None, checker_name=None, checker_type=None, comment=None, critical_threshold=None,
                 date_type=None, discrete_check=None, end_time=None, entity_id=None, expect_value=None, external_id=None,
                 external_type=None, fixed_check=None, id=None, is_prediction=None, lower_value=None, match_expression=None,
                 method_name=None, op=None, project_name=None, property=None, reference_value=None, result_string=None,
                 rule_id=None, rule_name=None, sample_value=None, table_name=None, task_id=None, template_id=None,
                 template_name=None, time_cost=None, trend=None, upper_value=None, warning_threshold=None, where_condition=None):
        # The trend of the monitoring result.
        self.actual_expression = actual_expression  # type: str
        # Indicates whether the monitoring result is the same as the predicted result. Valid values:
        # 
        # *   true: indicates that the monitoring result is the same as the predicted result.
        # *   false: indicates that the monitoring result is different from the predicted result.
        self.begin_time = begin_time  # type: long
        # The partition filter expression.
        self.biz_date = biz_date  # type: long
        # The name of the table that is monitored.
        self.block_type = block_type  # type: int
        # The monitoring type. Valid values:
        # 
        # *   1: VOLATILITY_CHECK
        # *   2: FIXEDVALUE_CHECK
        self.check_result = check_result  # type: int
        # The ID of the monitoring rule.
        self.check_result_status = check_result_status  # type: int
        # The method used to collect sample data, such as avg, count, sum, min, max, count_distinct, user_defined, table_count, table_size, table_dt_load_count, table_dt_refuseload_count, null_value, null_value/table_count, (table_count-count_distinct)/table_count, or table_count-count_distinct.
        self.checker_id = checker_id  # type: int
        # The comparison operator.
        self.checker_name = checker_name  # type: str
        # The type of the scheduling cycle. In most cases, the value of this parameter is YMD. This value indicates year, month, and day.
        self.checker_type = checker_type  # type: int
        # The name of the checker.
        self.comment = comment  # type: str
        # The ID of the checker.
        self.critical_threshold = critical_threshold  # type: float
        # The name of the monitoring rule.
        self.date_type = date_type  # type: str
        # The lower limit of the predicted result. The value of this parameter is automatically generated based on the threshold that you specified.
        self.discrete_check = discrete_check  # type: bool
        # The ID of the partition filter expression.
        self.end_time = end_time  # type: long
        # The ID of the monitoring template.
        self.entity_id = entity_id  # type: int
        # The ID of the primary key.
        self.expect_value = expect_value  # type: float
        # The type of the scheduling system. Only CWF scheduling systems are supported.
        self.external_id = external_id  # type: str
        # The string of the monitoring result.
        self.external_type = external_type  # type: str
        # The partition in the monitored data source table.
        self.fixed_check = fixed_check  # type: bool
        # The check value.
        self.id = id  # type: int
        # Indicates whether the monitoring is discrete monitoring. Valid values:
        # 
        # *   true: indicates that the monitoring is discrete monitoring.
        # *   false: indicates that the monitoring is not discrete monitoring.
        self.is_prediction = is_prediction  # type: bool
        # The expected value.
        self.lower_value = lower_value  # type: float
        # The time when the monitoring started.
        self.match_expression = match_expression  # type: str
        # The filter condition of the monitoring rule.
        self.method_name = method_name  # type: str
        # The ID of the node.
        self.op = op  # type: str
        # The threshold for a critical alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements. If a strong rule is used and a critical alert is reported, nodes are blocked.
        self.project_name = project_name  # type: str
        # The check result of the monitoring rule. Valid values:
        # 
        # *   0: indicates that the data source table is normal.
        # *   1: indicates that a warning alert is reported.
        # *   2: indicates that a critical alert is reported.
        self.property = property  # type: str
        # The data timestamp. If the monitored business entity is offline data, the value is usually one day before the monitoring is performed.
        self.reference_value = reference_value  # type: list[ListQualityResultsByEntityResponseBodyDataRuleChecksReferenceValue]
        # The name of the compute engine instance or data source for which data quality is monitored.
        self.result_string = result_string  # type: str
        # The upper limit of the predicted result. The value of this parameter is automatically generated based on the threshold that you specified.
        self.rule_id = rule_id  # type: int
        # The time when the monitoring ended.
        self.rule_name = rule_name  # type: str
        # The current sample value.
        self.sample_value = sample_value  # type: list[ListQualityResultsByEntityResponseBodyDataRuleChecksSampleValue]
        # The name of the monitoring template.
        self.table_name = table_name  # type: str
        # The values of the sample field that are grouped by using the GROUP BY clause. For example, the values of the Gender field are grouped by using the GROUP BY clause. In this case, the values of DiscreteProperty are Male, Female, and null.
        self.task_id = task_id  # type: str
        # The historical sample values.
        self.template_id = template_id  # type: int
        # Indicates whether the monitoring is performed based on a fixed value. Valid values:
        # 
        # *   true: indicates that the monitoring is performed based on a fixed value.
        # *   false: indicates that the monitoring is performed based on a non-fixed value.
        self.template_name = template_name  # type: str
        # The data timestamp. If the monitored business entity is offline data, the value is usually one day before the monitoring is performed.
        self.time_cost = time_cost  # type: str
        # The monitoring result. The value of this parameter is the same as the value of the CheckResultStatus parameter. Valid values:
        # 
        # *   0: indicates that the data source table is normal.
        # *   1: indicates that a warning alert is reported.
        # *   2: indicates that a critical alert is reported.
        self.trend = trend  # type: str
        # The time that was taken to run the monitoring task. Unit: seconds.
        self.upper_value = upper_value  # type: float
        # The description of the monitoring rule.
        self.warning_threshold = warning_threshold  # type: float
        # The ID of the monitoring task.
        self.where_condition = where_condition  # type: str

    def validate(self):
        if self.reference_value:
            for k in self.reference_value:
                if k:
                    k.validate()
        if self.sample_value:
            for k in self.sample_value:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListQualityResultsByEntityResponseBodyDataRuleChecks, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.actual_expression is not None:
            result['ActualExpression'] = self.actual_expression
        if self.begin_time is not None:
            result['BeginTime'] = self.begin_time
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.block_type is not None:
            result['BlockType'] = self.block_type
        if self.check_result is not None:
            result['CheckResult'] = self.check_result
        if self.check_result_status is not None:
            result['CheckResultStatus'] = self.check_result_status
        if self.checker_id is not None:
            result['CheckerId'] = self.checker_id
        if self.checker_name is not None:
            result['CheckerName'] = self.checker_name
        if self.checker_type is not None:
            result['CheckerType'] = self.checker_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.critical_threshold is not None:
            result['CriticalThreshold'] = self.critical_threshold
        if self.date_type is not None:
            result['DateType'] = self.date_type
        if self.discrete_check is not None:
            result['DiscreteCheck'] = self.discrete_check
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.expect_value is not None:
            result['ExpectValue'] = self.expect_value
        if self.external_id is not None:
            result['ExternalId'] = self.external_id
        if self.external_type is not None:
            result['ExternalType'] = self.external_type
        if self.fixed_check is not None:
            result['FixedCheck'] = self.fixed_check
        if self.id is not None:
            result['Id'] = self.id
        if self.is_prediction is not None:
            result['IsPrediction'] = self.is_prediction
        if self.lower_value is not None:
            result['LowerValue'] = self.lower_value
        if self.match_expression is not None:
            result['MatchExpression'] = self.match_expression
        if self.method_name is not None:
            result['MethodName'] = self.method_name
        if self.op is not None:
            result['Op'] = self.op
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.property is not None:
            result['Property'] = self.property
        result['ReferenceValue'] = []
        if self.reference_value is not None:
            for k in self.reference_value:
                result['ReferenceValue'].append(k.to_map() if k else None)
        if self.result_string is not None:
            result['ResultString'] = self.result_string
        if self.rule_id is not None:
            result['RuleId'] = self.rule_id
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        result['SampleValue'] = []
        if self.sample_value is not None:
            for k in self.sample_value:
                result['SampleValue'].append(k.to_map() if k else None)
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        if self.template_id is not None:
            result['TemplateId'] = self.template_id
        if self.template_name is not None:
            result['TemplateName'] = self.template_name
        if self.time_cost is not None:
            result['TimeCost'] = self.time_cost
        if self.trend is not None:
            result['Trend'] = self.trend
        if self.upper_value is not None:
            result['UpperValue'] = self.upper_value
        if self.warning_threshold is not None:
            result['WarningThreshold'] = self.warning_threshold
        if self.where_condition is not None:
            result['WhereCondition'] = self.where_condition
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ActualExpression') is not None:
            self.actual_expression = m.get('ActualExpression')
        if m.get('BeginTime') is not None:
            self.begin_time = m.get('BeginTime')
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('BlockType') is not None:
            self.block_type = m.get('BlockType')
        if m.get('CheckResult') is not None:
            self.check_result = m.get('CheckResult')
        if m.get('CheckResultStatus') is not None:
            self.check_result_status = m.get('CheckResultStatus')
        if m.get('CheckerId') is not None:
            self.checker_id = m.get('CheckerId')
        if m.get('CheckerName') is not None:
            self.checker_name = m.get('CheckerName')
        if m.get('CheckerType') is not None:
            self.checker_type = m.get('CheckerType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CriticalThreshold') is not None:
            self.critical_threshold = m.get('CriticalThreshold')
        if m.get('DateType') is not None:
            self.date_type = m.get('DateType')
        if m.get('DiscreteCheck') is not None:
            self.discrete_check = m.get('DiscreteCheck')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('ExpectValue') is not None:
            self.expect_value = m.get('ExpectValue')
        if m.get('ExternalId') is not None:
            self.external_id = m.get('ExternalId')
        if m.get('ExternalType') is not None:
            self.external_type = m.get('ExternalType')
        if m.get('FixedCheck') is not None:
            self.fixed_check = m.get('FixedCheck')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('IsPrediction') is not None:
            self.is_prediction = m.get('IsPrediction')
        if m.get('LowerValue') is not None:
            self.lower_value = m.get('LowerValue')
        if m.get('MatchExpression') is not None:
            self.match_expression = m.get('MatchExpression')
        if m.get('MethodName') is not None:
            self.method_name = m.get('MethodName')
        if m.get('Op') is not None:
            self.op = m.get('Op')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('Property') is not None:
            self.property = m.get('Property')
        self.reference_value = []
        if m.get('ReferenceValue') is not None:
            for k in m.get('ReferenceValue'):
                temp_model = ListQualityResultsByEntityResponseBodyDataRuleChecksReferenceValue()
                self.reference_value.append(temp_model.from_map(k))
        if m.get('ResultString') is not None:
            self.result_string = m.get('ResultString')
        if m.get('RuleId') is not None:
            self.rule_id = m.get('RuleId')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        self.sample_value = []
        if m.get('SampleValue') is not None:
            for k in m.get('SampleValue'):
                temp_model = ListQualityResultsByEntityResponseBodyDataRuleChecksSampleValue()
                self.sample_value.append(temp_model.from_map(k))
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        if m.get('TemplateId') is not None:
            self.template_id = m.get('TemplateId')
        if m.get('TemplateName') is not None:
            self.template_name = m.get('TemplateName')
        if m.get('TimeCost') is not None:
            self.time_cost = m.get('TimeCost')
        if m.get('Trend') is not None:
            self.trend = m.get('Trend')
        if m.get('UpperValue') is not None:
            self.upper_value = m.get('UpperValue')
        if m.get('WarningThreshold') is not None:
            self.warning_threshold = m.get('WarningThreshold')
        if m.get('WhereCondition') is not None:
            self.where_condition = m.get('WhereCondition')
        return self


class ListQualityResultsByEntityResponseBodyData(TeaModel):
    def __init__(self, page_number=None, page_size=None, rule_checks=None, total_count=None):
        # The monitoring results returned.
        self.page_number = page_number  # type: int
        # The type of the monitoring rule. The type of a monitoring rule indicates the importance of the rule. Valid values:
        # 
        # *   1: indicates that the monitoring rule is a strong rule.
        # 
        # *   0: indicates that the monitoring rule is a weak rule.
        # 
        #     You can specify whether a monitoring rule is a strong rule based on your business requirements. If a strong rule is used and a critical alert is triggered, nodes are blocked.
        self.page_size = page_size  # type: int
        # The field of the rule attribute. This field is the column name of the data source table that is monitored.
        self.rule_checks = rule_checks  # type: list[ListQualityResultsByEntityResponseBodyDataRuleChecks]
        # The threshold for a warning alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.rule_checks:
            for k in self.rule_checks:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListQualityResultsByEntityResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        result['RuleChecks'] = []
        if self.rule_checks is not None:
            for k in self.rule_checks:
                result['RuleChecks'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        self.rule_checks = []
        if m.get('RuleChecks') is not None:
            for k in m.get('RuleChecks'):
                temp_model = ListQualityResultsByEntityResponseBodyDataRuleChecks()
                self.rule_checks.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListQualityResultsByEntityResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The total number of entries returned.
        self.data = data  # type: ListQualityResultsByEntityResponseBodyData
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.error_code = error_code  # type: str
        # The error code returned.
        self.error_message = error_message  # type: str
        # Indicates whether the request is successful.
        self.http_status_code = http_status_code  # type: int
        # The data structure of the monitoring results returned.
        self.request_id = request_id  # type: str
        # The page number of the returned page.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListQualityResultsByEntityResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListQualityResultsByEntityResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListQualityResultsByEntityResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListQualityResultsByEntityResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListQualityResultsByEntityResponse, self).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=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 = ListQualityResultsByEntityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListQualityResultsByRuleRequest(TeaModel):
    def __init__(self, end_date=None, page_number=None, page_size=None, project_id=None, project_name=None,
                 rule_id=None, start_date=None):
        # The end of the time range to query. Specify the time in the yyyy-MM-dd HH:mm:ss format.
        # 
        # This parameter is used together with the StartDate parameter. The interval between the time specified by this parameter and the time specified by the StartDate parameter cannot exceed 7 days.
        self.end_date = end_date  # type: str
        # The number of the page to return.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        # The name of the compute engine instance or data source for which data quality is monitored.
        self.project_name = project_name  # type: str
        # The ID of the monitoring rule. You can use the ID and information such as a partition filter expression to perform a joint query.
        self.rule_id = rule_id  # type: long
        # The beginning of the time range to query. Specify the time in the yyyy-MM-dd HH:mm:ss format.
        # 
        # This parameter is used together with the EndDate parameter. The interval between the time specified by this parameter and the time specified by the EndDate parameter cannot exceed 7 days.
        self.start_date = start_date  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListQualityResultsByRuleRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.end_date is not None:
            result['EndDate'] = self.end_date
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.rule_id is not None:
            result['RuleId'] = self.rule_id
        if self.start_date is not None:
            result['StartDate'] = self.start_date
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EndDate') is not None:
            self.end_date = m.get('EndDate')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('RuleId') is not None:
            self.rule_id = m.get('RuleId')
        if m.get('StartDate') is not None:
            self.start_date = m.get('StartDate')
        return self


class ListQualityResultsByRuleResponseBodyDataRuleChecksReferenceValue(TeaModel):
    def __init__(self, biz_date=None, discrete_property=None, single_check_result=None, threshold=None, value=None):
        # The date on which the business was performed. If the monitored business entity is offline data, the value is usually one day before the monitoring is performed.
        self.biz_date = biz_date  # type: str
        # The values of the sample field that are grouped by using the GROUP BY clause. For example, the values of the Gender field are grouped by using the GROUP BY clause. In this case, the values of DiscreteProperty are Male, Female, and null.
        self.discrete_property = discrete_property  # type: str
        # The string of the monitoring result.
        self.single_check_result = single_check_result  # type: int
        # The threshold.
        self.threshold = threshold  # type: float
        # The sample value.
        self.value = value  # type: float

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListQualityResultsByRuleResponseBodyDataRuleChecksReferenceValue, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.discrete_property is not None:
            result['DiscreteProperty'] = self.discrete_property
        if self.single_check_result is not None:
            result['SingleCheckResult'] = self.single_check_result
        if self.threshold is not None:
            result['Threshold'] = self.threshold
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('DiscreteProperty') is not None:
            self.discrete_property = m.get('DiscreteProperty')
        if m.get('SingleCheckResult') is not None:
            self.single_check_result = m.get('SingleCheckResult')
        if m.get('Threshold') is not None:
            self.threshold = m.get('Threshold')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class ListQualityResultsByRuleResponseBodyDataRuleChecksSampleValue(TeaModel):
    def __init__(self, biz_date=None, discrete_property=None, value=None):
        # The date on which the business was performed. If the monitored business entity is offline data, the value is usually one day before the monitoring is performed.
        self.biz_date = biz_date  # type: str
        # The values of the sample field that are grouped by using the GROUP BY clause. For example, the values of the Gender field are grouped by using the GROUP BY clause. In this case, the values of DiscreteProperty are Male, Female, and null.
        self.discrete_property = discrete_property  # type: str
        # The sample value.
        self.value = value  # type: float

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListQualityResultsByRuleResponseBodyDataRuleChecksSampleValue, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.discrete_property is not None:
            result['DiscreteProperty'] = self.discrete_property
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('DiscreteProperty') is not None:
            self.discrete_property = m.get('DiscreteProperty')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class ListQualityResultsByRuleResponseBodyDataRuleChecks(TeaModel):
    def __init__(self, actual_expression=None, begin_time=None, biz_date=None, block_type=None, check_result=None,
                 check_result_status=None, checker_id=None, checker_name=None, checker_type=None, comment=None, critical_threshold=None,
                 date_type=None, discrete_check=None, end_time=None, entity_id=None, expect_value=None, external_id=None,
                 external_type=None, fixed_check=None, id=None, is_prediction=None, lower_value=None, match_expression=None,
                 method_name=None, op=None, open=None, project_name=None, property=None, reference_value=None,
                 result_string=None, rule_id=None, rule_name=None, sample_value=None, table_name=None, task_id=None,
                 template_id=None, template_name=None, time_cost=None, trend=None, upper_value=None, warning_threshold=None,
                 where_condition=None):
        # The partition in the monitored data source table.
        self.actual_expression = actual_expression  # type: str
        # The time when the monitoring started.
        self.begin_time = begin_time  # type: long
        # The date on which the business was performed. If the monitored business entity is offline data, the value is usually one day before the monitoring is performed.
        self.biz_date = biz_date  # type: long
        # The type of the monitoring rule. The type of a monitoring rule indicates the importance of the rule. Valid values:
        # 
        # *   1: indicates that the monitoring rule is a strong rule.
        # 
        # *   0: indicates that the monitoring rule is a weak rule.
        # 
        #     You can specify whether a monitoring rule is a strong rule based on your business requirements. If a strong rule is used and a critical alert is reported, nodes are blocked.
        self.block_type = block_type  # type: int
        # The monitoring result.
        self.check_result = check_result  # type: int
        # The status of the monitoring result.
        self.check_result_status = check_result_status  # type: int
        # The ID of the checker.
        self.checker_id = checker_id  # type: int
        # The name of the checker.
        self.checker_name = checker_name  # type: str
        # The type of the checker.
        self.checker_type = checker_type  # type: int
        # The description of the monitoring rule.
        self.comment = comment  # type: str
        # The threshold for a critical alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements. If a strong rule is used and a critical alert is reported, nodes are blocked.
        self.critical_threshold = critical_threshold  # type: float
        # The type of the scheduling cycle. In most cases, the value of this parameter is YMD. This value indicates year, month, and day.
        self.date_type = date_type  # type: str
        # Indicates whether the monitoring is discrete monitoring. Valid values:
        # 
        # *   true: indicates that the monitoring is discrete monitoring.
        # *   false: indicates that the monitoring is not discrete monitoring.
        self.discrete_check = discrete_check  # type: bool
        # The time when the monitoring ended.
        self.end_time = end_time  # type: long
        # The ID of the partition filter expression.
        self.entity_id = entity_id  # type: long
        # The expected value.
        self.expect_value = expect_value  # type: float
        # The ID of the node.
        self.external_id = external_id  # type: str
        # The type of the scheduling system. Only CWF scheduling systems are supported.
        self.external_type = external_type  # type: str
        # Indicates whether the monitoring is performed based on a fixed value. Valid values:
        # 
        # *   true: indicates that the monitoring is performed based on a fixed value.
        # *   false: indicates that the monitoring is performed based on a non-fixed value.
        self.fixed_check = fixed_check  # type: bool
        # The ID of the primary key.
        self.id = id  # type: long
        # Indicates whether the monitoring result is the same as the predicted result. Valid values:
        # 
        # *   true: indicates that the monitoring result is the same as the predicted result.
        # *   false: indicates that the monitoring result is different from the predicted result.
        self.is_prediction = is_prediction  # type: bool
        # The lower limit of the predicted result. The value of this parameter is automatically generated based on the threshold that you specified.
        self.lower_value = lower_value  # type: float
        # The partition filter expression.
        self.match_expression = match_expression  # type: str
        # The method used to collect sample data, such as avg, count, sum, min, max, count_distinct, user_defined, table_count, table_size, table_dt_load_count, table_dt_refuseload_count, null_value, null_value/table_count, (table_count-count_distinct)/table_count, or table_count-count_distinct.
        self.method_name = method_name  # type: str
        # The comparison operator.
        self.op = op  # type: str
        self.open = open  # type: bool
        # The name of the compute engine instance or data source for which data quality is monitored.
        self.project_name = project_name  # type: str
        # The field of the rule attribute. This field is the column name of the data source table that is monitored.
        self.property = property  # type: str
        # The historical sample values.
        self.reference_value = reference_value  # type: list[ListQualityResultsByRuleResponseBodyDataRuleChecksReferenceValue]
        # The string of the monitoring result.
        self.result_string = result_string  # type: str
        # The ID of the monitoring rule.
        self.rule_id = rule_id  # type: long
        # The name of the monitoring rule.
        self.rule_name = rule_name  # type: str
        # The sample values.
        self.sample_value = sample_value  # type: list[ListQualityResultsByRuleResponseBodyDataRuleChecksSampleValue]
        # The name of the table that is monitored.
        self.table_name = table_name  # type: str
        # The ID of the monitoring task.
        self.task_id = task_id  # type: str
        # The ID of the monitoring template.
        self.template_id = template_id  # type: int
        # The name of the monitoring template.
        self.template_name = template_name  # type: str
        # The time that was taken to run the monitoring task.
        self.time_cost = time_cost  # type: str
        # The trend of the monitoring result.
        self.trend = trend  # type: str
        # The upper limit of the predicted result. The value of this parameter is automatically generated based on the threshold that you specified.
        self.upper_value = upper_value  # type: float
        # The threshold for a warning alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements.
        self.warning_threshold = warning_threshold  # type: float
        # The filter condition of the monitoring rule.
        self.where_condition = where_condition  # type: str

    def validate(self):
        if self.reference_value:
            for k in self.reference_value:
                if k:
                    k.validate()
        if self.sample_value:
            for k in self.sample_value:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListQualityResultsByRuleResponseBodyDataRuleChecks, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.actual_expression is not None:
            result['ActualExpression'] = self.actual_expression
        if self.begin_time is not None:
            result['BeginTime'] = self.begin_time
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.block_type is not None:
            result['BlockType'] = self.block_type
        if self.check_result is not None:
            result['CheckResult'] = self.check_result
        if self.check_result_status is not None:
            result['CheckResultStatus'] = self.check_result_status
        if self.checker_id is not None:
            result['CheckerId'] = self.checker_id
        if self.checker_name is not None:
            result['CheckerName'] = self.checker_name
        if self.checker_type is not None:
            result['CheckerType'] = self.checker_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.critical_threshold is not None:
            result['CriticalThreshold'] = self.critical_threshold
        if self.date_type is not None:
            result['DateType'] = self.date_type
        if self.discrete_check is not None:
            result['DiscreteCheck'] = self.discrete_check
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.expect_value is not None:
            result['ExpectValue'] = self.expect_value
        if self.external_id is not None:
            result['ExternalId'] = self.external_id
        if self.external_type is not None:
            result['ExternalType'] = self.external_type
        if self.fixed_check is not None:
            result['FixedCheck'] = self.fixed_check
        if self.id is not None:
            result['Id'] = self.id
        if self.is_prediction is not None:
            result['IsPrediction'] = self.is_prediction
        if self.lower_value is not None:
            result['LowerValue'] = self.lower_value
        if self.match_expression is not None:
            result['MatchExpression'] = self.match_expression
        if self.method_name is not None:
            result['MethodName'] = self.method_name
        if self.op is not None:
            result['Op'] = self.op
        if self.open is not None:
            result['Open'] = self.open
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.property is not None:
            result['Property'] = self.property
        result['ReferenceValue'] = []
        if self.reference_value is not None:
            for k in self.reference_value:
                result['ReferenceValue'].append(k.to_map() if k else None)
        if self.result_string is not None:
            result['ResultString'] = self.result_string
        if self.rule_id is not None:
            result['RuleId'] = self.rule_id
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        result['SampleValue'] = []
        if self.sample_value is not None:
            for k in self.sample_value:
                result['SampleValue'].append(k.to_map() if k else None)
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        if self.template_id is not None:
            result['TemplateId'] = self.template_id
        if self.template_name is not None:
            result['TemplateName'] = self.template_name
        if self.time_cost is not None:
            result['TimeCost'] = self.time_cost
        if self.trend is not None:
            result['Trend'] = self.trend
        if self.upper_value is not None:
            result['UpperValue'] = self.upper_value
        if self.warning_threshold is not None:
            result['WarningThreshold'] = self.warning_threshold
        if self.where_condition is not None:
            result['WhereCondition'] = self.where_condition
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ActualExpression') is not None:
            self.actual_expression = m.get('ActualExpression')
        if m.get('BeginTime') is not None:
            self.begin_time = m.get('BeginTime')
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('BlockType') is not None:
            self.block_type = m.get('BlockType')
        if m.get('CheckResult') is not None:
            self.check_result = m.get('CheckResult')
        if m.get('CheckResultStatus') is not None:
            self.check_result_status = m.get('CheckResultStatus')
        if m.get('CheckerId') is not None:
            self.checker_id = m.get('CheckerId')
        if m.get('CheckerName') is not None:
            self.checker_name = m.get('CheckerName')
        if m.get('CheckerType') is not None:
            self.checker_type = m.get('CheckerType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CriticalThreshold') is not None:
            self.critical_threshold = m.get('CriticalThreshold')
        if m.get('DateType') is not None:
            self.date_type = m.get('DateType')
        if m.get('DiscreteCheck') is not None:
            self.discrete_check = m.get('DiscreteCheck')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('ExpectValue') is not None:
            self.expect_value = m.get('ExpectValue')
        if m.get('ExternalId') is not None:
            self.external_id = m.get('ExternalId')
        if m.get('ExternalType') is not None:
            self.external_type = m.get('ExternalType')
        if m.get('FixedCheck') is not None:
            self.fixed_check = m.get('FixedCheck')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('IsPrediction') is not None:
            self.is_prediction = m.get('IsPrediction')
        if m.get('LowerValue') is not None:
            self.lower_value = m.get('LowerValue')
        if m.get('MatchExpression') is not None:
            self.match_expression = m.get('MatchExpression')
        if m.get('MethodName') is not None:
            self.method_name = m.get('MethodName')
        if m.get('Op') is not None:
            self.op = m.get('Op')
        if m.get('Open') is not None:
            self.open = m.get('Open')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('Property') is not None:
            self.property = m.get('Property')
        self.reference_value = []
        if m.get('ReferenceValue') is not None:
            for k in m.get('ReferenceValue'):
                temp_model = ListQualityResultsByRuleResponseBodyDataRuleChecksReferenceValue()
                self.reference_value.append(temp_model.from_map(k))
        if m.get('ResultString') is not None:
            self.result_string = m.get('ResultString')
        if m.get('RuleId') is not None:
            self.rule_id = m.get('RuleId')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        self.sample_value = []
        if m.get('SampleValue') is not None:
            for k in m.get('SampleValue'):
                temp_model = ListQualityResultsByRuleResponseBodyDataRuleChecksSampleValue()
                self.sample_value.append(temp_model.from_map(k))
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        if m.get('TemplateId') is not None:
            self.template_id = m.get('TemplateId')
        if m.get('TemplateName') is not None:
            self.template_name = m.get('TemplateName')
        if m.get('TimeCost') is not None:
            self.time_cost = m.get('TimeCost')
        if m.get('Trend') is not None:
            self.trend = m.get('Trend')
        if m.get('UpperValue') is not None:
            self.upper_value = m.get('UpperValue')
        if m.get('WarningThreshold') is not None:
            self.warning_threshold = m.get('WarningThreshold')
        if m.get('WhereCondition') is not None:
            self.where_condition = m.get('WhereCondition')
        return self


class ListQualityResultsByRuleResponseBodyData(TeaModel):
    def __init__(self, page_number=None, page_size=None, rule_checks=None, total_count=None):
        # The page number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The monitoring results returned.
        self.rule_checks = rule_checks  # type: list[ListQualityResultsByRuleResponseBodyDataRuleChecks]
        # The total number of entries returned.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.rule_checks:
            for k in self.rule_checks:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListQualityResultsByRuleResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        result['RuleChecks'] = []
        if self.rule_checks is not None:
            for k in self.rule_checks:
                result['RuleChecks'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        self.rule_checks = []
        if m.get('RuleChecks') is not None:
            for k in m.get('RuleChecks'):
                temp_model = ListQualityResultsByRuleResponseBodyDataRuleChecks()
                self.rule_checks.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListQualityResultsByRuleResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The data structure of the monitoring results returned.
        self.data = data  # type: ListQualityResultsByRuleResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListQualityResultsByRuleResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListQualityResultsByRuleResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListQualityResultsByRuleResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListQualityResultsByRuleResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListQualityResultsByRuleResponse, self).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=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 = ListQualityResultsByRuleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListQualityRulesRequest(TeaModel):
    def __init__(self, entity_id=None, page_number=None, page_size=None, project_id=None, project_name=None):
        # The ID of the partition filter expression. You can call the [GetQualityEntity](~~174003~~) operation to query the ID of the partition filter expression.
        self.entity_id = entity_id  # type: long
        # The number of the page to return.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 20.
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        # The name of the compute engine instance or data source. You can obtain the name from data source configurations.
        self.project_name = project_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListQualityRulesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class ListQualityRulesResponseBodyDataRules(TeaModel):
    def __init__(self, block_type=None, checker_id=None, comment=None, critical_threshold=None, entity_id=None,
                 expect_value=None, fix_check=None, history_critical_threshold=None, history_warning_threshold=None, id=None,
                 match_expression=None, method_id=None, method_name=None, on_duty=None, on_duty_account_name=None, project_name=None,
                 property=None, property_key=None, rule_checker_relation_id=None, rule_name=None, rule_type=None,
                 table_name=None, template_id=None, template_name=None, trend=None, warning_threshold=None):
        # The strength of the monitoring rule. The strength of a monitoring rule indicates the importance of the rule. Valid values:
        # 
        # *   1: The monitoring rule is a strong rule.
        # 
        # *   0: The monitoring rule is a weak rule.
        # 
        #     You can specify whether a monitoring rule is a strong rule based on your business requirements. If a strong rule is used and a critical alert is reported, nodes are blocked.
        self.block_type = block_type  # type: int
        # The ID of the checker.
        self.checker_id = checker_id  # type: int
        # The description of the monitoring rule.
        self.comment = comment  # type: str
        # The threshold for a critical alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements. If a strong rule is used and a critical alert is reported, nodes are blocked.
        self.critical_threshold = critical_threshold  # type: str
        # The ID of the partition filter expression.
        self.entity_id = entity_id  # type: int
        # The expected value.
        self.expect_value = expect_value  # type: str
        # Indicates whether the monitoring is performed based on a fixed value.
        self.fix_check = fix_check  # type: bool
        # The historical threshold for a critical alert.
        self.history_critical_threshold = history_critical_threshold  # type: str
        # The historical threshold for a warning alert.
        self.history_warning_threshold = history_warning_threshold  # type: str
        # The ID of the monitoring rule.
        self.id = id  # type: int
        # The partition filter expression.
        self.match_expression = match_expression  # type: str
        # The ID of the sampling method of the monitoring rule.
        self.method_id = method_id  # type: int
        # The name of the method that is used to collect sample data, such as avg, count, sum, min, max, count_distinct, user_defined, table_count, table_size, table_dt_load_count, table_dt_refuseload_count, null_value, null_value/table_count, (table_count-count_distinct)/table_count, or table_count-count_distinct.
        self.method_name = method_name  # type: str
        # The ID of the Alibaba Cloud account that is used to configure the monitoring rule.
        self.on_duty = on_duty  # type: str
        # The name of the Alibaba Cloud account that is used to configure the monitoring rule.
        self.on_duty_account_name = on_duty_account_name  # type: str
        # The name of the compute engine instance or data source.
        self.project_name = project_name  # type: str
        # The name of the monitored field.
        self.property = property  # type: str
        # The field that is used to associate with monitoring rules at the frontend. This parameter can be ignored.
        self.property_key = property_key  # type: str
        # The ID of the node that is associated with the partition filter expression.
        self.rule_checker_relation_id = rule_checker_relation_id  # type: int
        # The name of the monitoring rule.
        self.rule_name = rule_name  # type: str
        # The type of the monitoring rule. Valid values:
        # 
        # *   0: The monitoring rule is created by the system.
        # *   1: The monitoring rule is created by a user.
        # *   2: The monitoring rule is a workspace-level rule.
        self.rule_type = rule_type  # type: int
        # The name of the table.
        self.table_name = table_name  # type: str
        # The ID of the monitoring template.
        self.template_id = template_id  # type: int
        # The name of the monitoring template.
        self.template_name = template_name  # type: str
        # The trend of the monitoring results.
        self.trend = trend  # type: str
        # The threshold for a warning alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements.
        self.warning_threshold = warning_threshold  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListQualityRulesResponseBodyDataRules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.block_type is not None:
            result['BlockType'] = self.block_type
        if self.checker_id is not None:
            result['CheckerId'] = self.checker_id
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.critical_threshold is not None:
            result['CriticalThreshold'] = self.critical_threshold
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.expect_value is not None:
            result['ExpectValue'] = self.expect_value
        if self.fix_check is not None:
            result['FixCheck'] = self.fix_check
        if self.history_critical_threshold is not None:
            result['HistoryCriticalThreshold'] = self.history_critical_threshold
        if self.history_warning_threshold is not None:
            result['HistoryWarningThreshold'] = self.history_warning_threshold
        if self.id is not None:
            result['Id'] = self.id
        if self.match_expression is not None:
            result['MatchExpression'] = self.match_expression
        if self.method_id is not None:
            result['MethodId'] = self.method_id
        if self.method_name is not None:
            result['MethodName'] = self.method_name
        if self.on_duty is not None:
            result['OnDuty'] = self.on_duty
        if self.on_duty_account_name is not None:
            result['OnDutyAccountName'] = self.on_duty_account_name
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.property is not None:
            result['Property'] = self.property
        if self.property_key is not None:
            result['PropertyKey'] = self.property_key
        if self.rule_checker_relation_id is not None:
            result['RuleCheckerRelationId'] = self.rule_checker_relation_id
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        if self.rule_type is not None:
            result['RuleType'] = self.rule_type
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.template_id is not None:
            result['TemplateId'] = self.template_id
        if self.template_name is not None:
            result['TemplateName'] = self.template_name
        if self.trend is not None:
            result['Trend'] = self.trend
        if self.warning_threshold is not None:
            result['WarningThreshold'] = self.warning_threshold
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BlockType') is not None:
            self.block_type = m.get('BlockType')
        if m.get('CheckerId') is not None:
            self.checker_id = m.get('CheckerId')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CriticalThreshold') is not None:
            self.critical_threshold = m.get('CriticalThreshold')
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('ExpectValue') is not None:
            self.expect_value = m.get('ExpectValue')
        if m.get('FixCheck') is not None:
            self.fix_check = m.get('FixCheck')
        if m.get('HistoryCriticalThreshold') is not None:
            self.history_critical_threshold = m.get('HistoryCriticalThreshold')
        if m.get('HistoryWarningThreshold') is not None:
            self.history_warning_threshold = m.get('HistoryWarningThreshold')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('MatchExpression') is not None:
            self.match_expression = m.get('MatchExpression')
        if m.get('MethodId') is not None:
            self.method_id = m.get('MethodId')
        if m.get('MethodName') is not None:
            self.method_name = m.get('MethodName')
        if m.get('OnDuty') is not None:
            self.on_duty = m.get('OnDuty')
        if m.get('OnDutyAccountName') is not None:
            self.on_duty_account_name = m.get('OnDutyAccountName')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('Property') is not None:
            self.property = m.get('Property')
        if m.get('PropertyKey') is not None:
            self.property_key = m.get('PropertyKey')
        if m.get('RuleCheckerRelationId') is not None:
            self.rule_checker_relation_id = m.get('RuleCheckerRelationId')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        if m.get('RuleType') is not None:
            self.rule_type = m.get('RuleType')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('TemplateId') is not None:
            self.template_id = m.get('TemplateId')
        if m.get('TemplateName') is not None:
            self.template_name = m.get('TemplateName')
        if m.get('Trend') is not None:
            self.trend = m.get('Trend')
        if m.get('WarningThreshold') is not None:
            self.warning_threshold = m.get('WarningThreshold')
        return self


class ListQualityRulesResponseBodyData(TeaModel):
    def __init__(self, page_number=None, page_size=None, rules=None, total_count=None):
        # The page number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The details of the monitoring rules.
        self.rules = rules  # type: list[ListQualityRulesResponseBodyDataRules]
        # The total number of returned entries.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.rules:
            for k in self.rules:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListQualityRulesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        result['Rules'] = []
        if self.rules is not None:
            for k in self.rules:
                result['Rules'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        self.rules = []
        if m.get('Rules') is not None:
            for k in m.get('Rules'):
                temp_model = ListQualityRulesResponseBodyDataRules()
                self.rules.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListQualityRulesResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The list of monitoring rules.
        self.data = data  # type: ListQualityRulesResponseBodyData
        # The error code.
        self.error_code = error_code  # type: str
        # The error message.
        self.error_message = error_message  # type: str
        # The HTTP status code.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot errors.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListQualityRulesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListQualityRulesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListQualityRulesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListQualityRulesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListQualityRulesResponse, self).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=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 = ListQualityRulesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListRefDISyncTasksRequest(TeaModel):
    def __init__(self, datasource_name=None, page_number=None, page_size=None, project_id=None, ref_type=None,
                 task_type=None):
        # The name of the data source. You can call the [ListDataSources](~~211431~~) operation to query the name of the data source.
        self.datasource_name = datasource_name  # type: str
        # The number of the page to return.
        self.page_number = page_number  # type: long
        # The number of entries to return on each page.
        self.page_size = page_size  # type: long
        # The ID of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace ID.
        self.project_id = project_id  # type: long
        # The condition used to filter sync nodes. Valid values:
        # 
        # *   from: queries the sync nodes that use the data source as the source data source.
        # *   to: queries the sync nodes that use the data source as the destination data source.
        self.ref_type = ref_type  # type: str
        # The type of the sync node that you want to query. Valid values:
        # 
        # *   DI_OFFLINE: batch sync node
        # *   DI_REALTIME: real-time sync node
        # 
        # You can specify only one type. The sync solution type is not supported.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListRefDISyncTasksRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.datasource_name is not None:
            result['DatasourceName'] = self.datasource_name
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.ref_type is not None:
            result['RefType'] = self.ref_type
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DatasourceName') is not None:
            self.datasource_name = m.get('DatasourceName')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RefType') is not None:
            self.ref_type = m.get('RefType')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class ListRefDISyncTasksResponseBodyDataDISyncTasks(TeaModel):
    def __init__(self, di_destination_datasource=None, di_source_datasource=None, node_id=None, node_name=None,
                 task_type=None):
        # The destination data source of the sync node.
        # 
        # If the sync node has multiple destination data sources, the return value is a JSON array, such as \\"odps_writer\\", \\"mysql\\".
        # 
        # If the RefType parameter is set to to, the sync nodes that use the specified data source as the destination data source are returned. In this case, the value of this parameter indicates the specified data source.
        self.di_destination_datasource = di_destination_datasource  # type: str
        # The source data source of the sync node.
        # 
        # If the sync node has multiple source data sources, the return value is a JSON array, such as \\"odps_writer\\", \\"mysql\\".
        # 
        # If the RefType parameter is set to from, the sync nodes that use the specified data source as the source data source are returned. In this case, the value of this parameter indicates the specified data source.
        self.di_source_datasource = di_source_datasource  # type: str
        # The ID of the sync node.
        self.node_id = node_id  # type: long
        # The name of the sync node.
        self.node_name = node_name  # type: str
        # The type of the sync node. Valid values:
        # 
        # *   DI_OFFLINE: batch sync node
        # *   DI_REALTIME: real-time sync node
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListRefDISyncTasksResponseBodyDataDISyncTasks, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.di_destination_datasource is not None:
            result['DiDestinationDatasource'] = self.di_destination_datasource
        if self.di_source_datasource is not None:
            result['DiSourceDatasource'] = self.di_source_datasource
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DiDestinationDatasource') is not None:
            self.di_destination_datasource = m.get('DiDestinationDatasource')
        if m.get('DiSourceDatasource') is not None:
            self.di_source_datasource = m.get('DiSourceDatasource')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class ListRefDISyncTasksResponseBodyData(TeaModel):
    def __init__(self, disync_tasks=None):
        # The details of the sync nodes.
        # 
        # A data source is usually associated with multiple sync nodes. Therefore, the value of this parameter is an array. The following parameters are the elements in the array. The sample values of these parameters show the details of a sync node.
        self.disync_tasks = disync_tasks  # type: list[ListRefDISyncTasksResponseBodyDataDISyncTasks]

    def validate(self):
        if self.disync_tasks:
            for k in self.disync_tasks:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListRefDISyncTasksResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DISyncTasks'] = []
        if self.disync_tasks is not None:
            for k in self.disync_tasks:
                result['DISyncTasks'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.disync_tasks = []
        if m.get('DISyncTasks') is not None:
            for k in m.get('DISyncTasks'):
                temp_model = ListRefDISyncTasksResponseBodyDataDISyncTasks()
                self.disync_tasks.append(temp_model.from_map(k))
        return self


class ListRefDISyncTasksResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # The data returned for the query.
        self.data = data  # type: ListRefDISyncTasksResponseBodyData
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListRefDISyncTasksResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListRefDISyncTasksResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListRefDISyncTasksResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListRefDISyncTasksResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListRefDISyncTasksResponse, self).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=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 = ListRefDISyncTasksResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListRemindsRequest(TeaModel):
    def __init__(self, alert_target=None, founder=None, node_id=None, page_number=None, page_size=None,
                 remind_types=None, search_text=None):
        # The ID of the Alibaba Cloud account that is used to receive alert notifications.
        self.alert_target = alert_target  # type: str
        # The ID of the Alibaba Cloud account that is used to create the custom alert rules.
        self.founder = founder  # type: str
        # The ID of the node to which the custom alert rules are applied. You can use the ID to search for the custom alert rules that are applied to the node.
        self.node_id = node_id  # type: long
        # The number of the page to return. Valid values: 1 to 30. Default value: 1.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The conditions that trigger an alert for the node. Valid values: FINISHED, UNFINISHED, ERROR, CYCLE_UNFINISHED, and TIMEOUT. The value FINISHED indicates that the node finishes running. The value UNFINISHED indicates that the node is still running at the specified point in time. The value ERROR indicates that an error occurs when the node is running. The value CYCLE_UNFINISHED indicates that the node does not finish running in the specified scheduling cycle. The value TIMEOUT indicates that the node times out. You can specify multiple conditions for a custom alert rule. If you specify multiple condition, separate them with commas (,).
        self.remind_types = remind_types  # type: str
        # The keyword in a rule name that is used to search for the rule. Fuzzy search is supported.
        self.search_text = search_text  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListRemindsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_target is not None:
            result['AlertTarget'] = self.alert_target
        if self.founder is not None:
            result['Founder'] = self.founder
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.remind_types is not None:
            result['RemindTypes'] = self.remind_types
        if self.search_text is not None:
            result['SearchText'] = self.search_text
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertTarget') is not None:
            self.alert_target = m.get('AlertTarget')
        if m.get('Founder') is not None:
            self.founder = m.get('Founder')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('RemindTypes') is not None:
            self.remind_types = m.get('RemindTypes')
        if m.get('SearchText') is not None:
            self.search_text = m.get('SearchText')
        return self


class ListRemindsResponseBodyDataReminds(TeaModel):
    def __init__(self, alert_methods=None, alert_targets=None, alert_unit=None, baseline_ids=None,
                 biz_process_ids=None, dnd_end=None, dnd_start=None, founder=None, node_ids=None, project_ids=None, remind_id=None,
                 remind_name=None, remind_type=None, remind_unit=None, useflag=None):
        # The notification method. Valid values: MAIL, SMS, and PHONE. The value MAIL indicates that the notification is sent by email. The value SMS indicates that the notification is sent by text message. The value PHONE indicates that the notification is sent by call, which is supported only by DataWorks Professional Edition and more advanced editions.
        self.alert_methods = alert_methods  # type: list[str]
        # The IDs of the Alibaba Cloud accounts that are used to receive alert notifications.
        self.alert_targets = alert_targets  # type: list[str]
        # The alert recipient. Valid values: OWNER and OTHER. The value OWNER indicates the node owner. The value OTHER indicates a specified user.
        self.alert_unit = alert_unit  # type: str
        # The IDs of the baselines to which the custom alert rule is applied. This parameter is returned if the value of the RemindUnit parameter is BASELINE.
        self.baseline_ids = baseline_ids  # type: list[long]
        # The IDs of the workflows to which the custom alert rule is applied. This parameter is returned if the value of the RemindUnit parameter is BIZPROCESS.
        self.biz_process_ids = biz_process_ids  # type: list[long]
        # The end time of the quiet hours. The value is in the hh:mm format. Valid values of hh: 0 to 23. Valid values of mm: 0 to 59.
        self.dnd_end = dnd_end  # type: str
        # The start time of the quiet hours. The value is in the hh:mm format. Valid values of hh: 0 to 23. Valid values of mm: 0 to 59.
        self.dnd_start = dnd_start  # type: str
        # The ID of the Alibaba Cloud account that is used to create the custom alert rule.
        self.founder = founder  # type: str
        # The IDs of the nodes to which the custom alert rule is applied. This parameter is returned if the value of the RemindUnit parameter is NODE.
        self.node_ids = node_ids  # type: list[long]
        # The IDs of the workspaces to which the custom alert rule is applied. This parameter is returned if the value of the RemindUnit parameter is PROJECT.
        self.project_ids = project_ids  # type: list[long]
        # The ID of the custom alert rule.
        self.remind_id = remind_id  # type: long
        # The name of the custom alert rule.
        self.remind_name = remind_name  # type: str
        # The conditions that trigger an alert for the node. Valid values: FINISHED, UNFINISHED, ERROR, CYCLE_UNFINISHED, and TIMEOUT. The value FINISHED indicates that the node finishes running. The value UNFINISHED indicates that the node is still running at the specified point in time. The value ERROR indicates that an error occurs when the node is running. The value CYCLE_UNFINISHED indicates that the node does not finish running in the specified scheduling cycle. The value TIMEOUT indicates that the node times out.
        self.remind_type = remind_type  # type: str
        # The type of the object to which the custom alert rule is applied. Valid values: NODE, BASELINE, PROJECT, and BIZPROCESS. The value NODE indicates that the monitored object is a node. The value BASELINE indicates that the monitored object is a baseline. The value PROJECT indicates that the monitored object is a workspace. The value BIZPROCESS indicates that the monitored object is a workflow.
        self.remind_unit = remind_unit  # type: str
        # Indicates whether the custom alert rule is enabled. Valid values: true and false.
        self.useflag = useflag  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListRemindsResponseBodyDataReminds, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_methods is not None:
            result['AlertMethods'] = self.alert_methods
        if self.alert_targets is not None:
            result['AlertTargets'] = self.alert_targets
        if self.alert_unit is not None:
            result['AlertUnit'] = self.alert_unit
        if self.baseline_ids is not None:
            result['BaselineIds'] = self.baseline_ids
        if self.biz_process_ids is not None:
            result['BizProcessIds'] = self.biz_process_ids
        if self.dnd_end is not None:
            result['DndEnd'] = self.dnd_end
        if self.dnd_start is not None:
            result['DndStart'] = self.dnd_start
        if self.founder is not None:
            result['Founder'] = self.founder
        if self.node_ids is not None:
            result['NodeIds'] = self.node_ids
        if self.project_ids is not None:
            result['ProjectIds'] = self.project_ids
        if self.remind_id is not None:
            result['RemindId'] = self.remind_id
        if self.remind_name is not None:
            result['RemindName'] = self.remind_name
        if self.remind_type is not None:
            result['RemindType'] = self.remind_type
        if self.remind_unit is not None:
            result['RemindUnit'] = self.remind_unit
        if self.useflag is not None:
            result['Useflag'] = self.useflag
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertMethods') is not None:
            self.alert_methods = m.get('AlertMethods')
        if m.get('AlertTargets') is not None:
            self.alert_targets = m.get('AlertTargets')
        if m.get('AlertUnit') is not None:
            self.alert_unit = m.get('AlertUnit')
        if m.get('BaselineIds') is not None:
            self.baseline_ids = m.get('BaselineIds')
        if m.get('BizProcessIds') is not None:
            self.biz_process_ids = m.get('BizProcessIds')
        if m.get('DndEnd') is not None:
            self.dnd_end = m.get('DndEnd')
        if m.get('DndStart') is not None:
            self.dnd_start = m.get('DndStart')
        if m.get('Founder') is not None:
            self.founder = m.get('Founder')
        if m.get('NodeIds') is not None:
            self.node_ids = m.get('NodeIds')
        if m.get('ProjectIds') is not None:
            self.project_ids = m.get('ProjectIds')
        if m.get('RemindId') is not None:
            self.remind_id = m.get('RemindId')
        if m.get('RemindName') is not None:
            self.remind_name = m.get('RemindName')
        if m.get('RemindType') is not None:
            self.remind_type = m.get('RemindType')
        if m.get('RemindUnit') is not None:
            self.remind_unit = m.get('RemindUnit')
        if m.get('Useflag') is not None:
            self.useflag = m.get('Useflag')
        return self


class ListRemindsResponseBodyData(TeaModel):
    def __init__(self, page_number=None, page_size=None, reminds=None, total_count=None):
        # The page number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries returned per page.
        self.page_size = page_size  # type: int
        # The custom alert rules returned.
        self.reminds = reminds  # type: list[ListRemindsResponseBodyDataReminds]
        # The total number of custom alert rules returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.reminds:
            for k in self.reminds:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListRemindsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        result['Reminds'] = []
        if self.reminds is not None:
            for k in self.reminds:
                result['Reminds'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        self.reminds = []
        if m.get('Reminds') is not None:
            for k in m.get('Reminds'):
                temp_model = ListRemindsResponseBodyDataReminds()
                self.reminds.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListRemindsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The information about custom alert rules returned.
        self.data = data  # type: ListRemindsResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListRemindsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListRemindsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListRemindsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListRemindsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListRemindsResponse, self).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=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 = ListRemindsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListResourceGroupsRequestTags(TeaModel):
    def __init__(self, key=None, value=None):
        # The HTTP status code returned.
        self.key = key  # type: str
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.value = value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListResourceGroupsRequestTags, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class ListResourceGroupsRequest(TeaModel):
    def __init__(self, biz_ext_key=None, keyword=None, resource_group_type=None,
                 resource_manager_resource_group_id=None, tags=None):
        # The tags.
        self.biz_ext_key = biz_ext_key  # type: str
        # The ID of the resource group.
        self.keyword = keyword  # type: str
        # The category of the resource groups. Valid values:
        # 
        # *   default: shared resource group
        # *   single: exclusive resource group
        # *   Default value: default
        self.resource_group_type = resource_group_type  # type: int
        # The tag key.
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        # The tag value.
        self.tags = tags  # type: list[ListResourceGroupsRequestTags]

    def validate(self):
        if self.tags:
            for k in self.tags:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListResourceGroupsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_ext_key is not None:
            result['BizExtKey'] = self.biz_ext_key
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        if self.resource_group_type is not None:
            result['ResourceGroupType'] = self.resource_group_type
        if self.resource_manager_resource_group_id is not None:
            result['ResourceManagerResourceGroupId'] = self.resource_manager_resource_group_id
        result['Tags'] = []
        if self.tags is not None:
            for k in self.tags:
                result['Tags'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizExtKey') is not None:
            self.biz_ext_key = m.get('BizExtKey')
        if m.get('Keyword') is not None:
            self.keyword = m.get('Keyword')
        if m.get('ResourceGroupType') is not None:
            self.resource_group_type = m.get('ResourceGroupType')
        if m.get('ResourceManagerResourceGroupId') is not None:
            self.resource_manager_resource_group_id = m.get('ResourceManagerResourceGroupId')
        self.tags = []
        if m.get('Tags') is not None:
            for k in m.get('Tags'):
                temp_model = ListResourceGroupsRequestTags()
                self.tags.append(temp_model.from_map(k))
        return self


class ListResourceGroupsShrinkRequest(TeaModel):
    def __init__(self, biz_ext_key=None, keyword=None, resource_group_type=None,
                 resource_manager_resource_group_id=None, tags_shrink=None):
        # The tags.
        self.biz_ext_key = biz_ext_key  # type: str
        # The ID of the resource group.
        self.keyword = keyword  # type: str
        # The category of the resource groups. Valid values:
        # 
        # *   default: shared resource group
        # *   single: exclusive resource group
        # *   Default value: default
        self.resource_group_type = resource_group_type  # type: int
        # The tag key.
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        # The tag value.
        self.tags_shrink = tags_shrink  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListResourceGroupsShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_ext_key is not None:
            result['BizExtKey'] = self.biz_ext_key
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        if self.resource_group_type is not None:
            result['ResourceGroupType'] = self.resource_group_type
        if self.resource_manager_resource_group_id is not None:
            result['ResourceManagerResourceGroupId'] = self.resource_manager_resource_group_id
        if self.tags_shrink is not None:
            result['Tags'] = self.tags_shrink
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizExtKey') is not None:
            self.biz_ext_key = m.get('BizExtKey')
        if m.get('Keyword') is not None:
            self.keyword = m.get('Keyword')
        if m.get('ResourceGroupType') is not None:
            self.resource_group_type = m.get('ResourceGroupType')
        if m.get('ResourceManagerResourceGroupId') is not None:
            self.resource_manager_resource_group_id = m.get('ResourceManagerResourceGroupId')
        if m.get('Tags') is not None:
            self.tags_shrink = m.get('Tags')
        return self


class ListResourceGroupsResponseBodyDataTags(TeaModel):
    def __init__(self, key=None, value=None):
        self.key = key  # type: str
        self.value = value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListResourceGroupsResponseBodyDataTags, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.key is not None:
            result['Key'] = self.key
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Key') is not None:
            self.key = m.get('Key')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class ListResourceGroupsResponseBodyData(TeaModel):
    def __init__(self, biz_ext_key=None, cluster=None, create_time=None, enable_kp=None, id=None, identifier=None,
                 is_default=None, mode=None, name=None, resource_group_type=None, resource_manager_resource_group_id=None,
                 sequence=None, specs=None, status=None, tags=None, tenant_id=None, update_time=None):
        # The details of the resource group. The content enclosed in braces {} is the details of the resource group.
        self.biz_ext_key = biz_ext_key  # type: str
        # The type of the resource group. Valid values:
        # 
        # *   0: DataWorks
        # *   2: MaxCompute
        # *   3: PAI
        # *   4: Data Integration
        # *   7: scheduling
        # *   9: DataService Studio
        self.cluster = cluster  # type: str
        # The mode of the resource group. Valid values:
        # 
        # *   ISOLATE: exclusive resource group that adopts the subscription billing method
        # *   SHARE: shared resource group that adopts the pay-as-you-go billing method
        # *   DEVELOP: resource group for developers
        self.create_time = create_time  # type: str
        # The time when the cluster was created. Example: Jul 9, 2018 02:43:37 PM.
        self.enable_kp = enable_kp  # type: bool
        # The ID of your Alibaba Cloud resource group.
        self.id = id  # type: long
        # The category of the resource group. Valid values:
        # 
        # *   default: shared resource group
        # *   single: exclusive resource group
        self.identifier = identifier  # type: str
        # Indicates whether the UID of an Alibaba Cloud account is used for access. Valid values:
        # 
        # *   true: The MaxCompute compute engine uses the UID of the Alibaba Cloud account as the display name of the account for access.
        # 
        # *   false: The MaxCompute compute engine uses the name of the Alibaba Cloud account as the display name of the account for access.
        # 
        #     The remaining values are useless. This parameter is returned only if the type of the resource group is MaxCompute.
        self.is_default = is_default  # type: bool
        # The sequence number of the resource group. Created resource groups are sorted in ascending order by sequence number.
        self.mode = mode  # type: str
        # The ID of the tenant.
        self.name = name  # type: str
        # The identifier of the resource group.
        self.resource_group_type = resource_group_type  # type: str
        # The tag key.
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        # The name of the resource group.
        self.sequence = sequence  # type: int
        # The ID of the resource group.
        self.specs = specs  # type: dict[str, any]
        # Indicates whether the resource group is the default resource group. Valid values:
        # 
        # *   true: The resource group is the default resource group.
        # *   false: The resource group is not the default resource group.
        self.status = status  # type: int
        # The tag value.
        self.tags = tags  # type: list[ListResourceGroupsResponseBodyDataTags]
        # The tags.
        self.tenant_id = tenant_id  # type: long
        # The name of the cluster. This parameter is returned only if the type of the resource group is MaxCompute or PAI.
        self.update_time = update_time  # type: str

    def validate(self):
        if self.tags:
            for k in self.tags:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListResourceGroupsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_ext_key is not None:
            result['BizExtKey'] = self.biz_ext_key
        if self.cluster is not None:
            result['Cluster'] = self.cluster
        if self.create_time is not None:
            result['CreateTime'] = self.create_time
        if self.enable_kp is not None:
            result['EnableKp'] = self.enable_kp
        if self.id is not None:
            result['Id'] = self.id
        if self.identifier is not None:
            result['Identifier'] = self.identifier
        if self.is_default is not None:
            result['IsDefault'] = self.is_default
        if self.mode is not None:
            result['Mode'] = self.mode
        if self.name is not None:
            result['Name'] = self.name
        if self.resource_group_type is not None:
            result['ResourceGroupType'] = self.resource_group_type
        if self.resource_manager_resource_group_id is not None:
            result['ResourceManagerResourceGroupId'] = self.resource_manager_resource_group_id
        if self.sequence is not None:
            result['Sequence'] = self.sequence
        if self.specs is not None:
            result['Specs'] = self.specs
        if self.status is not None:
            result['Status'] = self.status
        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.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.update_time is not None:
            result['UpdateTime'] = self.update_time
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizExtKey') is not None:
            self.biz_ext_key = m.get('BizExtKey')
        if m.get('Cluster') is not None:
            self.cluster = m.get('Cluster')
        if m.get('CreateTime') is not None:
            self.create_time = m.get('CreateTime')
        if m.get('EnableKp') is not None:
            self.enable_kp = m.get('EnableKp')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('Identifier') is not None:
            self.identifier = m.get('Identifier')
        if m.get('IsDefault') is not None:
            self.is_default = m.get('IsDefault')
        if m.get('Mode') is not None:
            self.mode = m.get('Mode')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ResourceGroupType') is not None:
            self.resource_group_type = m.get('ResourceGroupType')
        if m.get('ResourceManagerResourceGroupId') is not None:
            self.resource_manager_resource_group_id = m.get('ResourceManagerResourceGroupId')
        if m.get('Sequence') is not None:
            self.sequence = m.get('Sequence')
        if m.get('Specs') is not None:
            self.specs = m.get('Specs')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        self.tags = []
        if m.get('Tags') is not None:
            for k in m.get('Tags'):
                temp_model = ListResourceGroupsResponseBodyDataTags()
                self.tags.append(temp_model.from_map(k))
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('UpdateTime') is not None:
            self.update_time = m.get('UpdateTime')
        return self


class ListResourceGroupsResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        # The time when the resource group was last updated.
        self.data = data  # type: list[ListResourceGroupsResponseBodyData]
        # Indicates whether the request was successful.
        self.http_status_code = http_status_code  # type: int
        # The resource groups.
        self.request_id = request_id  # type: str
        # The status of the resource group. Valid values:
        # 
        # *   0: The resource group is running or in service.
        # *   1: The resource group has expired and is frozen.
        # *   2: The resource group is released or destroyed.
        # *   3: The resource group is being created or started.
        # *   4: The resource group fails to be created or started.
        # *   5: The resource group is being scaled out or upgraded.
        # *   6: The resource group fails to be scaled out or upgraded.
        # *   7: The resource group is being released or destroyed.
        # *   8: The resource group fails to be released or destroyed.
        # *   9: The operation performed on the resource group times out. All operations may time out. This value is temporarily available only for DataService Studio.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListResourceGroupsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Data'] = []
        if self.data is not None:
            for k in self.data:
                result['Data'].append(k.to_map() if k else None)
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data = []
        if m.get('Data') is not None:
            for k in m.get('Data'):
                temp_model = ListResourceGroupsResponseBodyData()
                self.data.append(temp_model.from_map(k))
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListResourceGroupsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListResourceGroupsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListResourceGroupsResponse, self).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=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 = ListResourceGroupsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListShiftPersonnelsRequest(TeaModel):
    def __init__(self, begin_time=None, end_time=None, shift_person_uid=None, shift_schedule_identifier=None,
                 user_type=None):
        # The time when the on-duty engineer ends a shift. Set the value to a UNIX timestamp.
        self.begin_time = begin_time  # type: long
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.end_time = end_time  # type: long
        # The time when the on-duty engineer starts a shift. Set the value to a UNIX timestamp.
        self.shift_person_uid = shift_person_uid  # type: str
        # The type of on-duty engineers that you want to query. Valid values: ALL, PRIMARY, BACKUP, and DESIGNATED_USER.
        self.shift_schedule_identifier = shift_schedule_identifier  # type: str
        # The ID of your Alibaba Cloud account. You can log on to the DataWorks console and move the pointer over the profile picture in the upper-right corner to obtain the ID.
        self.user_type = user_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListShiftPersonnelsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.begin_time is not None:
            result['BeginTime'] = self.begin_time
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.shift_person_uid is not None:
            result['ShiftPersonUID'] = self.shift_person_uid
        if self.shift_schedule_identifier is not None:
            result['ShiftScheduleIdentifier'] = self.shift_schedule_identifier
        if self.user_type is not None:
            result['UserType'] = self.user_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BeginTime') is not None:
            self.begin_time = m.get('BeginTime')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('ShiftPersonUID') is not None:
            self.shift_person_uid = m.get('ShiftPersonUID')
        if m.get('ShiftScheduleIdentifier') is not None:
            self.shift_schedule_identifier = m.get('ShiftScheduleIdentifier')
        if m.get('UserType') is not None:
            self.user_type = m.get('UserType')
        return self


class ListShiftPersonnelsResponseBodyPagingShiftPersons(TeaModel):
    def __init__(self, begin_time=None, end_time=None, shift_person_name=None, shift_person_uid=None):
        # The time when the on-duty engineer ends the shift.
        self.begin_time = begin_time  # type: long
        self.end_time = end_time  # type: long
        # The time when the on-duty engineer starts the shift.
        self.shift_person_name = shift_person_name  # type: str
        # The name of the on-duty engineer.
        self.shift_person_uid = shift_person_uid  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListShiftPersonnelsResponseBodyPagingShiftPersons, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.begin_time is not None:
            result['BeginTime'] = self.begin_time
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.shift_person_name is not None:
            result['ShiftPersonName'] = self.shift_person_name
        if self.shift_person_uid is not None:
            result['ShiftPersonUID'] = self.shift_person_uid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BeginTime') is not None:
            self.begin_time = m.get('BeginTime')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('ShiftPersonName') is not None:
            self.shift_person_name = m.get('ShiftPersonName')
        if m.get('ShiftPersonUID') is not None:
            self.shift_person_uid = m.get('ShiftPersonUID')
        return self


class ListShiftPersonnelsResponseBodyPaging(TeaModel):
    def __init__(self, page_number=None, page_size=None, shift_persons=None, total_count=None):
        # The number of entries returned per page. Default value: 10. Maximum value: 100.
        self.page_number = page_number  # type: int
        # The total number of entries returned.
        self.page_size = page_size  # type: int
        # The UID of the on-duty engineer.
        self.shift_persons = shift_persons  # type: list[ListShiftPersonnelsResponseBodyPagingShiftPersons]
        # The on-duty engineers in the shift schedule.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.shift_persons:
            for k in self.shift_persons:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListShiftPersonnelsResponseBodyPaging, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        result['ShiftPersons'] = []
        if self.shift_persons is not None:
            for k in self.shift_persons:
                result['ShiftPersons'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        self.shift_persons = []
        if m.get('ShiftPersons') is not None:
            for k in m.get('ShiftPersons'):
                temp_model = ListShiftPersonnelsResponseBodyPagingShiftPersons()
                self.shift_persons.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListShiftPersonnelsResponseBody(TeaModel):
    def __init__(self, paging=None, request_id=None):
        # The page number of the returned page. Minimum value: 1. Maximum value: 100. Default value: 1.
        self.paging = paging  # type: ListShiftPersonnelsResponseBodyPaging
        # The pagination data.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.paging:
            self.paging.validate()

    def to_map(self):
        _map = super(ListShiftPersonnelsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.paging is not None:
            result['Paging'] = self.paging.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Paging') is not None:
            temp_model = ListShiftPersonnelsResponseBodyPaging()
            self.paging = temp_model.from_map(m['Paging'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListShiftPersonnelsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListShiftPersonnelsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListShiftPersonnelsResponse, self).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=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 = ListShiftPersonnelsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListShiftSchedulesRequest(TeaModel):
    def __init__(self, owner=None, page_number=None, page_size=None, shift_schedule_name=None):
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.owner = owner  # type: str
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.page_number = page_number  # type: int
        # The number of the page to return. Minimum value:1. Maximum value: 100. Default value: 1.
        self.page_size = page_size  # type: int
        # The ID of your Alibaba Cloud account. You can log on to the DataWorks console and move the pointer over the profile picture in the upper-right corner to obtain the ID.
        self.shift_schedule_name = shift_schedule_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListShiftSchedulesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.shift_schedule_name is not None:
            result['ShiftScheduleName'] = self.shift_schedule_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ShiftScheduleName') is not None:
            self.shift_schedule_name = m.get('ShiftScheduleName')
        return self


class ListShiftSchedulesResponseBodyPagingShiftSchedules(TeaModel):
    def __init__(self, shift_schedule_identifier=None, shift_schedule_name=None):
        # The name of the shift schedule.
        self.shift_schedule_identifier = shift_schedule_identifier  # type: str
        self.shift_schedule_name = shift_schedule_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListShiftSchedulesResponseBodyPagingShiftSchedules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.shift_schedule_identifier is not None:
            result['ShiftScheduleIdentifier'] = self.shift_schedule_identifier
        if self.shift_schedule_name is not None:
            result['ShiftScheduleName'] = self.shift_schedule_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ShiftScheduleIdentifier') is not None:
            self.shift_schedule_identifier = m.get('ShiftScheduleIdentifier')
        if m.get('ShiftScheduleName') is not None:
            self.shift_schedule_name = m.get('ShiftScheduleName')
        return self


class ListShiftSchedulesResponseBodyPaging(TeaModel):
    def __init__(self, page_number=None, page_size=None, shift_schedules=None, total_count=None):
        # The number of entries returned per page.
        self.page_number = page_number  # type: int
        # The total number of entries returned.
        self.page_size = page_size  # type: int
        # The unique identifier of the shift schedule. You can use the identifier to query the on-duty engineers in the shift schedule.
        self.shift_schedules = shift_schedules  # type: list[ListShiftSchedulesResponseBodyPagingShiftSchedules]
        # The shift schedules.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.shift_schedules:
            for k in self.shift_schedules:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListShiftSchedulesResponseBodyPaging, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        result['ShiftSchedules'] = []
        if self.shift_schedules is not None:
            for k in self.shift_schedules:
                result['ShiftSchedules'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        self.shift_schedules = []
        if m.get('ShiftSchedules') is not None:
            for k in m.get('ShiftSchedules'):
                temp_model = ListShiftSchedulesResponseBodyPagingShiftSchedules()
                self.shift_schedules.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListShiftSchedulesResponseBody(TeaModel):
    def __init__(self, paging=None, request_id=None):
        # The page number of the returned page. Minimum value:1. Maximum value: 100.
        self.paging = paging  # type: ListShiftSchedulesResponseBodyPaging
        # The pagination data.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.paging:
            self.paging.validate()

    def to_map(self):
        _map = super(ListShiftSchedulesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.paging is not None:
            result['Paging'] = self.paging.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Paging') is not None:
            temp_model = ListShiftSchedulesResponseBodyPaging()
            self.paging = temp_model.from_map(m['Paging'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListShiftSchedulesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListShiftSchedulesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListShiftSchedulesResponse, self).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=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 = ListShiftSchedulesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListSuccessInstanceAmountRequest(TeaModel):
    def __init__(self, project_id=None):
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListSuccessInstanceAmountRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListSuccessInstanceAmountResponseBodyInstanceStatusTrendAvgTrend(TeaModel):
    def __init__(self, count=None, time_point=None):
        # The number of instances that are successfully run.
        self.count = count  # type: int
        # The point in time. The value is an exact hour that ranges from 00:00 to 23:00, such as 00:00, 01:00, or 02:00.
        self.time_point = time_point  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListSuccessInstanceAmountResponseBodyInstanceStatusTrendAvgTrend, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.time_point is not None:
            result['TimePoint'] = self.time_point
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('TimePoint') is not None:
            self.time_point = m.get('TimePoint')
        return self


class ListSuccessInstanceAmountResponseBodyInstanceStatusTrendTodayTrend(TeaModel):
    def __init__(self, count=None, time_point=None):
        # The number of instances that are successfully run.
        self.count = count  # type: int
        # The point in time. The value is an exact hour that ranges from 00:00 to 23:00, such as 00:00, 01:00, or 02:00.
        self.time_point = time_point  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListSuccessInstanceAmountResponseBodyInstanceStatusTrendTodayTrend, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.time_point is not None:
            result['TimePoint'] = self.time_point
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('TimePoint') is not None:
            self.time_point = m.get('TimePoint')
        return self


class ListSuccessInstanceAmountResponseBodyInstanceStatusTrendYesterdayTrend(TeaModel):
    def __init__(self, count=None, time_point=None):
        # The number of instances that are successfully run.
        self.count = count  # type: int
        # The point in time. The value is an exact hour that ranges from 00:00 to 23:00, such as 00:00, 01:00, or 02:00.
        self.time_point = time_point  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListSuccessInstanceAmountResponseBodyInstanceStatusTrendYesterdayTrend, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.time_point is not None:
            result['TimePoint'] = self.time_point
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('TimePoint') is not None:
            self.time_point = m.get('TimePoint')
        return self


class ListSuccessInstanceAmountResponseBodyInstanceStatusTrend(TeaModel):
    def __init__(self, avg_trend=None, today_trend=None, yesterday_trend=None):
        # The average trend.
        self.avg_trend = avg_trend  # type: list[ListSuccessInstanceAmountResponseBodyInstanceStatusTrendAvgTrend]
        # The trend of the number of auto triggered node instances that are successfully run on the current day.
        self.today_trend = today_trend  # type: list[ListSuccessInstanceAmountResponseBodyInstanceStatusTrendTodayTrend]
        # The trend of the number of auto triggered node instances that are successfully run one day earlier than the current day.
        self.yesterday_trend = yesterday_trend  # type: list[ListSuccessInstanceAmountResponseBodyInstanceStatusTrendYesterdayTrend]

    def validate(self):
        if self.avg_trend:
            for k in self.avg_trend:
                if k:
                    k.validate()
        if self.today_trend:
            for k in self.today_trend:
                if k:
                    k.validate()
        if self.yesterday_trend:
            for k in self.yesterday_trend:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListSuccessInstanceAmountResponseBodyInstanceStatusTrend, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['AvgTrend'] = []
        if self.avg_trend is not None:
            for k in self.avg_trend:
                result['AvgTrend'].append(k.to_map() if k else None)
        result['TodayTrend'] = []
        if self.today_trend is not None:
            for k in self.today_trend:
                result['TodayTrend'].append(k.to_map() if k else None)
        result['YesterdayTrend'] = []
        if self.yesterday_trend is not None:
            for k in self.yesterday_trend:
                result['YesterdayTrend'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.avg_trend = []
        if m.get('AvgTrend') is not None:
            for k in m.get('AvgTrend'):
                temp_model = ListSuccessInstanceAmountResponseBodyInstanceStatusTrendAvgTrend()
                self.avg_trend.append(temp_model.from_map(k))
        self.today_trend = []
        if m.get('TodayTrend') is not None:
            for k in m.get('TodayTrend'):
                temp_model = ListSuccessInstanceAmountResponseBodyInstanceStatusTrendTodayTrend()
                self.today_trend.append(temp_model.from_map(k))
        self.yesterday_trend = []
        if m.get('YesterdayTrend') is not None:
            for k in m.get('YesterdayTrend'):
                temp_model = ListSuccessInstanceAmountResponseBodyInstanceStatusTrendYesterdayTrend()
                self.yesterday_trend.append(temp_model.from_map(k))
        return self


class ListSuccessInstanceAmountResponseBody(TeaModel):
    def __init__(self, instance_status_trend=None, request_id=None):
        # Indicates the trend of the number of auto triggered node instances that are successfully run every hour on the hour of the current day.
        self.instance_status_trend = instance_status_trend  # type: ListSuccessInstanceAmountResponseBodyInstanceStatusTrend
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.instance_status_trend:
            self.instance_status_trend.validate()

    def to_map(self):
        _map = super(ListSuccessInstanceAmountResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_status_trend is not None:
            result['InstanceStatusTrend'] = self.instance_status_trend.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceStatusTrend') is not None:
            temp_model = ListSuccessInstanceAmountResponseBodyInstanceStatusTrend()
            self.instance_status_trend = temp_model.from_map(m['InstanceStatusTrend'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class ListSuccessInstanceAmountResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListSuccessInstanceAmountResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListSuccessInstanceAmountResponse, self).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=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 = ListSuccessInstanceAmountResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListTableLevelRequest(TeaModel):
    def __init__(self, level_type=None, page_num=None, page_size=None, project_id=None):
        # The type of the table level. Valid values: 1 and 2. A value of 1 indicates the logical level. A value of 2 indicates the physical level.
        self.level_type = level_type  # type: int
        # The number of the page to return. Default value: 1.
        self.page_num = page_num  # type: int
        # The number of entries to return on each page. Default value: 10.
        self.page_size = page_size  # type: int
        # The ID of the DataWorks workspace. You can log on to the DataWorks console to obtain the ID.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListTableLevelRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.level_type is not None:
            result['LevelType'] = self.level_type
        if self.page_num is not None:
            result['PageNum'] = self.page_num
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('LevelType') is not None:
            self.level_type = m.get('LevelType')
        if m.get('PageNum') is not None:
            self.page_num = m.get('PageNum')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListTableLevelResponseBodyTableLevelInfoLevelList(TeaModel):
    def __init__(self, description=None, level_id=None, level_type=None, name=None, project_id=None):
        # The description of the table level.
        self.description = description  # type: str
        # The ID of the table level.
        self.level_id = level_id  # type: long
        # The type of the table level. Valid values: 1 and 2. A value of 1 indicates the logical level. A value of 2 indicates the physical level.
        self.level_type = level_type  # type: int
        # The name of the table level.
        self.name = name  # type: str
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListTableLevelResponseBodyTableLevelInfoLevelList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        if self.level_id is not None:
            result['LevelId'] = self.level_id
        if self.level_type is not None:
            result['LevelType'] = self.level_type
        if self.name is not None:
            result['Name'] = self.name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('LevelId') is not None:
            self.level_id = m.get('LevelId')
        if m.get('LevelType') is not None:
            self.level_type = m.get('LevelType')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListTableLevelResponseBodyTableLevelInfo(TeaModel):
    def __init__(self, level_list=None, total_count=None):
        # The list of table levels.
        self.level_list = level_list  # type: list[ListTableLevelResponseBodyTableLevelInfoLevelList]
        # The total number of table levels returned.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.level_list:
            for k in self.level_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListTableLevelResponseBodyTableLevelInfo, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['LevelList'] = []
        if self.level_list is not None:
            for k in self.level_list:
                result['LevelList'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.level_list = []
        if m.get('LevelList') is not None:
            for k in m.get('LevelList'):
                temp_model = ListTableLevelResponseBodyTableLevelInfoLevelList()
                self.level_list.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListTableLevelResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, success=None,
                 table_level_info=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool
        # The information about the table levels.
        self.table_level_info = table_level_info  # type: ListTableLevelResponseBodyTableLevelInfo

    def validate(self):
        if self.table_level_info:
            self.table_level_info.validate()

    def to_map(self):
        _map = super(ListTableLevelResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        if self.table_level_info is not None:
            result['TableLevelInfo'] = self.table_level_info.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        if m.get('TableLevelInfo') is not None:
            temp_model = ListTableLevelResponseBodyTableLevelInfo()
            self.table_level_info = temp_model.from_map(m['TableLevelInfo'])
        return self


class ListTableLevelResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListTableLevelResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListTableLevelResponse, self).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=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 = ListTableLevelResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListTableThemeRequest(TeaModel):
    def __init__(self, page_num=None, page_size=None, parent_id=None, project_id=None):
        # The number of the page to return.
        self.page_num = page_num  # type: int
        # The number of entries to return on each page. Default value:10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The ID of the parent table folder.
        self.parent_id = parent_id  # type: long
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListTableThemeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_num is not None:
            result['PageNum'] = self.page_num
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.parent_id is not None:
            result['ParentId'] = self.parent_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNum') is not None:
            self.page_num = m.get('PageNum')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('ParentId') is not None:
            self.parent_id = m.get('ParentId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class ListTableThemeResponseBodyDataThemeList(TeaModel):
    def __init__(self, create_time_stamp=None, creator=None, level=None, name=None, parent_id=None, project_id=None,
                 theme_id=None):
        # The time when the level was created.
        self.create_time_stamp = create_time_stamp  # type: long
        # The creator of the level.
        self.creator = creator  # type: str
        # The level of the table folder. Valid values: 1 and 2. A value of 1 indicates a table folder of level 1. A value of 2 indicates a table folder of level 2.
        self.level = level  # type: int
        # The name of the level of the table folder.
        self.name = name  # type: str
        # The ID of the parent node.
        self.parent_id = parent_id  # type: long
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long
        # The ID of the table folder.
        self.theme_id = theme_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListTableThemeResponseBodyDataThemeList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.create_time_stamp is not None:
            result['CreateTimeStamp'] = self.create_time_stamp
        if self.creator is not None:
            result['Creator'] = self.creator
        if self.level is not None:
            result['Level'] = self.level
        if self.name is not None:
            result['Name'] = self.name
        if self.parent_id is not None:
            result['ParentId'] = self.parent_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.theme_id is not None:
            result['ThemeId'] = self.theme_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CreateTimeStamp') is not None:
            self.create_time_stamp = m.get('CreateTimeStamp')
        if m.get('Creator') is not None:
            self.creator = m.get('Creator')
        if m.get('Level') is not None:
            self.level = m.get('Level')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ParentId') is not None:
            self.parent_id = m.get('ParentId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ThemeId') is not None:
            self.theme_id = m.get('ThemeId')
        return self


class ListTableThemeResponseBodyData(TeaModel):
    def __init__(self, theme_list=None, total_count=None):
        # The list of levels of the table folders.
        self.theme_list = theme_list  # type: list[ListTableThemeResponseBodyDataThemeList]
        # The total number of table folders.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.theme_list:
            for k in self.theme_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListTableThemeResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ThemeList'] = []
        if self.theme_list is not None:
            for k in self.theme_list:
                result['ThemeList'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.theme_list = []
        if m.get('ThemeList') is not None:
            for k in m.get('ThemeList'):
                temp_model = ListTableThemeResponseBodyDataThemeList()
                self.theme_list.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListTableThemeResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The returned data about the level of the table folder.
        self.data = data  # type: ListTableThemeResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListTableThemeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListTableThemeResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListTableThemeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListTableThemeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListTableThemeResponse, self).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=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 = ListTableThemeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListTopicsRequest(TeaModel):
    def __init__(self, begin_time=None, end_time=None, instance_id=None, node_id=None, owner=None, page_number=None,
                 page_size=None, topic_statuses=None, topic_types=None):
        # The beginning of the time range to query. Specify the time in the ISO 8601 standard in the yyyy-MM-dd\"T\"HH:mm:ssZ format. The time must be in UTC.
        self.begin_time = begin_time  # type: str
        # The end of the time range to query. Specify the time in the ISO 8601 standard in the yyyy-MM-dd\"T\"HH:mm:ssZ format. The time must be in UTC.
        self.end_time = end_time  # type: str
        # The ID of the node instance that triggers the events. You can configure either this parameter or the NodeId parameter.
        self.instance_id = instance_id  # type: long
        # The ID of the node that triggers the events. You can configure either this parameter or the InstanceId parameter.
        self.node_id = node_id  # type: long
        # The ID of the Alibaba Cloud account used by the owner of the events.
        self.owner = owner  # type: str
        # The number of the page to return. Valid values: 1 to 30. Default value: 1.
        self.page_number = page_number  # type: int
        # The number of entries to return on each page. Default value: 10. Maximum value: 100.
        self.page_size = page_size  # type: int
        # The status of the events. Valid values: IGNORE, NEW, FIXING, and RECOVER. The value IGNORE indicates that the events are ignored. The value NEW indicates that the events are new events. The value FIXING indicates that the events are being processed. The value RECOVER indicates that the events are processed. You can specify multiple states. Separate them with commas (,).
        self.topic_statuses = topic_statuses  # type: str
        # The types of the events. Valid values: SLOW and ERROR. The value SLOW indicates that the running duration of the node in the current scheduling cycle is significantly longer than the average running duration of the node in previous scheduling cycles. The value ERROR indicates that the node fails to run. You can specify multiple types. Separate them with commas (,).
        self.topic_types = topic_types  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListTopicsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.begin_time is not None:
            result['BeginTime'] = self.begin_time
        if self.end_time is not None:
            result['EndTime'] = self.end_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.topic_statuses is not None:
            result['TopicStatuses'] = self.topic_statuses
        if self.topic_types is not None:
            result['TopicTypes'] = self.topic_types
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BeginTime') is not None:
            self.begin_time = m.get('BeginTime')
        if m.get('EndTime') is not None:
            self.end_time = m.get('EndTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TopicStatuses') is not None:
            self.topic_statuses = m.get('TopicStatuses')
        if m.get('TopicTypes') is not None:
            self.topic_types = m.get('TopicTypes')
        return self


class ListTopicsResponseBodyDataTopics(TeaModel):
    def __init__(self, add_time=None, fix_time=None, happen_time=None, instance_id=None, node_id=None,
                 node_name=None, node_owner=None, project_id=None, topic_id=None, topic_name=None, topic_status=None,
                 topic_type=None):
        # The timestamp when the event was found.
        self.add_time = add_time  # type: long
        # The timestamp when the event was processed.
        self.fix_time = fix_time  # type: long
        # The timestamp when the event occurred. A time difference may exist between the time when the event occurred and the time when the event was found.
        self.happen_time = happen_time  # type: long
        # The ID of the node instance that triggers the event.
        self.instance_id = instance_id  # type: long
        # The ID of the node that triggers the event.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The ID of the Alibaba Cloud account that is used by the node owner.
        self.node_owner = node_owner  # type: str
        # The ID of the workspace to which the node belongs.
        self.project_id = project_id  # type: long
        # The ID of the event.
        self.topic_id = topic_id  # type: long
        # The name of the event.
        self.topic_name = topic_name  # type: str
        # The status of the event. Valid values: IGNORE, NEW, FIXING, and RECOVER. The value IGNORE indicates that the event is ignored. The value NEW indicates that the event is a new event. The value FIXING indicates that the event is being processed. The value RECOVER indicates that the event is processed.
        self.topic_status = topic_status  # type: str
        # The type of the event. Valid values: SLOW and ERROR. The value SLOW indicates that the running duration of the node in the current scheduling cycle is significantly longer than the average running duration of the node in previous scheduling cycles. The value ERROR indicates that the node fails to run.
        self.topic_type = topic_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListTopicsResponseBodyDataTopics, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.add_time is not None:
            result['AddTime'] = self.add_time
        if self.fix_time is not None:
            result['FixTime'] = self.fix_time
        if self.happen_time is not None:
            result['HappenTime'] = self.happen_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.node_owner is not None:
            result['NodeOwner'] = self.node_owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.topic_id is not None:
            result['TopicId'] = self.topic_id
        if self.topic_name is not None:
            result['TopicName'] = self.topic_name
        if self.topic_status is not None:
            result['TopicStatus'] = self.topic_status
        if self.topic_type is not None:
            result['TopicType'] = self.topic_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AddTime') is not None:
            self.add_time = m.get('AddTime')
        if m.get('FixTime') is not None:
            self.fix_time = m.get('FixTime')
        if m.get('HappenTime') is not None:
            self.happen_time = m.get('HappenTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('NodeOwner') is not None:
            self.node_owner = m.get('NodeOwner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TopicId') is not None:
            self.topic_id = m.get('TopicId')
        if m.get('TopicName') is not None:
            self.topic_name = m.get('TopicName')
        if m.get('TopicStatus') is not None:
            self.topic_status = m.get('TopicStatus')
        if m.get('TopicType') is not None:
            self.topic_type = m.get('TopicType')
        return self


class ListTopicsResponseBodyData(TeaModel):
    def __init__(self, page_number=None, page_size=None, topics=None, total_count=None):
        # The page number of the returned page.
        self.page_number = page_number  # type: int
        # The number of entries returned per page.
        self.page_size = page_size  # type: int
        # The events returned.
        self.topics = topics  # type: list[ListTopicsResponseBodyDataTopics]
        # The total number of the events returned.
        self.total_count = total_count  # type: int

    def validate(self):
        if self.topics:
            for k in self.topics:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(ListTopicsResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        result['Topics'] = []
        if self.topics is not None:
            for k in self.topics:
                result['Topics'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        self.topics = []
        if m.get('Topics') is not None:
            for k in m.get('Topics'):
                temp_model = ListTopicsResponseBodyDataTopics()
                self.topics.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class ListTopicsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The information about the events returned.
        self.data = data  # type: ListTopicsResponseBodyData
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(ListTopicsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = ListTopicsResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ListTopicsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ListTopicsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ListTopicsResponse, self).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=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 = ListTopicsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class MountDirectoryRequest(TeaModel):
    def __init__(self, target_id=None, target_type=None, target_user_id=None):
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.target_id = target_id  # type: str
        # The number of directories that are added. Valid values:
        # 
        # *   0: No directories are added. The left-side navigation pane may contain the specified directory.
        # *   1: One directory is added.
        self.target_type = target_type  # type: str
        self.target_user_id = target_user_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(MountDirectoryRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.target_id is not None:
            result['TargetId'] = self.target_id
        if self.target_type is not None:
            result['TargetType'] = self.target_type
        if self.target_user_id is not None:
            result['TargetUserId'] = self.target_user_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TargetId') is not None:
            self.target_id = m.get('TargetId')
        if m.get('TargetType') is not None:
            self.target_type = m.get('TargetType')
        if m.get('TargetUserId') is not None:
            self.target_user_id = m.get('TargetUserId')
        return self


class MountDirectoryResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.data = data  # type: int
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        # The error message returned if the request failed.
        self.http_status_code = http_status_code  # type: int
        # The error code returned. The value 200 indicates that the add task is successful.
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(MountDirectoryResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class MountDirectoryResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: MountDirectoryResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(MountDirectoryResponse, self).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=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 = MountDirectoryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class OfflineNodeRequest(TeaModel):
    def __init__(self, node_id=None, project_id=None):
        # The ID of the DataWorks workspace. You can call the [ListProjects](~~178393~~) operation to obtain the ID.
        self.node_id = node_id  # type: long
        # The ID of the request. You can use the ID to locate logs and troubleshoot issues.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(OfflineNodeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class OfflineNodeResponseBody(TeaModel):
    def __init__(self, request_id=None, success=None):
        # Indicates whether the request is successful.
        self.request_id = request_id  # type: str
        self.success = success  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(OfflineNodeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class OfflineNodeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: OfflineNodeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(OfflineNodeResponse, self).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=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 = OfflineNodeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class PublishDataServiceApiRequest(TeaModel):
    def __init__(self, api_id=None, project_id=None, tenant_id=None):
        # The ID of the API. You can call the [ListDataServiceApis](~~174009~~) operation to obtain the ID.
        self.api_id = api_id  # type: long
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace ID.
        self.project_id = project_id  # type: long
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(PublishDataServiceApiRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class PublishDataServiceApiResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the API is published.
        self.data = data  # type: bool
        # The error code.
        self.error_code = error_code  # type: str
        # The error message.
        self.error_message = error_message  # type: str
        # The HTTP status code.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(PublishDataServiceApiResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class PublishDataServiceApiResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: PublishDataServiceApiResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(PublishDataServiceApiResponse, self).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=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 = PublishDataServiceApiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class QueryDISyncTaskConfigProcessResultRequest(TeaModel):
    def __init__(self, async_process_id=None, project_id=None, task_type=None):
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.async_process_id = async_process_id  # type: long
        # The type of the object that you want to create or update in Data Integration in asynchronous mode. Valid values:
        # 
        # *   DI_REALTIME: real-time synchronization node
        # 
        # *   DI_SOLUTION: synchronization solution
        # 
        #     DataWorks allows you to create or update real-time synchronization nodes and synchronization solutions in Data Integration only in asynchronous mode.
        self.project_id = project_id  # type: long
        # The ID of the asynchronous thread. You can call the [GenerateDISyncTaskConfigForCreating](~~383463~~) or [GenerateDISyncTaskConfigForUpdating](~~383464~~) operation to generate the ID.
        # 
        # *   The GenerateDISyncTaskConfigForCreating operation is used to generate the ID of the asynchronous thread that is used to create a real-time synchronization node or a synchronization solution in Data Integration.
        # *   The GenerateDISyncTaskConfigForUpdating operation is used to generate the ID of the asynchronous thread that is used to update a real-time synchronization node or a synchronization solution in Data Integration.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(QueryDISyncTaskConfigProcessResultRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.async_process_id is not None:
            result['AsyncProcessId'] = self.async_process_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AsyncProcessId') is not None:
            self.async_process_id = m.get('AsyncProcessId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class QueryDISyncTaskConfigProcessResultResponseBodyData(TeaModel):
    def __init__(self, message=None, status=None, task_content=None):
        # The parameters that are obtained. The parameters are used as the request parameters of the [CreateDISyncTask](~~278725~~) or [UpdateDISyncTask](~~289109~~) operation to create or update a real-time synchronization node or a synchronization solution in Data Integration.
        self.message = message  # type: str
        # The reason why the parameters fail to be obtained. If the parameters are obtained, the value null is returned.
        self.status = status  # type: str
        self.task_content = task_content  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(QueryDISyncTaskConfigProcessResultResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.status is not None:
            result['Status'] = self.status
        if self.task_content is not None:
            result['TaskContent'] = self.task_content
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskContent') is not None:
            self.task_content = m.get('TaskContent')
        return self


class QueryDISyncTaskConfigProcessResultResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # Indicates whether the parameters are obtained. Valid values:
        # 
        # *   success: indicates that the parameters are obtained.
        # *   fail: indicates that the parameters fail to be obtained. You can view the reason for the failure and troubleshoot the issue based on the reason.
        self.data = data  # type: QueryDISyncTaskConfigProcessResultResponseBodyData
        # The information returned for the parameters that are asynchronously generated and used to create or update a real-time synchronization node or a synchronization solution in Data Integration.
        self.request_id = request_id  # type: str
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(QueryDISyncTaskConfigProcessResultResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = QueryDISyncTaskConfigProcessResultResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class QueryDISyncTaskConfigProcessResultResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: QueryDISyncTaskConfigProcessResultResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(QueryDISyncTaskConfigProcessResultResponse, self).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=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 = QueryDISyncTaskConfigProcessResultResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class QueryPublicModelEngineRequest(TeaModel):
    def __init__(self, project_id=None, text=None):
        self.project_id = project_id  # type: str
        self.text = text  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(QueryPublicModelEngineRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.text is not None:
            result['Text'] = self.text
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Text') is not None:
            self.text = m.get('Text')
        return self


class QueryPublicModelEngineResponseBody(TeaModel):
    def __init__(self, request_id=None, return_value=None):
        self.request_id = request_id  # type: str
        self.return_value = return_value  # type: list[dict[str, any]]

    def validate(self):
        pass

    def to_map(self):
        _map = super(QueryPublicModelEngineResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.return_value is not None:
            result['ReturnValue'] = self.return_value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('ReturnValue') is not None:
            self.return_value = m.get('ReturnValue')
        return self


class QueryPublicModelEngineResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: QueryPublicModelEngineResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(QueryPublicModelEngineResponse, self).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=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 = QueryPublicModelEngineResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RegisterLineageRelationRequest(TeaModel):
    def __init__(self, lineage_relation_register_vo=None):
        self.lineage_relation_register_vo = lineage_relation_register_vo  # type: LineageRelationRegisterVO

    def validate(self):
        if self.lineage_relation_register_vo:
            self.lineage_relation_register_vo.validate()

    def to_map(self):
        _map = super(RegisterLineageRelationRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.lineage_relation_register_vo is not None:
            result['LineageRelationRegisterVO'] = self.lineage_relation_register_vo.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('LineageRelationRegisterVO') is not None:
            temp_model = LineageRelationRegisterVO()
            self.lineage_relation_register_vo = temp_model.from_map(m['LineageRelationRegisterVO'])
        return self


class RegisterLineageRelationShrinkRequest(TeaModel):
    def __init__(self, lineage_relation_register_voshrink=None):
        self.lineage_relation_register_voshrink = lineage_relation_register_voshrink  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(RegisterLineageRelationShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.lineage_relation_register_voshrink is not None:
            result['LineageRelationRegisterVO'] = self.lineage_relation_register_voshrink
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('LineageRelationRegisterVO') is not None:
            self.lineage_relation_register_voshrink = m.get('LineageRelationRegisterVO')
        return self


class RegisterLineageRelationResponseBodyLineageRelation(TeaModel):
    def __init__(self, dest_entity_qualified_name=None, relationship_guid=None, src_entity_qualified_name=None):
        self.dest_entity_qualified_name = dest_entity_qualified_name  # type: str
        self.relationship_guid = relationship_guid  # type: str
        self.src_entity_qualified_name = src_entity_qualified_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(RegisterLineageRelationResponseBodyLineageRelation, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dest_entity_qualified_name is not None:
            result['DestEntityQualifiedName'] = self.dest_entity_qualified_name
        if self.relationship_guid is not None:
            result['RelationshipGuid'] = self.relationship_guid
        if self.src_entity_qualified_name is not None:
            result['SrcEntityQualifiedName'] = self.src_entity_qualified_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DestEntityQualifiedName') is not None:
            self.dest_entity_qualified_name = m.get('DestEntityQualifiedName')
        if m.get('RelationshipGuid') is not None:
            self.relationship_guid = m.get('RelationshipGuid')
        if m.get('SrcEntityQualifiedName') is not None:
            self.src_entity_qualified_name = m.get('SrcEntityQualifiedName')
        return self


class RegisterLineageRelationResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, lineage_relation=None,
                 request_id=None, success=None):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.lineage_relation = lineage_relation  # type: RegisterLineageRelationResponseBodyLineageRelation
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        if self.lineage_relation:
            self.lineage_relation.validate()

    def to_map(self):
        _map = super(RegisterLineageRelationResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.lineage_relation is not None:
            result['LineageRelation'] = self.lineage_relation.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('LineageRelation') is not None:
            temp_model = RegisterLineageRelationResponseBodyLineageRelation()
            self.lineage_relation = temp_model.from_map(m['LineageRelation'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class RegisterLineageRelationResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: RegisterLineageRelationResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(RegisterLineageRelationResponse, self).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=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 = RegisterLineageRelationResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RemoveEntityTagsRequest(TeaModel):
    def __init__(self, qualified_name=None, tag_keys=None):
        self.qualified_name = qualified_name  # type: str
        self.tag_keys = tag_keys  # type: list[str]

    def validate(self):
        pass

    def to_map(self):
        _map = super(RemoveEntityTagsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        if self.tag_keys is not None:
            result['TagKeys'] = self.tag_keys
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        if m.get('TagKeys') is not None:
            self.tag_keys = m.get('TagKeys')
        return self


class RemoveEntityTagsShrinkRequest(TeaModel):
    def __init__(self, qualified_name=None, tag_keys_shrink=None):
        self.qualified_name = qualified_name  # type: str
        self.tag_keys_shrink = tag_keys_shrink  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(RemoveEntityTagsShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        if self.tag_keys_shrink is not None:
            result['TagKeys'] = self.tag_keys_shrink
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        if m.get('TagKeys') is not None:
            self.tag_keys_shrink = m.get('TagKeys')
        return self


class RemoveEntityTagsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: bool
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(RemoveEntityTagsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class RemoveEntityTagsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: RemoveEntityTagsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(RemoveEntityTagsResponse, self).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=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 = RemoveEntityTagsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RemoveProjectMemberFromRoleRequest(TeaModel):
    def __init__(self, project_id=None, role_code=None, user_id=None):
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long
        # The role in the DataWorks workspace. You can call the ListProjectRoles operation to query codes of the roles in the workspace.
        # 
        # Valid values:
        # 
        # *   role_project_owner: workspace owner
        # *   role_project_admin: workspace administrator
        # *   role_project_dev: developer
        # *   role_project_pe: O\&M engineer
        # *   role_project_deploy: deployment expert
        # *   role_project_guest: visitor
        # *   role_project_security: security administrator
        # *   role_project_tester: experiencer
        # *   role_project_erd: model designer
        self.role_code = role_code  # type: str
        # The ID of the user.
        self.user_id = user_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(RemoveProjectMemberFromRoleRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.role_code is not None:
            result['RoleCode'] = self.role_code
        if self.user_id is not None:
            result['UserId'] = self.user_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RoleCode') is not None:
            self.role_code = m.get('RoleCode')
        if m.get('UserId') is not None:
            self.user_id = m.get('UserId')
        return self


class RemoveProjectMemberFromRoleResponseBody(TeaModel):
    def __init__(self, request_id=None):
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(RemoveProjectMemberFromRoleResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class RemoveProjectMemberFromRoleResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: RemoveProjectMemberFromRoleResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(RemoveProjectMemberFromRoleResponse, self).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=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 = RemoveProjectMemberFromRoleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RestartInstanceRequest(TeaModel):
    def __init__(self, instance_id=None, project_env=None):
        # The instance ID.
        self.instance_id = instance_id  # type: long
        # The environment of the workspace. Valid values: PROD and DEV.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(RestartInstanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class RestartInstanceResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The result returned.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request, You can use the ID to query logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(RestartInstanceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class RestartInstanceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: RestartInstanceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(RestartInstanceResponse, self).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=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 = RestartInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ResumeInstanceRequest(TeaModel):
    def __init__(self, instance_id=None, project_env=None):
        # The instance ID.
        self.instance_id = instance_id  # type: long
        # The environment of the workspace. Valid values: PROD and DEV.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ResumeInstanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class ResumeInstanceResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The result returned.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(ResumeInstanceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class ResumeInstanceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ResumeInstanceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ResumeInstanceResponse, self).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=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 = ResumeInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RevokeColumnPermissionRequest(TeaModel):
    def __init__(self, columns=None, max_compute_project_name=None, revoke_user_id=None, revoke_user_name=None,
                 table_name=None, workspace_id=None):
        # The Alibaba Cloud account of the user from whom you want to revoke permissions. Specify this parameter in the format that is the same as the format of the account used to access the MaxCompute project.
        # 
        # *   If you want to revoke permissions from an Alibaba Cloud account, specify this parameter in the ALIYUN$+Alibaba Cloud account format.
        # *   If you want to revoke permissions from a Resource Access Management (RAM) user, specify this parameter in the RAM$+RAM user format.
        # 
        # You must specify either this parameter or RevokeUserId. If you specify both this parameter and RevokeUserId, the value of RevokeUserId prevails.
        self.columns = columns  # type: str
        # The name of the MaxCompute table to which the destination fields belong. You can call the [SearchMetaTables](~~173919~~) operation to query the name.
        self.max_compute_project_name = max_compute_project_name  # type: str
        # Indicates whether the permissions on table fields are revoked.
        self.revoke_user_id = revoke_user_id  # type: str
        # The ID of the Alibaba Cloud account of the user from whom you want to revoke permissions. You can log on to the DataWorks console and go to the Security Settings page to obtain the ID.
        # 
        # You must specify either this parameter or RevokeUserName. If you specify both this parameter and RevokeUserName, the value of this parameter prevails.
        self.revoke_user_name = revoke_user_name  # type: str
        # The fields for which you want to revoke permissions from a user. Separate multiple fields with commas (,).
        # 
        # You can revoke the permissions on the fields only in MaxCompute tables.
        self.table_name = table_name  # type: str
        # The name of the MaxCompute project to which the destination fields belong. You can log on to the DataWorks console and go to the Workspace Management page to obtain the name of the MaxCompute project that is associated with the workspace.
        self.workspace_id = workspace_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(RevokeColumnPermissionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.columns is not None:
            result['Columns'] = self.columns
        if self.max_compute_project_name is not None:
            result['MaxComputeProjectName'] = self.max_compute_project_name
        if self.revoke_user_id is not None:
            result['RevokeUserId'] = self.revoke_user_id
        if self.revoke_user_name is not None:
            result['RevokeUserName'] = self.revoke_user_name
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.workspace_id is not None:
            result['WorkspaceId'] = self.workspace_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Columns') is not None:
            self.columns = m.get('Columns')
        if m.get('MaxComputeProjectName') is not None:
            self.max_compute_project_name = m.get('MaxComputeProjectName')
        if m.get('RevokeUserId') is not None:
            self.revoke_user_id = m.get('RevokeUserId')
        if m.get('RevokeUserName') is not None:
            self.revoke_user_name = m.get('RevokeUserName')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


class RevokeColumnPermissionResponseBody(TeaModel):
    def __init__(self, request_id=None, revoke_success=None):
        self.request_id = request_id  # type: str
        # The ID of the request.
        self.revoke_success = revoke_success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(RevokeColumnPermissionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.revoke_success is not None:
            result['RevokeSuccess'] = self.revoke_success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('RevokeSuccess') is not None:
            self.revoke_success = m.get('RevokeSuccess')
        return self


class RevokeColumnPermissionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: RevokeColumnPermissionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(RevokeColumnPermissionResponse, self).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=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 = RevokeColumnPermissionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RevokeTablePermissionRequest(TeaModel):
    def __init__(self, actions=None, max_compute_project_name=None, revoke_user_id=None, revoke_user_name=None,
                 table_name=None, workspace_id=None):
        # The permissions that you want to revoke. Separate multiple permissions with commas (,).
        # 
        # You can revoke only the SELECT, DESCRIBE, and DOWNLOAD permissions on MaxCompute tables.
        self.actions = actions  # type: str
        # The name of the MaxCompute project to which the table belongs. You can log on to the DataWorks console and go to the Workspace Management page to obtain the MaxCompute project name.
        self.max_compute_project_name = max_compute_project_name  # type: str
        # The ID of the Alibaba Cloud account from which you want to revoke permissions. You can log on to the DataWorks console and go to the Security Settings page to obtain the ID.
        # 
        # You must specify either this parameter or RevokeUserName. If you specify both this parameter and RevokeUserName, the value of this parameter prevails.
        self.revoke_user_id = revoke_user_id  # type: str
        # The Alibaba Cloud account from which you want to revoke permissions. Specify this parameter in the format that is the same as the format of the account used to access the MaxCompute project.
        # 
        # *   If you want to revoke permissions from an Alibaba Cloud account, specify this parameter in the ALIYUN$+Alibaba Cloud account format.
        # *   If you want to revoke permissions from a Resource Access Management (RAM) user, specify this parameter in the RAM$+RAM user format.
        # 
        # You must specify either this parameter or RevokeUserId. If you specify both this parameter and RevokeUserId, the value of RevokeUserId prevails.
        self.revoke_user_name = revoke_user_name  # type: str
        # The name of the MaxCompute table. You can call the [SearchMetaTables](~~173919~~) operation to query the table name.
        self.table_name = table_name  # type: str
        # The ID of the DataWorks workspace with which the MaxCompute project is associated. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID.
        self.workspace_id = workspace_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(RevokeTablePermissionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.actions is not None:
            result['Actions'] = self.actions
        if self.max_compute_project_name is not None:
            result['MaxComputeProjectName'] = self.max_compute_project_name
        if self.revoke_user_id is not None:
            result['RevokeUserId'] = self.revoke_user_id
        if self.revoke_user_name is not None:
            result['RevokeUserName'] = self.revoke_user_name
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.workspace_id is not None:
            result['WorkspaceId'] = self.workspace_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Actions') is not None:
            self.actions = m.get('Actions')
        if m.get('MaxComputeProjectName') is not None:
            self.max_compute_project_name = m.get('MaxComputeProjectName')
        if m.get('RevokeUserId') is not None:
            self.revoke_user_id = m.get('RevokeUserId')
        if m.get('RevokeUserName') is not None:
            self.revoke_user_name = m.get('RevokeUserName')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


class RevokeTablePermissionResponseBody(TeaModel):
    def __init__(self, request_id=None, revoke_success=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the permissions on the table are revoked.
        self.revoke_success = revoke_success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(RevokeTablePermissionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.revoke_success is not None:
            result['RevokeSuccess'] = self.revoke_success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('RevokeSuccess') is not None:
            self.revoke_success = m.get('RevokeSuccess')
        return self


class RevokeTablePermissionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: RevokeTablePermissionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(RevokeTablePermissionResponse, self).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=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 = RevokeTablePermissionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RunCycleDagNodesRequest(TeaModel):
    def __init__(self, biz_begin_time=None, biz_end_time=None, end_biz_date=None, exclude_node_ids=None,
                 include_node_ids=None, name=None, node_params=None, parallelism=None, project_env=None, root_node_id=None,
                 start_biz_date=None, start_future_instance_immediately=None):
        # The time when the node started to run. This parameter is required only for auto triggered nodes that are scheduled by hour. Specify the value in the HH:mm:ss format. Valid values: 00:00:00 to 23:59:59.
        self.biz_begin_time = biz_begin_time  # type: str
        # The time when the node stopped running. This parameter is required only for auto triggered nodes that are scheduled by hour. Specify the value in the HH:mm:ss format. Valid values: 00:00:00 to 23:59:59.
        self.biz_end_time = biz_end_time  # type: str
        # The data timestamp at which data is no longer backfilled. Specify the value in the yyyy-MM-dd 00:00:00 format.
        self.end_biz_date = end_biz_date  # type: str
        # The IDs of the nodes for which no data needs to be backfilled. The system generates dry-run instances for all these nodes. After these dry-run instances are scheduled, the statuses of these instances are directly set to successful, but the script is not run.
        self.exclude_node_ids = exclude_node_ids  # type: str
        # The ID of the node for which you want to backfill data. If you want to backfill data for multiple nodes, separate the IDs of the nodes with commas (,). You can call the [ListNodes](~~173979~~) operation to query the ID.
        self.include_node_ids = include_node_ids  # type: str
        # The name of the workflow.
        self.name = name  # type: str
        # The parameters that need to be configured for the node. Set this parameter to a JSON string. The key indicates the ID of the node, and the value indicates the actual values of the parameters.
        self.node_params = node_params  # type: str
        # Specifies whether data can be backfilled for multiple nodes at the same time.
        self.parallelism = parallelism  # type: bool
        # The environment of the workspace. Valid values: PROD and DEV. The value PROD indicates the production environment, and the value DEV indicates the development environment.
        self.project_env = project_env  # type: str
        # The ID of the node for which data is first backfilled. You can call the [ListNodes](~~173979~~) operation to query the ID.
        self.root_node_id = root_node_id  # type: long
        # The data timestamp at which data starts to be backfilled. Specify the value in the yyyy-MM-dd 00:00:00 format.
        self.start_biz_date = start_biz_date  # type: str
        # Specifies whether to immediately run an instance that is scheduled to run in the future. If you set this parameter to true, the instance that is scheduled to run in the future is run immediately. Otherwise, the instance is run as scheduled.
        self.start_future_instance_immediately = start_future_instance_immediately  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(RunCycleDagNodesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_begin_time is not None:
            result['BizBeginTime'] = self.biz_begin_time
        if self.biz_end_time is not None:
            result['BizEndTime'] = self.biz_end_time
        if self.end_biz_date is not None:
            result['EndBizDate'] = self.end_biz_date
        if self.exclude_node_ids is not None:
            result['ExcludeNodeIds'] = self.exclude_node_ids
        if self.include_node_ids is not None:
            result['IncludeNodeIds'] = self.include_node_ids
        if self.name is not None:
            result['Name'] = self.name
        if self.node_params is not None:
            result['NodeParams'] = self.node_params
        if self.parallelism is not None:
            result['Parallelism'] = self.parallelism
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.root_node_id is not None:
            result['RootNodeId'] = self.root_node_id
        if self.start_biz_date is not None:
            result['StartBizDate'] = self.start_biz_date
        if self.start_future_instance_immediately is not None:
            result['StartFutureInstanceImmediately'] = self.start_future_instance_immediately
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizBeginTime') is not None:
            self.biz_begin_time = m.get('BizBeginTime')
        if m.get('BizEndTime') is not None:
            self.biz_end_time = m.get('BizEndTime')
        if m.get('EndBizDate') is not None:
            self.end_biz_date = m.get('EndBizDate')
        if m.get('ExcludeNodeIds') is not None:
            self.exclude_node_ids = m.get('ExcludeNodeIds')
        if m.get('IncludeNodeIds') is not None:
            self.include_node_ids = m.get('IncludeNodeIds')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('NodeParams') is not None:
            self.node_params = m.get('NodeParams')
        if m.get('Parallelism') is not None:
            self.parallelism = m.get('Parallelism')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('RootNodeId') is not None:
            self.root_node_id = m.get('RootNodeId')
        if m.get('StartBizDate') is not None:
            self.start_biz_date = m.get('StartBizDate')
        if m.get('StartFutureInstanceImmediately') is not None:
            self.start_future_instance_immediately = m.get('StartFutureInstanceImmediately')
        return self


class RunCycleDagNodesResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The IDs of the nodes in the workflow.
        self.data = data  # type: list[long]
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(RunCycleDagNodesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class RunCycleDagNodesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: RunCycleDagNodesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(RunCycleDagNodesResponse, self).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=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 = RunCycleDagNodesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RunManualDagNodesRequest(TeaModel):
    def __init__(self, biz_date=None, dag_parameters=None, end_biz_date=None, exclude_node_ids=None, flow_name=None,
                 include_node_ids=None, node_parameters=None, project_env=None, project_id=None, project_name=None,
                 start_biz_date=None):
        # The parameters transmitted between nodes in the manually triggered workflow. The parameters are in the following JSON format: { "\<ID of a node in the manually triggered workflow>": "Scheduling parameter settings of the node, which are in the same format as the Parameters parameter on the Properties tab of the DataStudio page", "\<ID of a node in the manually triggered workflow>": "Scheduling parameter settings of the node, which are in the same format as the Parameters parameter on the Properties tab of the DataStudio page" }.
        self.biz_date = biz_date  # type: str
        # The IDs of the nodes that you need to run in the manually triggered workflow. Separate multiple node IDs with commas (,). You can call the ListNodes operation to query the node IDs.
        self.dag_parameters = dag_parameters  # type: str
        self.end_biz_date = end_biz_date  # type: str
        # The ID of the workspace to which the manually triggered workflow belongs.
        self.exclude_node_ids = exclude_node_ids  # type: str
        # The data timestamp. The value must be one or more days before the current date. For example, if the current date is November 11, 2020, set the value to 2020-11-10 00:00:00 or earlier. Specify this parameter in the YYYY-MM-DD 00:00:00 format.
        self.flow_name = flow_name  # type: str
        # The IDs of the nodes that you do not need to run in the manually triggered workflow. The system generates dry-run instances for all these nodes. After the dry-run instances are scheduled, the states of these instances are directly set to successful, but the scripts are not run. Separate multiple node IDs with commas (,).
        self.include_node_ids = include_node_ids  # type: str
        # The parameters of the manually triggered workflow, which are synchronized to all the instances in the directed acyclic graph (DAG) of the workflow. If a workflow parameter specified in DagParameters is referenced as a scheduling parameter of a node, the value of the scheduling parameter is replaced with the value of the workflow parameter.
        self.node_parameters = node_parameters  # type: str
        # The name of the workspace to which the manually triggered workflow belongs.
        self.project_env = project_env  # type: str
        # The ID of the DAG for the manually triggered workflow. You can call an operation with this parameter as a request parameter to query the details and statuses of the nodes in this manually triggered workflow.
        self.project_id = project_id  # type: long
        # The name of the manually triggered workflow.
        self.project_name = project_name  # type: str
        self.start_biz_date = start_biz_date  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(RunManualDagNodesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.dag_parameters is not None:
            result['DagParameters'] = self.dag_parameters
        if self.end_biz_date is not None:
            result['EndBizDate'] = self.end_biz_date
        if self.exclude_node_ids is not None:
            result['ExcludeNodeIds'] = self.exclude_node_ids
        if self.flow_name is not None:
            result['FlowName'] = self.flow_name
        if self.include_node_ids is not None:
            result['IncludeNodeIds'] = self.include_node_ids
        if self.node_parameters is not None:
            result['NodeParameters'] = self.node_parameters
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.start_biz_date is not None:
            result['StartBizDate'] = self.start_biz_date
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('DagParameters') is not None:
            self.dag_parameters = m.get('DagParameters')
        if m.get('EndBizDate') is not None:
            self.end_biz_date = m.get('EndBizDate')
        if m.get('ExcludeNodeIds') is not None:
            self.exclude_node_ids = m.get('ExcludeNodeIds')
        if m.get('FlowName') is not None:
            self.flow_name = m.get('FlowName')
        if m.get('IncludeNodeIds') is not None:
            self.include_node_ids = m.get('IncludeNodeIds')
        if m.get('NodeParameters') is not None:
            self.node_parameters = m.get('NodeParameters')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('StartBizDate') is not None:
            self.start_biz_date = m.get('StartBizDate')
        return self


class RunManualDagNodesResponseBody(TeaModel):
    def __init__(self, dag_id=None, request_id=None):
        # The ID of the request.
        self.dag_id = dag_id  # type: long
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(RunManualDagNodesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dag_id is not None:
            result['DagId'] = self.dag_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DagId') is not None:
            self.dag_id = m.get('DagId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class RunManualDagNodesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: RunManualDagNodesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(RunManualDagNodesResponse, self).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=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 = RunManualDagNodesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RunSmokeTestRequest(TeaModel):
    def __init__(self, bizdate=None, name=None, node_id=None, node_params=None, project_env=None):
        # The data timestamp.
        self.bizdate = bizdate  # type: str
        # The name of the workflow.
        self.name = name  # type: str
        # The ID of the node. You can call the [ListNodes](~~173979~~) operation to query the ID.
        self.node_id = node_id  # type: long
        # The parameters related to the node. Set this parameter to a JSON string. A key in the string indicates a parameter, and a value in the string indicates the value of the related parameter.
        self.node_params = node_params  # type: str
        # The environment of the workspace. Valid values: PROD and DEV. The value PROD indicates the production environment, and the value DEV indicates the development environment.
        # 
        # A workspace in basic mode does not have a development environment. For more information, see [Basic mode and standard mode](~~85772~~).
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(RunSmokeTestRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.name is not None:
            result['Name'] = self.name
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_params is not None:
            result['NodeParams'] = self.node_params
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeParams') is not None:
            self.node_params = m.get('NodeParams')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class RunSmokeTestResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the workflow.
        self.data = data  # type: long
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(RunSmokeTestResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class RunSmokeTestResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: RunSmokeTestResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(RunSmokeTestResponse, self).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=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 = RunSmokeTestResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RunTriggerNodeRequest(TeaModel):
    def __init__(self, app_id=None, biz_date=None, cycle_time=None, node_id=None):
        # The ID of the DataWorks workspace to which the manually triggered node belongs. You can call the [ListProjects](~~178393~~) operation to query the ID.
        self.app_id = app_id  # type: long
        # The data timestamp of the manually triggered node instance.
        self.biz_date = biz_date  # type: long
        # The scheduled time to run the manually triggered node. Set the value to a 13-digit timestamp in milliseconds.
        self.cycle_time = cycle_time  # type: long
        # The ID of the manually triggered node. You can call the [ListNodes](~~173979~~) operation to query the ID.
        self.node_id = node_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(RunTriggerNodeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.app_id is not None:
            result['AppId'] = self.app_id
        if self.biz_date is not None:
            result['BizDate'] = self.biz_date
        if self.cycle_time is not None:
            result['CycleTime'] = self.cycle_time
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AppId') is not None:
            self.app_id = m.get('AppId')
        if m.get('BizDate') is not None:
            self.biz_date = m.get('BizDate')
        if m.get('CycleTime') is not None:
            self.cycle_time = m.get('CycleTime')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        return self


class RunTriggerNodeResponseBody(TeaModel):
    def __init__(self, request_id=None, success=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(RunTriggerNodeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class RunTriggerNodeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: RunTriggerNodeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(RunTriggerNodeResponse, self).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=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 = RunTriggerNodeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SaveDataServiceApiTestResultRequest(TeaModel):
    def __init__(self, api_id=None, auto_generate=None, fail_result_sample=None, project_id=None,
                 result_sample=None):
        self.api_id = api_id  # type: long
        self.auto_generate = auto_generate  # type: bool
        self.fail_result_sample = fail_result_sample  # type: str
        self.project_id = project_id  # type: long
        self.result_sample = result_sample  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(SaveDataServiceApiTestResultRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.auto_generate is not None:
            result['AutoGenerate'] = self.auto_generate
        if self.fail_result_sample is not None:
            result['FailResultSample'] = self.fail_result_sample
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.result_sample is not None:
            result['ResultSample'] = self.result_sample
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('AutoGenerate') is not None:
            self.auto_generate = m.get('AutoGenerate')
        if m.get('FailResultSample') is not None:
            self.fail_result_sample = m.get('FailResultSample')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ResultSample') is not None:
            self.result_sample = m.get('ResultSample')
        return self


class SaveDataServiceApiTestResultResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        self.data = data  # type: bool
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(SaveDataServiceApiTestResultResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class SaveDataServiceApiTestResultResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: SaveDataServiceApiTestResultResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(SaveDataServiceApiTestResultResponse, self).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=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 = SaveDataServiceApiTestResultResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ScanSensitiveDataRequest(TeaModel):
    def __init__(self, data=None):
        # The data that you want to check.
        self.data = data  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(ScanSensitiveDataRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        return self


class ScanSensitiveDataResponseBody(TeaModel):
    def __init__(self, request_id=None, sensitives=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # The result of the check.
        # 
        # sensDatas indicates the rules that are used to check the sensitive data. sensDatas includes the following parameters:
        # 
        # *   hitCount: the number of times that the sensitive data hits the rule
        # *   ruleName: the name of the rule
        self.sensitives = sensitives  # type: dict[str, any]

    def validate(self):
        pass

    def to_map(self):
        _map = super(ScanSensitiveDataResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.sensitives is not None:
            result['Sensitives'] = self.sensitives
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Sensitives') is not None:
            self.sensitives = m.get('Sensitives')
        return self


class ScanSensitiveDataResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ScanSensitiveDataResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(ScanSensitiveDataResponse, self).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=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 = ScanSensitiveDataResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SearchMetaTablesRequest(TeaModel):
    def __init__(self, app_guid=None, cluster_id=None, data_source_type=None, entity_type=None, keyword=None,
                 page_number=None, page_size=None, schema=None):
        # The type of the metatables. Valid values: 0 and 1. The value 0 indicates that tables are queried. The value 1 indicates that views are queried. If you do not configure this parameter, all types of metatables are queried.
        self.app_guid = app_guid  # type: str
        # The schema information of the table. You need to configure this parameter if you enable the table schema in MaxCompute.
        self.cluster_id = cluster_id  # type: str
        # The HTTP status code returned.
        self.data_source_type = data_source_type  # type: str
        # The type of the data source. Valid values: odps and emr.
        self.entity_type = entity_type  # type: int
        # The ID of the EMR cluster. This parameter is required only if you set the DataSourceType parameter to emr.
        # 
        # You can log on to the [EMR console](https://emr.console.aliyun.com/?spm=a2c4g.11186623.0.0.965cc5c2GeiHet#/cn-hangzhou) to obtain the ID of the EMR cluster.
        self.keyword = keyword  # type: str
        # The GUID of the workspace where the metatables reside.
        self.page_number = page_number  # type: int
        # The keyword based on which metatables are queried. During the query, the system tokenizes the names of metatables and matches the names with the keyword. If no name is matched, an empty result is returned. By default, the system uses underscores (\_) to tokenize the names.
        self.page_size = page_size  # type: int
        # The error message returned.
        self.schema = schema  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(SearchMetaTablesRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.app_guid is not None:
            result['AppGuid'] = self.app_guid
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.data_source_type is not None:
            result['DataSourceType'] = self.data_source_type
        if self.entity_type is not None:
            result['EntityType'] = self.entity_type
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.schema is not None:
            result['Schema'] = self.schema
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AppGuid') is not None:
            self.app_guid = m.get('AppGuid')
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DataSourceType') is not None:
            self.data_source_type = m.get('DataSourceType')
        if m.get('EntityType') is not None:
            self.entity_type = m.get('EntityType')
        if m.get('Keyword') is not None:
            self.keyword = m.get('Keyword')
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('Schema') is not None:
            self.schema = m.get('Schema')
        return self


class SearchMetaTablesResponseBodyDataDataEntityList(TeaModel):
    def __init__(self, cluster_id=None, database_name=None, entity_type=None, env_type=None, owner_id=None,
                 project_id=None, project_name=None, schema=None, table_guid=None, table_name=None, tenant_id=None):
        # The ID of the tenant.
        self.cluster_id = cluster_id  # type: str
        # The name of the workspace.
        self.database_name = database_name  # type: str
        # The ID of the workspace.
        self.entity_type = entity_type  # type: int
        # The schema information of the table. This parameter is returned only if you enable the table schema in MaxCompute.
        self.env_type = env_type  # type: int
        # The type of the environment. Valid values:
        # 
        # *   1: production environment
        # *   0: development environment
        self.owner_id = owner_id  # type: str
        # The ID of the Alibaba Cloud account used by the workspace owner.
        self.project_id = project_id  # type: long
        # The GUID of the metatable.
        self.project_name = project_name  # type: str
        self.schema = schema  # type: str
        # The ID of the EMR cluster.
        self.table_guid = table_guid  # type: str
        # The type of the metatable. Valid values:
        # 
        # *   0: table
        # *   1: view
        self.table_name = table_name  # type: str
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(SearchMetaTablesResponseBodyDataDataEntityList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cluster_id is not None:
            result['ClusterId'] = self.cluster_id
        if self.database_name is not None:
            result['DatabaseName'] = self.database_name
        if self.entity_type is not None:
            result['EntityType'] = self.entity_type
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.schema is not None:
            result['Schema'] = self.schema
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClusterId') is not None:
            self.cluster_id = m.get('ClusterId')
        if m.get('DatabaseName') is not None:
            self.database_name = m.get('DatabaseName')
        if m.get('EntityType') is not None:
            self.entity_type = m.get('EntityType')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('Schema') is not None:
            self.schema = m.get('Schema')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class SearchMetaTablesResponseBodyData(TeaModel):
    def __init__(self, data_entity_list=None, page_number=None, page_size=None, total_count=None):
        # The name of the metadatabase.
        self.data_entity_list = data_entity_list  # type: list[SearchMetaTablesResponseBodyDataDataEntityList]
        # The total number of metatables.
        self.page_number = page_number  # type: int
        # The list of metatables.
        self.page_size = page_size  # type: int
        # The name of the metatable.
        self.total_count = total_count  # type: long

    def validate(self):
        if self.data_entity_list:
            for k in self.data_entity_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(SearchMetaTablesResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['DataEntityList'] = []
        if self.data_entity_list is not None:
            for k in self.data_entity_list:
                result['DataEntityList'].append(k.to_map() if k else None)
        if self.page_number is not None:
            result['PageNumber'] = self.page_number
        if self.page_size is not None:
            result['PageSize'] = self.page_size
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.data_entity_list = []
        if m.get('DataEntityList') is not None:
            for k in m.get('DataEntityList'):
                temp_model = SearchMetaTablesResponseBodyDataDataEntityList()
                self.data_entity_list.append(temp_model.from_map(k))
        if m.get('PageNumber') is not None:
            self.page_number = m.get('PageNumber')
        if m.get('PageSize') is not None:
            self.page_size = m.get('PageSize')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


class SearchMetaTablesResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The number of entries returned per page.
        self.data = data  # type: SearchMetaTablesResponseBodyData
        # The page number of the returned page.
        self.error_code = error_code  # type: str
        # Indicates whether the request is successful.
        self.error_message = error_message  # type: str
        # The ID of the request.
        self.http_status_code = http_status_code  # type: int
        # The error code returned.
        self.request_id = request_id  # type: str
        # The business data returned.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(SearchMetaTablesResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data.to_map()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = SearchMetaTablesResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class SearchMetaTablesResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: SearchMetaTablesResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(SearchMetaTablesResponse, self).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=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 = SearchMetaTablesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SearchNodesByOutputRequest(TeaModel):
    def __init__(self, outputs=None, project_env=None):
        self.outputs = outputs  # type: str
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(SearchNodesByOutputRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.outputs is not None:
            result['Outputs'] = self.outputs
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Outputs') is not None:
            self.outputs = m.get('Outputs')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class SearchNodesByOutputResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: dict[str, any]
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(SearchNodesByOutputResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class SearchNodesByOutputResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: SearchNodesByOutputResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(SearchNodesByOutputResponse, self).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=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 = SearchNodesByOutputResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SetDataSourceShareRequest(TeaModel):
    def __init__(self, datasource_name=None, env_type=None, project_id=None, project_permissions=None,
                 user_permissions=None):
        # The name of the data source to be shared.
        self.datasource_name = datasource_name  # type: str
        # The environment to which the data source belongs. Valid values:
        # 
        # *   0: development environment
        # *   1: production environment
        self.env_type = env_type  # type: str
        # The ID of the DataWorks workspace to which the data source belongs. You can call the [ListProjects](~~178393~~) operation to query the ID of the workspace.
        self.project_id = project_id  # type: long
        # The DataWorks workspace to which the data source is to be shared. If you set this parameter, all members of the specified DataWorks workspace can view and use the data source. The value must be a JSON array. Example: {"projectId":1000,"permission":"WRITE","sharedName":"PX_DATAHUB1.shared_name"}.
        # 
        # Field description:
        # 
        # *   projectId: the ID of the DataWorks workspace to which the data source is to be shared.
        # *   permission: the mode in which the data source is shared. Valid values: READ and WRITE. The value READ indicates that all members of the specified workspace can read data from the data source, but cannot modify the data. The value WRITE indicates that all members of the specified workspace can modify the data in the data source.
        # *   sharedName: the name of the data source to be shared.
        self.project_permissions = project_permissions  # type: str
        # The user to whom the data source is to be shared. If you set this parameter, the specified user can view or use the data source. The value must be a JSON array. Example: {"projectId":10000,"users":\[{"userId":"276184575345452131","permission":"WRITE"},"sharedName":"PX_DATAHUB1.shared_name"}].
        # 
        # Field description:
        # 
        # *   projectId: the ID of the DataWorks workspace. If you set the UserPermissions parameter, the specified user can view or use the data source only in this specified DataWorks workspace.
        # *   userId: the ID of the user to whom the data source is to be shared.
        # *   permission: the mode in which the data source is shared. Valid values: READ and WRITE. The value READ indicates that the specified user can read data from the data source, but cannot modify the data. The value WRITE indicates that the specified user can modify the data in the data source.
        # *   sharedName: the name of the data source to be shared.
        # 
        # If the ProjectPermissions and UserPermissions parameters are both left empty, the specified data source is not shared to any DataWorks workspace or user. If neither of the parameters is left empty, both parameters take effect.
        self.user_permissions = user_permissions  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(SetDataSourceShareRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.datasource_name is not None:
            result['DatasourceName'] = self.datasource_name
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_permissions is not None:
            result['ProjectPermissions'] = self.project_permissions
        if self.user_permissions is not None:
            result['UserPermissions'] = self.user_permissions
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DatasourceName') is not None:
            self.datasource_name = m.get('DatasourceName')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectPermissions') is not None:
            self.project_permissions = m.get('ProjectPermissions')
        if m.get('UserPermissions') is not None:
            self.user_permissions = m.get('UserPermissions')
        return self


class SetDataSourceShareResponseBodyData(TeaModel):
    def __init__(self, message=None, status=None):
        # The reason why the data source failed to be shared. If the data source was shared, this parameter is left empty.
        self.message = message  # type: str
        # Indicates whether the data source was shared. Valid values:
        # 
        # *   success: The data source was shared.
        # *   fail: The data source failed to be shared. You can troubleshoot issues based on the Message parameter.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(SetDataSourceShareResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class SetDataSourceShareResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # The information about the sharing operation.
        self.data = data  # type: SetDataSourceShareResponseBodyData
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(SetDataSourceShareResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = SetDataSourceShareResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class SetDataSourceShareResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: SetDataSourceShareResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(SetDataSourceShareResponse, self).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=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 = SetDataSourceShareResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SetEntityTagsRequest(TeaModel):
    def __init__(self, qualified_name=None, tags=None):
        self.qualified_name = qualified_name  # type: str
        self.tags = tags  # type: list[UserEntityTag]

    def validate(self):
        if self.tags:
            for k in self.tags:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(SetEntityTagsRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        result['Tags'] = []
        if self.tags is not None:
            for k in self.tags:
                result['Tags'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        self.tags = []
        if m.get('Tags') is not None:
            for k in m.get('Tags'):
                temp_model = UserEntityTag()
                self.tags.append(temp_model.from_map(k))
        return self


class SetEntityTagsShrinkRequest(TeaModel):
    def __init__(self, qualified_name=None, tags_shrink=None):
        self.qualified_name = qualified_name  # type: str
        self.tags_shrink = tags_shrink  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(SetEntityTagsShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        if self.tags_shrink is not None:
            result['Tags'] = self.tags_shrink
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        if m.get('Tags') is not None:
            self.tags_shrink = m.get('Tags')
        return self


class SetEntityTagsResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: bool
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(SetEntityTagsResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class SetEntityTagsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: SetEntityTagsResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(SetEntityTagsResponse, self).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=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 = SetEntityTagsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SetSuccessInstanceRequest(TeaModel):
    def __init__(self, instance_id=None, project_env=None):
        # The environment of the workspace. Valid values: PROD and DEV.
        self.instance_id = instance_id  # type: long
        # The HTTP status code.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(SetSuccessInstanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class SetSuccessInstanceResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The error message.
        self.data = data  # type: bool
        # Indicates whether the request is successful.
        self.error_code = error_code  # type: str
        # The ID of the request.
        self.error_message = error_message  # type: str
        # Indicates whether result details are returned.
        self.http_status_code = http_status_code  # type: int
        # The error code.
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(SetSuccessInstanceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class SetSuccessInstanceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: SetSuccessInstanceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(SetSuccessInstanceResponse, self).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=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 = SetSuccessInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class StartDIJobRequestRealtimeStartSettingsFailoverSettings(TeaModel):
    def __init__(self, interval=None, upper_limit=None):
        self.interval = interval  # type: long
        self.upper_limit = upper_limit  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(StartDIJobRequestRealtimeStartSettingsFailoverSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.interval is not None:
            result['Interval'] = self.interval
        if self.upper_limit is not None:
            result['UpperLimit'] = self.upper_limit
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Interval') is not None:
            self.interval = m.get('Interval')
        if m.get('UpperLimit') is not None:
            self.upper_limit = m.get('UpperLimit')
        return self


class StartDIJobRequestRealtimeStartSettings(TeaModel):
    def __init__(self, failover_settings=None, start_time=None):
        self.failover_settings = failover_settings  # type: StartDIJobRequestRealtimeStartSettingsFailoverSettings
        self.start_time = start_time  # type: long

    def validate(self):
        if self.failover_settings:
            self.failover_settings.validate()

    def to_map(self):
        _map = super(StartDIJobRequestRealtimeStartSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.failover_settings is not None:
            result['FailoverSettings'] = self.failover_settings.to_map()
        if self.start_time is not None:
            result['StartTime'] = self.start_time
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FailoverSettings') is not None:
            temp_model = StartDIJobRequestRealtimeStartSettingsFailoverSettings()
            self.failover_settings = temp_model.from_map(m['FailoverSettings'])
        if m.get('StartTime') is not None:
            self.start_time = m.get('StartTime')
        return self


class StartDIJobRequest(TeaModel):
    def __init__(self, dijob_id=None, force_to_rerun=None, realtime_start_settings=None):
        self.dijob_id = dijob_id  # type: long
        self.force_to_rerun = force_to_rerun  # type: bool
        self.realtime_start_settings = realtime_start_settings  # type: StartDIJobRequestRealtimeStartSettings

    def validate(self):
        if self.realtime_start_settings:
            self.realtime_start_settings.validate()

    def to_map(self):
        _map = super(StartDIJobRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.force_to_rerun is not None:
            result['ForceToRerun'] = self.force_to_rerun
        if self.realtime_start_settings is not None:
            result['RealtimeStartSettings'] = self.realtime_start_settings.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('ForceToRerun') is not None:
            self.force_to_rerun = m.get('ForceToRerun')
        if m.get('RealtimeStartSettings') is not None:
            temp_model = StartDIJobRequestRealtimeStartSettings()
            self.realtime_start_settings = temp_model.from_map(m['RealtimeStartSettings'])
        return self


class StartDIJobShrinkRequest(TeaModel):
    def __init__(self, dijob_id=None, force_to_rerun=None, realtime_start_settings_shrink=None):
        self.dijob_id = dijob_id  # type: long
        self.force_to_rerun = force_to_rerun  # type: bool
        self.realtime_start_settings_shrink = realtime_start_settings_shrink  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(StartDIJobShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.force_to_rerun is not None:
            result['ForceToRerun'] = self.force_to_rerun
        if self.realtime_start_settings_shrink is not None:
            result['RealtimeStartSettings'] = self.realtime_start_settings_shrink
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('ForceToRerun') is not None:
            self.force_to_rerun = m.get('ForceToRerun')
        if m.get('RealtimeStartSettings') is not None:
            self.realtime_start_settings_shrink = m.get('RealtimeStartSettings')
        return self


class StartDIJobResponseBody(TeaModel):
    def __init__(self, request_id=None):
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(StartDIJobResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class StartDIJobResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: StartDIJobResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(StartDIJobResponse, self).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=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 = StartDIJobResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class StartDISyncInstanceRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, start_param=None, task_type=None):
        # *   If you set the TaskType parameter to DI_REALTIME, the StartParam parameter specifies the startup parameters for the real-time synchronization node. The startup parameters include failover-related parameters, the parameter that specifies the number of dirty data records allowed, and the parameters in the data definition language (DDL) statements.
        # *   If you set the TaskType parameter to DI_SOLUTION, the StartParam parameter does not take effect.
        self.file_id = file_id  # type: long
        # The type of the Data Integration object that you want to start. Valid values:
        # 
        # *   DI_REALTIME: real-time synchronization node
        # *   DI_SOLUTION: data synchronization solution
        self.project_id = project_id  # type: long
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request succeeded.
        # *   false: The request failed.
        self.start_param = start_param  # type: str
        # *   If you set the TaskType parameter to DI_REALTIME, set the FileId parameter to the ID of the real-time synchronization node that you want to start.
        # *   If you set the TaskType parameter to DI_SOLUTION, set the FileId parameter to the ID of the data synchronization solution that you want to start.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(StartDISyncInstanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.start_param is not None:
            result['StartParam'] = self.start_param
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('StartParam') is not None:
            self.start_param = m.get('StartParam')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class StartDISyncInstanceResponseBodyData(TeaModel):
    def __init__(self, message=None, status=None):
        self.message = message  # type: str
        # The reason why the real-time synchronization node or the data synchronization solution fails to be started.
        # 
        # If the real-time synchronization node or the data synchronization solution is started, the value null is returned.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(StartDISyncInstanceResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class StartDISyncInstanceResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # Indicates whether the real-time synchronization node or the data synchronization solution is started. Valid values:
        # 
        # *   success: The real-time synchronization node or the data synchronization solution is started.
        # *   fail: The real-time synchronization node or the data synchronization solution fails to be started. You can troubleshoot the issue based on the provided cause.
        self.data = data  # type: StartDISyncInstanceResponseBodyData
        # The result returned for the start.
        self.request_id = request_id  # type: str
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(StartDISyncInstanceResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = StartDISyncInstanceResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class StartDISyncInstanceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: StartDISyncInstanceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(StartDISyncInstanceResponse, self).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=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 = StartDISyncInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class StartMigrationRequest(TeaModel):
    def __init__(self, migration_id=None, project_id=None):
        # The ID of the migration package. You can call the [CreateImportMigration](~~206094~~) operation to obtain the ID of the import package and call the [CreateExportMigration](~~349325~~) operation to obtain the ID of the export package.
        self.migration_id = migration_id  # type: long
        # The ID of the workspace. You can go to the Workspace Management page of the DataWorks console to view the ID.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(StartMigrationRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.migration_id is not None:
            result['MigrationId'] = self.migration_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('MigrationId') is not None:
            self.migration_id = m.get('MigrationId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class StartMigrationResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the migration task is started. Valid values:
        # 
        # *   true: The migration task is started.
        # *   false: The migration task fails to be started.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(StartMigrationResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class StartMigrationResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: StartMigrationResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(StartMigrationResponse, self).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=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 = StartMigrationResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class StopDIJobRequest(TeaModel):
    def __init__(self, dijob_id=None):
        self.dijob_id = dijob_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(StopDIJobRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        return self


class StopDIJobResponseBody(TeaModel):
    def __init__(self, request_id=None):
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(StopDIJobResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class StopDIJobResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: StopDIJobResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(StopDIJobResponse, self).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=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 = StopDIJobResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class StopDISyncInstanceRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, task_type=None):
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.file_id = file_id  # type: long
        # The type of the synchronization node that you want to stop. Set the value to DI_REALTIME.
        # 
        # DI_REALTIME indicates a real-time synchronization node.
        self.project_id = project_id  # type: long
        # The ID of the synchronization node. You can call the [ListFiles](~~173942~~) operation to obtain the ID.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(StopDISyncInstanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class StopDISyncInstanceResponseBodyData(TeaModel):
    def __init__(self, message=None, status=None):
        self.message = message  # type: str
        # The reason why the synchronization node fails to be stopped.
        # 
        # If the synchronization node is stopped, the value null is returned.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(StopDISyncInstanceResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class StopDISyncInstanceResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # Indicates whether the synchronization node is stopped. Valid values:
        # 
        # *   success: The synchronization node is stopped.
        # *   fail: The synchronization node fails to be stopped.
        self.data = data  # type: StopDISyncInstanceResponseBodyData
        # The information returned for the synchronization node.
        self.request_id = request_id  # type: str
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(StopDISyncInstanceResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = StopDISyncInstanceResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class StopDISyncInstanceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: StopDISyncInstanceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(StopDISyncInstanceResponse, self).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=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 = StopDISyncInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class StopInstanceRequest(TeaModel):
    def __init__(self, instance_id=None, project_env=None):
        # The ID of the instance. You can call the [ListInstances](~~173982~~) operation to query the ID.
        self.instance_id = instance_id  # type: long
        # The environment of the workspace. Valid values: PROD and DEV.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(StopInstanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class StopInstanceResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The result returned.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to locate logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(StopInstanceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class StopInstanceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: StopInstanceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(StopInstanceResponse, self).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=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 = StopInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SubmitDataServiceApiRequest(TeaModel):
    def __init__(self, api_id=None, project_id=None, tenant_id=None):
        self.api_id = api_id  # type: long
        self.project_id = project_id  # type: long
        self.tenant_id = tenant_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(SubmitDataServiceApiRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        return self


class SubmitDataServiceApiResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, http_status_code=None, request_id=None, success=None):
        self.data = data  # type: bool
        self.error_code = error_code  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(SubmitDataServiceApiResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class SubmitDataServiceApiResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: SubmitDataServiceApiResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(SubmitDataServiceApiResponse, self).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=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 = SubmitDataServiceApiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SubmitFileRequest(TeaModel):
    def __init__(self, comment=None, file_id=None, project_id=None, project_identifier=None,
                 skip_all_deploy_file_extensions=None):
        # Specifies whether to skip the pre-publish check after the file is committed.
        # 
        # *   false: indicates that the pre-publish check is not skipped. After the file is committed, the pre-publish check is automatically triggered. The file can be deployed only after the file passes the check.
        # *   true: indicates that the pre-publish check is skipped. After the file is submitted, the pre-publish check process is not triggered. You can directly publish the file.
        self.comment = comment  # type: str
        # The description of the commit operation.
        self.file_id = file_id  # type: long
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace name. You must configure either this parameter or the ProjectId parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The ID of the file. You can call the [ListFiles](~~173942~~) operation to query the ID.
        self.project_identifier = project_identifier  # type: str
        # The HTTP status code returned.
        self.skip_all_deploy_file_extensions = skip_all_deploy_file_extensions  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(SubmitFileRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.skip_all_deploy_file_extensions is not None:
            result['SkipAllDeployFileExtensions'] = self.skip_all_deploy_file_extensions
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('SkipAllDeployFileExtensions') is not None:
            self.skip_all_deploy_file_extensions = m.get('SkipAllDeployFileExtensions')
        return self


class SubmitFileResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the request. You can troubleshoot issues based on the ID.
        self.data = data  # type: long
        self.error_code = error_code  # type: str
        # Indicates whether the request is successful.
        self.error_message = error_message  # type: str
        # The ID of the deployment task. The ID is used as the value of a specific request parameter when you call the [GetDeployment](~~173950~~) operation to query the details of the deployment task.
        self.http_status_code = http_status_code  # type: int
        # The error message returned.
        self.request_id = request_id  # type: str
        # The error code returned.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(SubmitFileResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class SubmitFileResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: SubmitFileResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(SubmitFileResponse, self).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=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 = SubmitFileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SuspendInstanceRequest(TeaModel):
    def __init__(self, instance_id=None, project_env=None):
        # The instance ID.
        self.instance_id = instance_id  # type: long
        # The environment of the workspace. Valid values: PROD and DEV.
        self.project_env = project_env  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(SuspendInstanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        return self


class SuspendInstanceResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The result returned.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(SuspendInstanceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class SuspendInstanceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: SuspendInstanceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(SuspendInstanceResponse, self).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=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 = SuspendInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class TerminateDISyncInstanceRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, task_type=None):
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.file_id = file_id  # type: long
        # The type of the node. A value of DI_REALTIME indicates that the node is a real-time synchronization node.
        self.project_id = project_id  # type: long
        # The ID of the real-time synchronization node.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(TerminateDISyncInstanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class TerminateDISyncInstanceResponseBodyData(TeaModel):
    def __init__(self, message=None, status=None):
        self.message = message  # type: str
        # The reason why the real-time synchronization node fails to be terminated. If the real-time synchronization node is terminated, this parameter is left empty.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(TerminateDISyncInstanceResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class TerminateDISyncInstanceResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # Indicates whether the real-time synchronization node is terminated. Valid values:
        # 
        # *   success
        # *   fail
        self.data = data  # type: TerminateDISyncInstanceResponseBodyData
        # The result of the operation.
        self.request_id = request_id  # type: str
        # The ID of the request. You can query logs and troubleshoot issues based on the ID.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(TerminateDISyncInstanceResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = TerminateDISyncInstanceResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class TerminateDISyncInstanceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: TerminateDISyncInstanceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(TerminateDISyncInstanceResponse, self).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=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 = TerminateDISyncInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class TestDataServiceApiRequestBodyParams(TeaModel):
    def __init__(self, param_key=None, param_value=None):
        # The name of the parameter.
        self.param_key = param_key  # type: str
        # The value of the parameter.
        self.param_value = param_value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(TestDataServiceApiRequestBodyParams, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.param_key is not None:
            result['ParamKey'] = self.param_key
        if self.param_value is not None:
            result['ParamValue'] = self.param_value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ParamKey') is not None:
            self.param_key = m.get('ParamKey')
        if m.get('ParamValue') is not None:
            self.param_value = m.get('ParamValue')
        return self


class TestDataServiceApiRequestHeadParams(TeaModel):
    def __init__(self, param_key=None, param_value=None):
        # The name of the parameter.
        self.param_key = param_key  # type: str
        # The value of the parameter.
        self.param_value = param_value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(TestDataServiceApiRequestHeadParams, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.param_key is not None:
            result['ParamKey'] = self.param_key
        if self.param_value is not None:
            result['ParamValue'] = self.param_value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ParamKey') is not None:
            self.param_key = m.get('ParamKey')
        if m.get('ParamValue') is not None:
            self.param_value = m.get('ParamValue')
        return self


class TestDataServiceApiRequestPathParams(TeaModel):
    def __init__(self, param_key=None, param_value=None):
        # The name of the parameter.
        self.param_key = param_key  # type: str
        # The value of the parameter.
        self.param_value = param_value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(TestDataServiceApiRequestPathParams, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.param_key is not None:
            result['ParamKey'] = self.param_key
        if self.param_value is not None:
            result['ParamValue'] = self.param_value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ParamKey') is not None:
            self.param_key = m.get('ParamKey')
        if m.get('ParamValue') is not None:
            self.param_value = m.get('ParamValue')
        return self


class TestDataServiceApiRequestQueryParam(TeaModel):
    def __init__(self, param_key=None, param_value=None):
        # The name of the parameter.
        self.param_key = param_key  # type: str
        # The value of the parameter.
        self.param_value = param_value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(TestDataServiceApiRequestQueryParam, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.param_key is not None:
            result['ParamKey'] = self.param_key
        if self.param_value is not None:
            result['ParamValue'] = self.param_value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ParamKey') is not None:
            self.param_key = m.get('ParamKey')
        if m.get('ParamValue') is not None:
            self.param_value = m.get('ParamValue')
        return self


class TestDataServiceApiRequest(TeaModel):
    def __init__(self, api_id=None, body_content=None, body_params=None, head_params=None, path_params=None,
                 query_param=None):
        # The ID of the DataService Studio API on which the test is performed.
        self.api_id = api_id  # type: long
        # The data of the request body.
        self.body_content = body_content  # type: str
        # The request parameters that are contained in the request body.
        self.body_params = body_params  # type: list[TestDataServiceApiRequestBodyParams]
        # The request parameters that are contained in the request header.
        self.head_params = head_params  # type: list[TestDataServiceApiRequestHeadParams]
        # The request parameters that are contained in the request path.
        self.path_params = path_params  # type: list[TestDataServiceApiRequestPathParams]
        # The request parameters that are contained in the query.
        self.query_param = query_param  # type: list[TestDataServiceApiRequestQueryParam]

    def validate(self):
        if self.body_params:
            for k in self.body_params:
                if k:
                    k.validate()
        if self.head_params:
            for k in self.head_params:
                if k:
                    k.validate()
        if self.path_params:
            for k in self.path_params:
                if k:
                    k.validate()
        if self.query_param:
            for k in self.query_param:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(TestDataServiceApiRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.body_content is not None:
            result['BodyContent'] = self.body_content
        result['BodyParams'] = []
        if self.body_params is not None:
            for k in self.body_params:
                result['BodyParams'].append(k.to_map() if k else None)
        result['HeadParams'] = []
        if self.head_params is not None:
            for k in self.head_params:
                result['HeadParams'].append(k.to_map() if k else None)
        result['PathParams'] = []
        if self.path_params is not None:
            for k in self.path_params:
                result['PathParams'].append(k.to_map() if k else None)
        result['QueryParam'] = []
        if self.query_param is not None:
            for k in self.query_param:
                result['QueryParam'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('BodyContent') is not None:
            self.body_content = m.get('BodyContent')
        self.body_params = []
        if m.get('BodyParams') is not None:
            for k in m.get('BodyParams'):
                temp_model = TestDataServiceApiRequestBodyParams()
                self.body_params.append(temp_model.from_map(k))
        self.head_params = []
        if m.get('HeadParams') is not None:
            for k in m.get('HeadParams'):
                temp_model = TestDataServiceApiRequestHeadParams()
                self.head_params.append(temp_model.from_map(k))
        self.path_params = []
        if m.get('PathParams') is not None:
            for k in m.get('PathParams'):
                temp_model = TestDataServiceApiRequestPathParams()
                self.path_params.append(temp_model.from_map(k))
        self.query_param = []
        if m.get('QueryParam') is not None:
            for k in m.get('QueryParam'):
                temp_model = TestDataServiceApiRequestQueryParam()
                self.query_param.append(temp_model.from_map(k))
        return self


class TestDataServiceApiResponseBodyData(TeaModel):
    def __init__(self, test_id=None):
        # The ID of the test.
        self.test_id = test_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(TestDataServiceApiResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.test_id is not None:
            result['TestId'] = self.test_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TestId') is not None:
            self.test_id = m.get('TestId')
        return self


class TestDataServiceApiResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None):
        # The information about the test.
        self.data = data  # type: TestDataServiceApiResponseBodyData
        # The ID of the request.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(TestDataServiceApiResponseBody, self).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=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = TestDataServiceApiResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class TestDataServiceApiResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: TestDataServiceApiResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(TestDataServiceApiResponse, self).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=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 = TestDataServiceApiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class TestNetworkConnectionRequest(TeaModel):
    def __init__(self, datasource_name=None, env_type=None, project_id=None, resource_group=None):
        # The name of the data source.
        self.datasource_name = datasource_name  # type: str
        # The environment to which the data source belongs. Valid values:
        # 
        # *   0: development environment
        # *   1: production environment
        self.env_type = env_type  # type: str
        # The ID of the DataWorks workspace to which the data source belongs. You can call the [ListProjects](~~178393~~) operation to query the ID of the workspace.
        self.project_id = project_id  # type: long
        # The identifier of the resource group. You can call the [ListResourceGroups](~~173913~~) operation to query the identifier of the resource group.
        self.resource_group = resource_group  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(TestNetworkConnectionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.datasource_name is not None:
            result['DatasourceName'] = self.datasource_name
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.resource_group is not None:
            result['ResourceGroup'] = self.resource_group
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DatasourceName') is not None:
            self.datasource_name = m.get('DatasourceName')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ResourceGroup') is not None:
            self.resource_group = m.get('ResourceGroup')
        return self


class TestNetworkConnectionResponseBodyTaskList(TeaModel):
    def __init__(self, connect_message=None, connect_status=None):
        # The reason why the data source and resource group failed the connectivity test. If data source and the resource group passed the connectivity test, this parameter is left empty.
        self.connect_message = connect_message  # type: str
        # The result of the connectivity test. Valid values:
        # 
        # *   true: The data source and the resource group passed the connectivity test.
        # *   false: The data source and the resource group failed the connectivity test. You can troubleshoot issues based on the ConnectMessage parameter.
        self.connect_status = connect_status  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(TestNetworkConnectionResponseBodyTaskList, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connect_message is not None:
            result['ConnectMessage'] = self.connect_message
        if self.connect_status is not None:
            result['ConnectStatus'] = self.connect_status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectMessage') is not None:
            self.connect_message = m.get('ConnectMessage')
        if m.get('ConnectStatus') is not None:
            self.connect_status = m.get('ConnectStatus')
        return self


class TestNetworkConnectionResponseBody(TeaModel):
    def __init__(self, request_id=None, success=None, task_list=None):
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.success = success  # type: bool
        # The information about the connectivity test.
        self.task_list = task_list  # type: TestNetworkConnectionResponseBodyTaskList

    def validate(self):
        if self.task_list:
            self.task_list.validate()

    def to_map(self):
        _map = super(TestNetworkConnectionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        if self.task_list is not None:
            result['TaskList'] = self.task_list.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        if m.get('TaskList') is not None:
            temp_model = TestNetworkConnectionResponseBodyTaskList()
            self.task_list = temp_model.from_map(m['TaskList'])
        return self


class TestNetworkConnectionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: TestNetworkConnectionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(TestNetworkConnectionResponse, self).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=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 = TestNetworkConnectionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class TopTenElapsedTimeInstanceRequest(TeaModel):
    def __init__(self, project_id=None):
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace ID.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(TopTenElapsedTimeInstanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class TopTenElapsedTimeInstanceResponseBodyInstanceConsumeTimeRankConsumeTimeRank(TeaModel):
    def __init__(self, business_date=None, consumed=None, instance_id=None, node_id=None, node_name=None, owner=None,
                 program_type=None):
        # The data timestamp of the instance.
        self.business_date = business_date  # type: long
        # The running duration of the instance. Unit: seconds.
        self.consumed = consumed  # type: long
        # The ID of the instance.
        self.instance_id = instance_id  # type: long
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The ID of the Alibaba Cloud account used by the owner of the node.
        self.owner = owner  # type: str
        # The type of the node.
        # 
        # Valid values:
        # 
        # 6 (Shell), 10 (ODPS SQL), 11 (ODPS MR), 23 (Data Integration), 24 (ODPS Script), 99 (zero load), 221 (PyODPS 2), 225 (ODPS Spark), 227 (EMR Hive), 228 (EMR Spark), 229 (EMR Spark SQL), 230 (EMR MR), 239 (OSS object inspection), 257 (EMR Shell), 258 (EMR Spark Shell), 259 (EMR Presto), 260 (EMR Impala), 900 (real-time synchronization), 1089 (cross-tenant collaboration), 1091 (Hologres development), 1093 (Hologres SQL), 1100 (assignment), and 1221 (PyODPS 3)
        self.program_type = program_type  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(TopTenElapsedTimeInstanceResponseBodyInstanceConsumeTimeRankConsumeTimeRank, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.business_date is not None:
            result['BusinessDate'] = self.business_date
        if self.consumed is not None:
            result['Consumed'] = self.consumed
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BusinessDate') is not None:
            self.business_date = m.get('BusinessDate')
        if m.get('Consumed') is not None:
            self.consumed = m.get('Consumed')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        return self


class TopTenElapsedTimeInstanceResponseBodyInstanceConsumeTimeRank(TeaModel):
    def __init__(self, consume_time_rank=None, update_time=None):
        # The ranking data of the running durations of the instances.
        self.consume_time_rank = consume_time_rank  # type: list[TopTenElapsedTimeInstanceResponseBodyInstanceConsumeTimeRankConsumeTimeRank]
        # The timestamp at which the ranking of the running durations of the instances was updated.
        self.update_time = update_time  # type: long

    def validate(self):
        if self.consume_time_rank:
            for k in self.consume_time_rank:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(TopTenElapsedTimeInstanceResponseBodyInstanceConsumeTimeRank, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ConsumeTimeRank'] = []
        if self.consume_time_rank is not None:
            for k in self.consume_time_rank:
                result['ConsumeTimeRank'].append(k.to_map() if k else None)
        if self.update_time is not None:
            result['UpdateTime'] = self.update_time
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.consume_time_rank = []
        if m.get('ConsumeTimeRank') is not None:
            for k in m.get('ConsumeTimeRank'):
                temp_model = TopTenElapsedTimeInstanceResponseBodyInstanceConsumeTimeRankConsumeTimeRank()
                self.consume_time_rank.append(temp_model.from_map(k))
        if m.get('UpdateTime') is not None:
            self.update_time = m.get('UpdateTime')
        return self


class TopTenElapsedTimeInstanceResponseBody(TeaModel):
    def __init__(self, instance_consume_time_rank=None, request_id=None):
        # The ranking record of the running durations of the instances.
        self.instance_consume_time_rank = instance_consume_time_rank  # type: TopTenElapsedTimeInstanceResponseBodyInstanceConsumeTimeRank
        # The ID of the request. You can troubleshoot errors based on the ID.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.instance_consume_time_rank:
            self.instance_consume_time_rank.validate()

    def to_map(self):
        _map = super(TopTenElapsedTimeInstanceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_consume_time_rank is not None:
            result['InstanceConsumeTimeRank'] = self.instance_consume_time_rank.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceConsumeTimeRank') is not None:
            temp_model = TopTenElapsedTimeInstanceResponseBodyInstanceConsumeTimeRank()
            self.instance_consume_time_rank = temp_model.from_map(m['InstanceConsumeTimeRank'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class TopTenElapsedTimeInstanceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: TopTenElapsedTimeInstanceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(TopTenElapsedTimeInstanceResponse, self).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=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 = TopTenElapsedTimeInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class TopTenErrorTimesInstanceRequest(TeaModel):
    def __init__(self, project_id=None):
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(TopTenErrorTimesInstanceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class TopTenErrorTimesInstanceResponseBodyInstanceErrorRankErrorRank(TeaModel):
    def __init__(self, count=None, node_id=None, node_name=None, owner=None, program_type=None, project_id=None):
        # The number of errors that occur on the node.
        self.count = count  # type: int
        # The ID of the node.
        self.node_id = node_id  # type: long
        # The name of the node.
        self.node_name = node_name  # type: str
        # The user identifier (UID) of the Alibaba Cloud account used by the owner of the node.
        self.owner = owner  # type: str
        # The type of the node.
        # 
        # Valid values:
        # 
        # 6 (Shell node), 10 (ODPS SQL node), 11 (ODPS MR node), 23 (Data Integration node), 24 (ODPS Script node), 99 (zero load node), 221 (PyODPS 2 node), 225 (ODPS Spark node), 227 (EMR Hive node), 228 (EMR Spark node), 229 (EMR Spark SQL node), 230 (EMR MR node), 239 (OSS object inspection node), 257 (EMR Shell node), 258 (EMR Spark Shell node), 259 (EMR Presto node), 260 (EMR Impala node), 900 (real-time data synchronization node), 1089 (cross-tenant collaboration node), 1091 (Hologres development node), 1093 (Hologres SQL node), 1100 (assignment node), and 1221 (PyODPS 3 node).
        self.program_type = program_type  # type: int
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(TopTenErrorTimesInstanceResponseBodyInstanceErrorRankErrorRank, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.node_name is not None:
            result['NodeName'] = self.node_name
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.program_type is not None:
            result['ProgramType'] = self.program_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Count') is not None:
            self.count = m.get('Count')
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('NodeName') is not None:
            self.node_name = m.get('NodeName')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProgramType') is not None:
            self.program_type = m.get('ProgramType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class TopTenErrorTimesInstanceResponseBodyInstanceErrorRank(TeaModel):
    def __init__(self, error_rank=None, update_time=None):
        # The ranking of nodes on which errors occur within the last month.
        self.error_rank = error_rank  # type: list[TopTenErrorTimesInstanceResponseBodyInstanceErrorRankErrorRank]
        # The time when the ranking was updated.
        self.update_time = update_time  # type: long

    def validate(self):
        if self.error_rank:
            for k in self.error_rank:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(TopTenErrorTimesInstanceResponseBodyInstanceErrorRank, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ErrorRank'] = []
        if self.error_rank is not None:
            for k in self.error_rank:
                result['ErrorRank'].append(k.to_map() if k else None)
        if self.update_time is not None:
            result['UpdateTime'] = self.update_time
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.error_rank = []
        if m.get('ErrorRank') is not None:
            for k in m.get('ErrorRank'):
                temp_model = TopTenErrorTimesInstanceResponseBodyInstanceErrorRankErrorRank()
                self.error_rank.append(temp_model.from_map(k))
        if m.get('UpdateTime') is not None:
            self.update_time = m.get('UpdateTime')
        return self


class TopTenErrorTimesInstanceResponseBody(TeaModel):
    def __init__(self, instance_error_rank=None, request_id=None):
        # The ranking of nodes on which errors occur.
        self.instance_error_rank = instance_error_rank  # type: TopTenErrorTimesInstanceResponseBodyInstanceErrorRank
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str

    def validate(self):
        if self.instance_error_rank:
            self.instance_error_rank.validate()

    def to_map(self):
        _map = super(TopTenErrorTimesInstanceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.instance_error_rank is not None:
            result['InstanceErrorRank'] = self.instance_error_rank.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InstanceErrorRank') is not None:
            temp_model = TopTenErrorTimesInstanceResponseBodyInstanceErrorRank()
            self.instance_error_rank = temp_model.from_map(m['InstanceErrorRank'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class TopTenErrorTimesInstanceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: TopTenErrorTimesInstanceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(TopTenErrorTimesInstanceResponse, self).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=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 = TopTenErrorTimesInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UmountDirectoryRequest(TeaModel):
    def __init__(self, target_id=None, target_type=None, target_user_id=None):
        # The HTTP status code returned. The value 200 indicates that the request was successful.
        self.target_id = target_id  # type: str
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.target_type = target_type  # type: str
        self.target_user_id = target_user_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UmountDirectoryRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.target_id is not None:
            result['TargetId'] = self.target_id
        if self.target_type is not None:
            result['TargetType'] = self.target_type
        if self.target_user_id is not None:
            result['TargetUserId'] = self.target_user_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TargetId') is not None:
            self.target_id = m.get('TargetId')
        if m.get('TargetType') is not None:
            self.target_type = m.get('TargetType')
        if m.get('TargetUserId') is not None:
            self.target_user_id = m.get('TargetUserId')
        return self


class UmountDirectoryResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.data = data  # type: int
        self.error_code = error_code  # type: str
        # The error code returned. The value 200 indicates that the remove task is successful.
        self.error_message = error_message  # type: str
        # The error message returned if the request failed.
        self.http_status_code = http_status_code  # type: int
        # The number of directories that are removed. Valid values:
        # 
        # *   0: No directories are removed. The left-side navigation pane may not contain the specified directory.
        # *   1: One directory is removed.
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UmountDirectoryResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UmountDirectoryResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UmountDirectoryResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UmountDirectoryResponse, self).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=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 = UmountDirectoryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateBaselineRequestAlertSettingsDingRobots(TeaModel):
    def __init__(self, at_all=None, web_url=None):
        self.at_all = at_all  # type: bool
        self.web_url = web_url  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateBaselineRequestAlertSettingsDingRobots, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.at_all is not None:
            result['AtAll'] = self.at_all
        if self.web_url is not None:
            result['WebUrl'] = self.web_url
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AtAll') is not None:
            self.at_all = m.get('AtAll')
        if m.get('WebUrl') is not None:
            self.web_url = m.get('WebUrl')
        return self


class UpdateBaselineRequestAlertSettings(TeaModel):
    def __init__(self, alert_interval=None, alert_maximum=None, alert_methods=None, alert_recipient=None,
                 alert_recipient_type=None, alert_type=None, baseline_alert_enabled=None, ding_robots=None, silence_end_time=None,
                 silence_start_time=None, topic_types=None, webhooks=None):
        self.alert_interval = alert_interval  # type: int
        self.alert_maximum = alert_maximum  # type: int
        self.alert_methods = alert_methods  # type: list[str]
        self.alert_recipient = alert_recipient  # type: str
        self.alert_recipient_type = alert_recipient_type  # type: str
        self.alert_type = alert_type  # type: str
        self.baseline_alert_enabled = baseline_alert_enabled  # type: bool
        self.ding_robots = ding_robots  # type: list[UpdateBaselineRequestAlertSettingsDingRobots]
        self.silence_end_time = silence_end_time  # type: str
        self.silence_start_time = silence_start_time  # type: str
        self.topic_types = topic_types  # type: list[str]
        self.webhooks = webhooks  # type: list[str]

    def validate(self):
        if self.ding_robots:
            for k in self.ding_robots:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(UpdateBaselineRequestAlertSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_interval is not None:
            result['AlertInterval'] = self.alert_interval
        if self.alert_maximum is not None:
            result['AlertMaximum'] = self.alert_maximum
        if self.alert_methods is not None:
            result['AlertMethods'] = self.alert_methods
        if self.alert_recipient is not None:
            result['AlertRecipient'] = self.alert_recipient
        if self.alert_recipient_type is not None:
            result['AlertRecipientType'] = self.alert_recipient_type
        if self.alert_type is not None:
            result['AlertType'] = self.alert_type
        if self.baseline_alert_enabled is not None:
            result['BaselineAlertEnabled'] = self.baseline_alert_enabled
        result['DingRobots'] = []
        if self.ding_robots is not None:
            for k in self.ding_robots:
                result['DingRobots'].append(k.to_map() if k else None)
        if self.silence_end_time is not None:
            result['SilenceEndTime'] = self.silence_end_time
        if self.silence_start_time is not None:
            result['SilenceStartTime'] = self.silence_start_time
        if self.topic_types is not None:
            result['TopicTypes'] = self.topic_types
        if self.webhooks is not None:
            result['Webhooks'] = self.webhooks
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertInterval') is not None:
            self.alert_interval = m.get('AlertInterval')
        if m.get('AlertMaximum') is not None:
            self.alert_maximum = m.get('AlertMaximum')
        if m.get('AlertMethods') is not None:
            self.alert_methods = m.get('AlertMethods')
        if m.get('AlertRecipient') is not None:
            self.alert_recipient = m.get('AlertRecipient')
        if m.get('AlertRecipientType') is not None:
            self.alert_recipient_type = m.get('AlertRecipientType')
        if m.get('AlertType') is not None:
            self.alert_type = m.get('AlertType')
        if m.get('BaselineAlertEnabled') is not None:
            self.baseline_alert_enabled = m.get('BaselineAlertEnabled')
        self.ding_robots = []
        if m.get('DingRobots') is not None:
            for k in m.get('DingRobots'):
                temp_model = UpdateBaselineRequestAlertSettingsDingRobots()
                self.ding_robots.append(temp_model.from_map(k))
        if m.get('SilenceEndTime') is not None:
            self.silence_end_time = m.get('SilenceEndTime')
        if m.get('SilenceStartTime') is not None:
            self.silence_start_time = m.get('SilenceStartTime')
        if m.get('TopicTypes') is not None:
            self.topic_types = m.get('TopicTypes')
        if m.get('Webhooks') is not None:
            self.webhooks = m.get('Webhooks')
        return self


class UpdateBaselineRequestOvertimeSettings(TeaModel):
    def __init__(self, cycle=None, time=None):
        self.cycle = cycle  # type: int
        self.time = time  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateBaselineRequestOvertimeSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cycle is not None:
            result['Cycle'] = self.cycle
        if self.time is not None:
            result['Time'] = self.time
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Cycle') is not None:
            self.cycle = m.get('Cycle')
        if m.get('Time') is not None:
            self.time = m.get('Time')
        return self


class UpdateBaselineRequest(TeaModel):
    def __init__(self, alert_enabled=None, alert_margin_threshold=None, alert_settings=None, baseline_id=None,
                 baseline_name=None, baseline_type=None, enabled=None, node_ids=None, overtime_settings=None, owner=None,
                 priority=None, project_id=None, remove_node_ids=None):
        self.alert_enabled = alert_enabled  # type: bool
        self.alert_margin_threshold = alert_margin_threshold  # type: int
        self.alert_settings = alert_settings  # type: list[UpdateBaselineRequestAlertSettings]
        self.baseline_id = baseline_id  # type: long
        self.baseline_name = baseline_name  # type: str
        self.baseline_type = baseline_type  # type: str
        self.enabled = enabled  # type: bool
        self.node_ids = node_ids  # type: str
        self.overtime_settings = overtime_settings  # type: list[UpdateBaselineRequestOvertimeSettings]
        self.owner = owner  # type: str
        self.priority = priority  # type: int
        self.project_id = project_id  # type: long
        self.remove_node_ids = remove_node_ids  # type: str

    def validate(self):
        if self.alert_settings:
            for k in self.alert_settings:
                if k:
                    k.validate()
        if self.overtime_settings:
            for k in self.overtime_settings:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(UpdateBaselineRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_enabled is not None:
            result['AlertEnabled'] = self.alert_enabled
        if self.alert_margin_threshold is not None:
            result['AlertMarginThreshold'] = self.alert_margin_threshold
        result['AlertSettings'] = []
        if self.alert_settings is not None:
            for k in self.alert_settings:
                result['AlertSettings'].append(k.to_map() if k else None)
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.baseline_type is not None:
            result['BaselineType'] = self.baseline_type
        if self.enabled is not None:
            result['Enabled'] = self.enabled
        if self.node_ids is not None:
            result['NodeIds'] = self.node_ids
        result['OvertimeSettings'] = []
        if self.overtime_settings is not None:
            for k in self.overtime_settings:
                result['OvertimeSettings'].append(k.to_map() if k else None)
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.remove_node_ids is not None:
            result['RemoveNodeIds'] = self.remove_node_ids
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertEnabled') is not None:
            self.alert_enabled = m.get('AlertEnabled')
        if m.get('AlertMarginThreshold') is not None:
            self.alert_margin_threshold = m.get('AlertMarginThreshold')
        self.alert_settings = []
        if m.get('AlertSettings') is not None:
            for k in m.get('AlertSettings'):
                temp_model = UpdateBaselineRequestAlertSettings()
                self.alert_settings.append(temp_model.from_map(k))
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('BaselineType') is not None:
            self.baseline_type = m.get('BaselineType')
        if m.get('Enabled') is not None:
            self.enabled = m.get('Enabled')
        if m.get('NodeIds') is not None:
            self.node_ids = m.get('NodeIds')
        self.overtime_settings = []
        if m.get('OvertimeSettings') is not None:
            for k in m.get('OvertimeSettings'):
                temp_model = UpdateBaselineRequestOvertimeSettings()
                self.overtime_settings.append(temp_model.from_map(k))
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RemoveNodeIds') is not None:
            self.remove_node_ids = m.get('RemoveNodeIds')
        return self


class UpdateBaselineShrinkRequest(TeaModel):
    def __init__(self, alert_enabled=None, alert_margin_threshold=None, alert_settings_shrink=None,
                 baseline_id=None, baseline_name=None, baseline_type=None, enabled=None, node_ids=None,
                 overtime_settings_shrink=None, owner=None, priority=None, project_id=None, remove_node_ids=None):
        self.alert_enabled = alert_enabled  # type: bool
        self.alert_margin_threshold = alert_margin_threshold  # type: int
        self.alert_settings_shrink = alert_settings_shrink  # type: str
        self.baseline_id = baseline_id  # type: long
        self.baseline_name = baseline_name  # type: str
        self.baseline_type = baseline_type  # type: str
        self.enabled = enabled  # type: bool
        self.node_ids = node_ids  # type: str
        self.overtime_settings_shrink = overtime_settings_shrink  # type: str
        self.owner = owner  # type: str
        self.priority = priority  # type: int
        self.project_id = project_id  # type: long
        self.remove_node_ids = remove_node_ids  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateBaselineShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_enabled is not None:
            result['AlertEnabled'] = self.alert_enabled
        if self.alert_margin_threshold is not None:
            result['AlertMarginThreshold'] = self.alert_margin_threshold
        if self.alert_settings_shrink is not None:
            result['AlertSettings'] = self.alert_settings_shrink
        if self.baseline_id is not None:
            result['BaselineId'] = self.baseline_id
        if self.baseline_name is not None:
            result['BaselineName'] = self.baseline_name
        if self.baseline_type is not None:
            result['BaselineType'] = self.baseline_type
        if self.enabled is not None:
            result['Enabled'] = self.enabled
        if self.node_ids is not None:
            result['NodeIds'] = self.node_ids
        if self.overtime_settings_shrink is not None:
            result['OvertimeSettings'] = self.overtime_settings_shrink
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.priority is not None:
            result['Priority'] = self.priority
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.remove_node_ids is not None:
            result['RemoveNodeIds'] = self.remove_node_ids
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertEnabled') is not None:
            self.alert_enabled = m.get('AlertEnabled')
        if m.get('AlertMarginThreshold') is not None:
            self.alert_margin_threshold = m.get('AlertMarginThreshold')
        if m.get('AlertSettings') is not None:
            self.alert_settings_shrink = m.get('AlertSettings')
        if m.get('BaselineId') is not None:
            self.baseline_id = m.get('BaselineId')
        if m.get('BaselineName') is not None:
            self.baseline_name = m.get('BaselineName')
        if m.get('BaselineType') is not None:
            self.baseline_type = m.get('BaselineType')
        if m.get('Enabled') is not None:
            self.enabled = m.get('Enabled')
        if m.get('NodeIds') is not None:
            self.node_ids = m.get('NodeIds')
        if m.get('OvertimeSettings') is not None:
            self.overtime_settings_shrink = m.get('OvertimeSettings')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('Priority') is not None:
            self.priority = m.get('Priority')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RemoveNodeIds') is not None:
            self.remove_node_ids = m.get('RemoveNodeIds')
        return self


class UpdateBaselineResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        self.data = data  # type: bool
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateBaselineResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateBaselineResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateBaselineResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateBaselineResponse, self).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=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 = UpdateBaselineResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateBusinessRequest(TeaModel):
    def __init__(self, business_id=None, business_name=None, description=None, owner=None, project_id=None,
                 project_identifier=None):
        # The ID of the workflow. You can call the [ListBusiness](~~173945~~) operation to obtain the workflow ID.
        self.business_id = business_id  # type: long
        # The name of the workflow. You can call the [ListBusiness](~~173945~~) operation to obtain the workflow name.
        self.business_name = business_name  # type: str
        # The description of the workflow.
        self.description = description  # type: str
        # The owner of the workflow. You can call the [ListBusiness](~~173945~~) operation to obtain the workflow owner.
        self.owner = owner  # type: str
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace ID. You must configure either this parameter or the ProjectIdentifier parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the workspace name. You must configure either this parameter or ProjectId parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateBusinessRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.business_id is not None:
            result['BusinessId'] = self.business_id
        if self.business_name is not None:
            result['BusinessName'] = self.business_name
        if self.description is not None:
            result['Description'] = self.description
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BusinessId') is not None:
            self.business_id = m.get('BusinessId')
        if m.get('BusinessName') is not None:
            self.business_name = m.get('BusinessName')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class UpdateBusinessResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, success=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateBusinessResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateBusinessResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateBusinessResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateBusinessResponse, self).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=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 = UpdateBusinessResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateConnectionRequest(TeaModel):
    def __init__(self, connection_id=None, content=None, description=None, env_type=None, status=None):
        # The ID of the data source.
        self.connection_id = connection_id  # type: long
        # Details of the data source.
        self.content = content  # type: str
        # Describes the data source.
        self.description = description  # type: str
        # Environment of the data source.
        self.env_type = env_type  # type: int
        # The status of the data source.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateConnectionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.connection_id is not None:
            result['ConnectionId'] = self.connection_id
        if self.content is not None:
            result['Content'] = self.content
        if self.description is not None:
            result['Description'] = self.description
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ConnectionId') is not None:
            self.connection_id = m.get('ConnectionId')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class UpdateConnectionResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        # Indicates whether the update is successful.
        self.data = data  # type: bool
        # The HTTP status code.
        self.http_status_code = http_status_code  # type: str
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful. A value of true indicates that the request is successful. A value of false indicates that the request has failed.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateConnectionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateConnectionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateConnectionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateConnectionResponse, self).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=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 = UpdateConnectionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateDIAlarmRuleRequestNotificationSettingsNotificationChannels(TeaModel):
    def __init__(self, channels=None, severity=None):
        self.channels = channels  # type: list[str]
        self.severity = severity  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIAlarmRuleRequestNotificationSettingsNotificationChannels, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.channels is not None:
            result['Channels'] = self.channels
        if self.severity is not None:
            result['Severity'] = self.severity
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Channels') is not None:
            self.channels = m.get('Channels')
        if m.get('Severity') is not None:
            self.severity = m.get('Severity')
        return self


class UpdateDIAlarmRuleRequestNotificationSettingsNotificationReceivers(TeaModel):
    def __init__(self, receiver_type=None, receiver_values=None):
        self.receiver_type = receiver_type  # type: str
        self.receiver_values = receiver_values  # type: list[str]

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIAlarmRuleRequestNotificationSettingsNotificationReceivers, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.receiver_type is not None:
            result['ReceiverType'] = self.receiver_type
        if self.receiver_values is not None:
            result['ReceiverValues'] = self.receiver_values
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ReceiverType') is not None:
            self.receiver_type = m.get('ReceiverType')
        if m.get('ReceiverValues') is not None:
            self.receiver_values = m.get('ReceiverValues')
        return self


class UpdateDIAlarmRuleRequestNotificationSettings(TeaModel):
    def __init__(self, inhibition_interval=None, notification_channels=None, notification_receivers=None):
        self.inhibition_interval = inhibition_interval  # type: int
        self.notification_channels = notification_channels  # type: list[UpdateDIAlarmRuleRequestNotificationSettingsNotificationChannels]
        self.notification_receivers = notification_receivers  # type: list[UpdateDIAlarmRuleRequestNotificationSettingsNotificationReceivers]

    def validate(self):
        if self.notification_channels:
            for k in self.notification_channels:
                if k:
                    k.validate()
        if self.notification_receivers:
            for k in self.notification_receivers:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(UpdateDIAlarmRuleRequestNotificationSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.inhibition_interval is not None:
            result['InhibitionInterval'] = self.inhibition_interval
        result['NotificationChannels'] = []
        if self.notification_channels is not None:
            for k in self.notification_channels:
                result['NotificationChannels'].append(k.to_map() if k else None)
        result['NotificationReceivers'] = []
        if self.notification_receivers is not None:
            for k in self.notification_receivers:
                result['NotificationReceivers'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('InhibitionInterval') is not None:
            self.inhibition_interval = m.get('InhibitionInterval')
        self.notification_channels = []
        if m.get('NotificationChannels') is not None:
            for k in m.get('NotificationChannels'):
                temp_model = UpdateDIAlarmRuleRequestNotificationSettingsNotificationChannels()
                self.notification_channels.append(temp_model.from_map(k))
        self.notification_receivers = []
        if m.get('NotificationReceivers') is not None:
            for k in m.get('NotificationReceivers'):
                temp_model = UpdateDIAlarmRuleRequestNotificationSettingsNotificationReceivers()
                self.notification_receivers.append(temp_model.from_map(k))
        return self


class UpdateDIAlarmRuleRequestTriggerConditions(TeaModel):
    def __init__(self, duration=None, severity=None, threshold=None):
        self.duration = duration  # type: long
        self.severity = severity  # type: str
        self.threshold = threshold  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIAlarmRuleRequestTriggerConditions, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.duration is not None:
            result['Duration'] = self.duration
        if self.severity is not None:
            result['Severity'] = self.severity
        if self.threshold is not None:
            result['Threshold'] = self.threshold
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Duration') is not None:
            self.duration = m.get('Duration')
        if m.get('Severity') is not None:
            self.severity = m.get('Severity')
        if m.get('Threshold') is not None:
            self.threshold = m.get('Threshold')
        return self


class UpdateDIAlarmRuleRequest(TeaModel):
    def __init__(self, dialarm_rule_id=None, description=None, enabled=None, metric_type=None,
                 notification_settings=None, trigger_conditions=None):
        self.dialarm_rule_id = dialarm_rule_id  # type: long
        self.description = description  # type: str
        self.enabled = enabled  # type: bool
        self.metric_type = metric_type  # type: str
        self.notification_settings = notification_settings  # type: UpdateDIAlarmRuleRequestNotificationSettings
        self.trigger_conditions = trigger_conditions  # type: list[UpdateDIAlarmRuleRequestTriggerConditions]

    def validate(self):
        if self.notification_settings:
            self.notification_settings.validate()
        if self.trigger_conditions:
            for k in self.trigger_conditions:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(UpdateDIAlarmRuleRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dialarm_rule_id is not None:
            result['DIAlarmRuleId'] = self.dialarm_rule_id
        if self.description is not None:
            result['Description'] = self.description
        if self.enabled is not None:
            result['Enabled'] = self.enabled
        if self.metric_type is not None:
            result['MetricType'] = self.metric_type
        if self.notification_settings is not None:
            result['NotificationSettings'] = self.notification_settings.to_map()
        result['TriggerConditions'] = []
        if self.trigger_conditions is not None:
            for k in self.trigger_conditions:
                result['TriggerConditions'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIAlarmRuleId') is not None:
            self.dialarm_rule_id = m.get('DIAlarmRuleId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Enabled') is not None:
            self.enabled = m.get('Enabled')
        if m.get('MetricType') is not None:
            self.metric_type = m.get('MetricType')
        if m.get('NotificationSettings') is not None:
            temp_model = UpdateDIAlarmRuleRequestNotificationSettings()
            self.notification_settings = temp_model.from_map(m['NotificationSettings'])
        self.trigger_conditions = []
        if m.get('TriggerConditions') is not None:
            for k in m.get('TriggerConditions'):
                temp_model = UpdateDIAlarmRuleRequestTriggerConditions()
                self.trigger_conditions.append(temp_model.from_map(k))
        return self


class UpdateDIAlarmRuleShrinkRequest(TeaModel):
    def __init__(self, dialarm_rule_id=None, description=None, enabled=None, metric_type=None,
                 notification_settings_shrink=None, trigger_conditions_shrink=None):
        self.dialarm_rule_id = dialarm_rule_id  # type: long
        self.description = description  # type: str
        self.enabled = enabled  # type: bool
        self.metric_type = metric_type  # type: str
        self.notification_settings_shrink = notification_settings_shrink  # type: str
        self.trigger_conditions_shrink = trigger_conditions_shrink  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIAlarmRuleShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dialarm_rule_id is not None:
            result['DIAlarmRuleId'] = self.dialarm_rule_id
        if self.description is not None:
            result['Description'] = self.description
        if self.enabled is not None:
            result['Enabled'] = self.enabled
        if self.metric_type is not None:
            result['MetricType'] = self.metric_type
        if self.notification_settings_shrink is not None:
            result['NotificationSettings'] = self.notification_settings_shrink
        if self.trigger_conditions_shrink is not None:
            result['TriggerConditions'] = self.trigger_conditions_shrink
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIAlarmRuleId') is not None:
            self.dialarm_rule_id = m.get('DIAlarmRuleId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('Enabled') is not None:
            self.enabled = m.get('Enabled')
        if m.get('MetricType') is not None:
            self.metric_type = m.get('MetricType')
        if m.get('NotificationSettings') is not None:
            self.notification_settings_shrink = m.get('NotificationSettings')
        if m.get('TriggerConditions') is not None:
            self.trigger_conditions_shrink = m.get('TriggerConditions')
        return self


class UpdateDIAlarmRuleResponseBody(TeaModel):
    def __init__(self, request_id=None):
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIAlarmRuleResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class UpdateDIAlarmRuleResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateDIAlarmRuleResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateDIAlarmRuleResponse, self).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=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 = UpdateDIAlarmRuleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateDIJobRequestJobSettingsColumnDataTypeSettings(TeaModel):
    def __init__(self, destination_data_type=None, source_data_type=None):
        self.destination_data_type = destination_data_type  # type: str
        self.source_data_type = source_data_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIJobRequestJobSettingsColumnDataTypeSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.destination_data_type is not None:
            result['DestinationDataType'] = self.destination_data_type
        if self.source_data_type is not None:
            result['SourceDataType'] = self.source_data_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DestinationDataType') is not None:
            self.destination_data_type = m.get('DestinationDataType')
        if m.get('SourceDataType') is not None:
            self.source_data_type = m.get('SourceDataType')
        return self


class UpdateDIJobRequestJobSettingsDdlHandlingSettings(TeaModel):
    def __init__(self, action=None, type=None):
        self.action = action  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIJobRequestJobSettingsDdlHandlingSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.action is not None:
            result['Action'] = self.action
        if self.type is not None:
            result['Type'] = self.type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Action') is not None:
            self.action = m.get('Action')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class UpdateDIJobRequestJobSettingsRuntimeSettings(TeaModel):
    def __init__(self, name=None, value=None):
        self.name = name  # type: str
        self.value = value  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIJobRequestJobSettingsRuntimeSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.name is not None:
            result['Name'] = self.name
        if self.value is not None:
            result['Value'] = self.value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Value') is not None:
            self.value = m.get('Value')
        return self


class UpdateDIJobRequestJobSettings(TeaModel):
    def __init__(self, column_data_type_settings=None, ddl_handling_settings=None, runtime_settings=None):
        self.column_data_type_settings = column_data_type_settings  # type: list[UpdateDIJobRequestJobSettingsColumnDataTypeSettings]
        self.ddl_handling_settings = ddl_handling_settings  # type: list[UpdateDIJobRequestJobSettingsDdlHandlingSettings]
        self.runtime_settings = runtime_settings  # type: list[UpdateDIJobRequestJobSettingsRuntimeSettings]

    def validate(self):
        if self.column_data_type_settings:
            for k in self.column_data_type_settings:
                if k:
                    k.validate()
        if self.ddl_handling_settings:
            for k in self.ddl_handling_settings:
                if k:
                    k.validate()
        if self.runtime_settings:
            for k in self.runtime_settings:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(UpdateDIJobRequestJobSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['ColumnDataTypeSettings'] = []
        if self.column_data_type_settings is not None:
            for k in self.column_data_type_settings:
                result['ColumnDataTypeSettings'].append(k.to_map() if k else None)
        result['DdlHandlingSettings'] = []
        if self.ddl_handling_settings is not None:
            for k in self.ddl_handling_settings:
                result['DdlHandlingSettings'].append(k.to_map() if k else None)
        result['RuntimeSettings'] = []
        if self.runtime_settings is not None:
            for k in self.runtime_settings:
                result['RuntimeSettings'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.column_data_type_settings = []
        if m.get('ColumnDataTypeSettings') is not None:
            for k in m.get('ColumnDataTypeSettings'):
                temp_model = UpdateDIJobRequestJobSettingsColumnDataTypeSettings()
                self.column_data_type_settings.append(temp_model.from_map(k))
        self.ddl_handling_settings = []
        if m.get('DdlHandlingSettings') is not None:
            for k in m.get('DdlHandlingSettings'):
                temp_model = UpdateDIJobRequestJobSettingsDdlHandlingSettings()
                self.ddl_handling_settings.append(temp_model.from_map(k))
        self.runtime_settings = []
        if m.get('RuntimeSettings') is not None:
            for k in m.get('RuntimeSettings'):
                temp_model = UpdateDIJobRequestJobSettingsRuntimeSettings()
                self.runtime_settings.append(temp_model.from_map(k))
        return self


class UpdateDIJobRequestResourceSettingsOfflineResourceSettings(TeaModel):
    def __init__(self, resource_group_identifier=None):
        self.resource_group_identifier = resource_group_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIJobRequestResourceSettingsOfflineResourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.resource_group_identifier is not None:
            result['ResourceGroupIdentifier'] = self.resource_group_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ResourceGroupIdentifier') is not None:
            self.resource_group_identifier = m.get('ResourceGroupIdentifier')
        return self


class UpdateDIJobRequestResourceSettingsRealtimeResourceSettings(TeaModel):
    def __init__(self, resource_group_identifier=None):
        self.resource_group_identifier = resource_group_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIJobRequestResourceSettingsRealtimeResourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.resource_group_identifier is not None:
            result['ResourceGroupIdentifier'] = self.resource_group_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ResourceGroupIdentifier') is not None:
            self.resource_group_identifier = m.get('ResourceGroupIdentifier')
        return self


class UpdateDIJobRequestResourceSettings(TeaModel):
    def __init__(self, offline_resource_settings=None, realtime_resource_settings=None):
        self.offline_resource_settings = offline_resource_settings  # type: UpdateDIJobRequestResourceSettingsOfflineResourceSettings
        self.realtime_resource_settings = realtime_resource_settings  # type: UpdateDIJobRequestResourceSettingsRealtimeResourceSettings

    def validate(self):
        if self.offline_resource_settings:
            self.offline_resource_settings.validate()
        if self.realtime_resource_settings:
            self.realtime_resource_settings.validate()

    def to_map(self):
        _map = super(UpdateDIJobRequestResourceSettings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.offline_resource_settings is not None:
            result['OfflineResourceSettings'] = self.offline_resource_settings.to_map()
        if self.realtime_resource_settings is not None:
            result['RealtimeResourceSettings'] = self.realtime_resource_settings.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('OfflineResourceSettings') is not None:
            temp_model = UpdateDIJobRequestResourceSettingsOfflineResourceSettings()
            self.offline_resource_settings = temp_model.from_map(m['OfflineResourceSettings'])
        if m.get('RealtimeResourceSettings') is not None:
            temp_model = UpdateDIJobRequestResourceSettingsRealtimeResourceSettings()
            self.realtime_resource_settings = temp_model.from_map(m['RealtimeResourceSettings'])
        return self


class UpdateDIJobRequestTableMappingsSourceObjectSelectionRules(TeaModel):
    def __init__(self, expression=None, object_type=None):
        self.expression = expression  # type: str
        self.object_type = object_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIJobRequestTableMappingsSourceObjectSelectionRules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.expression is not None:
            result['Expression'] = self.expression
        if self.object_type is not None:
            result['ObjectType'] = self.object_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Expression') is not None:
            self.expression = m.get('Expression')
        if m.get('ObjectType') is not None:
            self.object_type = m.get('ObjectType')
        return self


class UpdateDIJobRequestTableMappingsTransformationRules(TeaModel):
    def __init__(self, rule_action_type=None, rule_name=None, rule_target_type=None):
        self.rule_action_type = rule_action_type  # type: str
        self.rule_name = rule_name  # type: str
        self.rule_target_type = rule_target_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIJobRequestTableMappingsTransformationRules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.rule_action_type is not None:
            result['RuleActionType'] = self.rule_action_type
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        if self.rule_target_type is not None:
            result['RuleTargetType'] = self.rule_target_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RuleActionType') is not None:
            self.rule_action_type = m.get('RuleActionType')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        if m.get('RuleTargetType') is not None:
            self.rule_target_type = m.get('RuleTargetType')
        return self


class UpdateDIJobRequestTableMappings(TeaModel):
    def __init__(self, source_object_selection_rules=None, transformation_rules=None):
        self.source_object_selection_rules = source_object_selection_rules  # type: list[UpdateDIJobRequestTableMappingsSourceObjectSelectionRules]
        self.transformation_rules = transformation_rules  # type: list[UpdateDIJobRequestTableMappingsTransformationRules]

    def validate(self):
        if self.source_object_selection_rules:
            for k in self.source_object_selection_rules:
                if k:
                    k.validate()
        if self.transformation_rules:
            for k in self.transformation_rules:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(UpdateDIJobRequestTableMappings, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['SourceObjectSelectionRules'] = []
        if self.source_object_selection_rules is not None:
            for k in self.source_object_selection_rules:
                result['SourceObjectSelectionRules'].append(k.to_map() if k else None)
        result['TransformationRules'] = []
        if self.transformation_rules is not None:
            for k in self.transformation_rules:
                result['TransformationRules'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.source_object_selection_rules = []
        if m.get('SourceObjectSelectionRules') is not None:
            for k in m.get('SourceObjectSelectionRules'):
                temp_model = UpdateDIJobRequestTableMappingsSourceObjectSelectionRules()
                self.source_object_selection_rules.append(temp_model.from_map(k))
        self.transformation_rules = []
        if m.get('TransformationRules') is not None:
            for k in m.get('TransformationRules'):
                temp_model = UpdateDIJobRequestTableMappingsTransformationRules()
                self.transformation_rules.append(temp_model.from_map(k))
        return self


class UpdateDIJobRequestTransformationRules(TeaModel):
    def __init__(self, rule_action_type=None, rule_expression=None, rule_name=None, rule_target_type=None):
        self.rule_action_type = rule_action_type  # type: str
        self.rule_expression = rule_expression  # type: str
        self.rule_name = rule_name  # type: str
        self.rule_target_type = rule_target_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIJobRequestTransformationRules, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.rule_action_type is not None:
            result['RuleActionType'] = self.rule_action_type
        if self.rule_expression is not None:
            result['RuleExpression'] = self.rule_expression
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        if self.rule_target_type is not None:
            result['RuleTargetType'] = self.rule_target_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RuleActionType') is not None:
            self.rule_action_type = m.get('RuleActionType')
        if m.get('RuleExpression') is not None:
            self.rule_expression = m.get('RuleExpression')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        if m.get('RuleTargetType') is not None:
            self.rule_target_type = m.get('RuleTargetType')
        return self


class UpdateDIJobRequest(TeaModel):
    def __init__(self, dijob_id=None, description=None, job_settings=None, resource_settings=None,
                 table_mappings=None, transformation_rules=None):
        self.dijob_id = dijob_id  # type: long
        self.description = description  # type: str
        self.job_settings = job_settings  # type: UpdateDIJobRequestJobSettings
        self.resource_settings = resource_settings  # type: UpdateDIJobRequestResourceSettings
        self.table_mappings = table_mappings  # type: list[UpdateDIJobRequestTableMappings]
        self.transformation_rules = transformation_rules  # type: list[UpdateDIJobRequestTransformationRules]

    def validate(self):
        if self.job_settings:
            self.job_settings.validate()
        if self.resource_settings:
            self.resource_settings.validate()
        if self.table_mappings:
            for k in self.table_mappings:
                if k:
                    k.validate()
        if self.transformation_rules:
            for k in self.transformation_rules:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(UpdateDIJobRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.description is not None:
            result['Description'] = self.description
        if self.job_settings is not None:
            result['JobSettings'] = self.job_settings.to_map()
        if self.resource_settings is not None:
            result['ResourceSettings'] = self.resource_settings.to_map()
        result['TableMappings'] = []
        if self.table_mappings is not None:
            for k in self.table_mappings:
                result['TableMappings'].append(k.to_map() if k else None)
        result['TransformationRules'] = []
        if self.transformation_rules is not None:
            for k in self.transformation_rules:
                result['TransformationRules'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('JobSettings') is not None:
            temp_model = UpdateDIJobRequestJobSettings()
            self.job_settings = temp_model.from_map(m['JobSettings'])
        if m.get('ResourceSettings') is not None:
            temp_model = UpdateDIJobRequestResourceSettings()
            self.resource_settings = temp_model.from_map(m['ResourceSettings'])
        self.table_mappings = []
        if m.get('TableMappings') is not None:
            for k in m.get('TableMappings'):
                temp_model = UpdateDIJobRequestTableMappings()
                self.table_mappings.append(temp_model.from_map(k))
        self.transformation_rules = []
        if m.get('TransformationRules') is not None:
            for k in m.get('TransformationRules'):
                temp_model = UpdateDIJobRequestTransformationRules()
                self.transformation_rules.append(temp_model.from_map(k))
        return self


class UpdateDIJobShrinkRequest(TeaModel):
    def __init__(self, dijob_id=None, description=None, job_settings_shrink=None, resource_settings_shrink=None,
                 table_mappings_shrink=None, transformation_rules_shrink=None):
        self.dijob_id = dijob_id  # type: long
        self.description = description  # type: str
        self.job_settings_shrink = job_settings_shrink  # type: str
        self.resource_settings_shrink = resource_settings_shrink  # type: str
        self.table_mappings_shrink = table_mappings_shrink  # type: str
        self.transformation_rules_shrink = transformation_rules_shrink  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIJobShrinkRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dijob_id is not None:
            result['DIJobId'] = self.dijob_id
        if self.description is not None:
            result['Description'] = self.description
        if self.job_settings_shrink is not None:
            result['JobSettings'] = self.job_settings_shrink
        if self.resource_settings_shrink is not None:
            result['ResourceSettings'] = self.resource_settings_shrink
        if self.table_mappings_shrink is not None:
            result['TableMappings'] = self.table_mappings_shrink
        if self.transformation_rules_shrink is not None:
            result['TransformationRules'] = self.transformation_rules_shrink
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DIJobId') is not None:
            self.dijob_id = m.get('DIJobId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('JobSettings') is not None:
            self.job_settings_shrink = m.get('JobSettings')
        if m.get('ResourceSettings') is not None:
            self.resource_settings_shrink = m.get('ResourceSettings')
        if m.get('TableMappings') is not None:
            self.table_mappings_shrink = m.get('TableMappings')
        if m.get('TransformationRules') is not None:
            self.transformation_rules_shrink = m.get('TransformationRules')
        return self


class UpdateDIJobResponseBody(TeaModel):
    def __init__(self, request_id=None):
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIJobResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class UpdateDIJobResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateDIJobResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateDIJobResponse, self).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=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 = UpdateDIJobResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateDIProjectConfigRequest(TeaModel):
    def __init__(self, destination_type=None, project_config=None, project_id=None, source_type=None):
        # The type of the sources of the synchronization solutions.
        # 
        # Valid values: oracle, mysql, polardb, datahub, drds, and analyticdb_for_mysql.
        # 
        # If you do not configure this parameter, DataWorks applies the default global configuration to all sources.
        self.destination_type = destination_type  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.project_config = project_config  # type: str
        # The type of the destinations of the synchronization solutions. This parameter cannot be left empty.
        # 
        # Valid values: analyticdb_for_mysql, odps, elasticsearch, holo, mysql, and polardb.
        self.project_id = project_id  # type: long
        # The new default global configuration of synchronization solutions. The value indicates the processing rules of different types of DDL messages. The value must be in the JSON format. Example:
        # 
        # {"RENAMECOLUMN":"WARNING","DROPTABLE":"WARNING","CREATETABLE":"WARNING","MODIFYCOLUMN":"WARNING","TRUNCATETABLE":"WARNING","DROPCOLUMN":"WARNING","ADDCOLUMN":"WARNING","RENAMETABLE":"WARNING"}
        # 
        # Field description:
        # 
        # *   RENAMECOLUMN: renames a column.
        # *   DROPTABLE: deletes a table.
        # *   CREATETABLE: creates a table.
        # *   MODIFYCOLUMN: changes the data type of a column.
        # *   TRUNCATETABLE: clears a table.
        # *   DROPCOLUMN: deletes a column.
        # *   ADDCOLUMN: creates a column.
        # *   RENAMETABLE: renames a table.
        # 
        # DataWorks processes a DDL message of a specific type based on the following rules:
        # 
        # *   WARNING: ignores the message and records an alert in real-time synchronization logs. The alert contains information about the situation that the message is ignored because of an execution error.
        # *   IGNORE: discards the message and does not send it to the destination.
        # *   CRITICAL: terminates the real-time synchronization node and sets the node status to Failed.
        # *   NORMAL: sends the message to the destination to process the message. Each destination processes DDL messages based on its own business logic. If DataWorks adopts the NORMAL policy, DataWorks only forwards DDL messages.
        self.source_type = source_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIProjectConfigRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.destination_type is not None:
            result['DestinationType'] = self.destination_type
        if self.project_config is not None:
            result['ProjectConfig'] = self.project_config
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.source_type is not None:
            result['SourceType'] = self.source_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('DestinationType') is not None:
            self.destination_type = m.get('DestinationType')
        if m.get('ProjectConfig') is not None:
            self.project_config = m.get('ProjectConfig')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('SourceType') is not None:
            self.source_type = m.get('SourceType')
        return self


class UpdateDIProjectConfigResponseBodyData(TeaModel):
    def __init__(self, status=None):
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDIProjectConfigResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class UpdateDIProjectConfigResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # Indicates whether the default global configuration of synchronization solutions was modified. Valid values:
        # 
        # *   success: The default global configuration of synchronization solutions was modified.
        # *   fail: The default global configuration of synchronization solutions failed to be modified.
        self.data = data  # type: UpdateDIProjectConfigResponseBodyData
        # The information about the modification.
        self.request_id = request_id  # type: str
        # The ID of the request. You can use the ID to locate logs and troubleshoot issues.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(UpdateDIProjectConfigResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = UpdateDIProjectConfigResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateDIProjectConfigResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateDIProjectConfigResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateDIProjectConfigResponse, self).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=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 = UpdateDIProjectConfigResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateDISyncTaskRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, task_content=None, task_param=None, task_type=None):
        # The ID of the sync node to be updated. You can call the [ListFiles](~~173942~~) operation to query the ID of the node.
        self.file_id = file_id  # type: long
        # The ID of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace ID.
        # 
        # You must set this parameter to specify the DataWorks workspace in which the node resides.
        self.project_id = project_id  # type: long
        # The updated configuration of the sync node. This operation is equivalent to node update by using the code editor in the DataWorks console. For more information, see [Create a sync node by using the code editor](~~137717~~). You can call the UpdateDISyncTask operation to update only batch sync nodes. If you do not need to update the configuration of the sync node, leave this parameter empty.
        self.task_content = task_content  # type: str
        # The setting that updates the resource group used by the node. The value must be in the JSON format.
        # 
        # Only the ResourceGroup field is supported. This field specifies the identifier of the resource group for Data Integration that is used by the node. To query the identifier of the resource group, call the [ListResourceGroup](~~62055~~) operation.
        # 
        # If you do not need to update the resource group for the sync node, leave this parameter empty.
        self.task_param = task_param  # type: str
        # The type of the sync node.
        # 
        # You can call the UpdateDISyncTask operation to update only batch sync nodes. The value must be DI_OFFLINE.
        self.task_type = task_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDISyncTaskRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.task_content is not None:
            result['TaskContent'] = self.task_content
        if self.task_param is not None:
            result['TaskParam'] = self.task_param
        if self.task_type is not None:
            result['TaskType'] = self.task_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('TaskContent') is not None:
            self.task_content = m.get('TaskContent')
        if m.get('TaskParam') is not None:
            self.task_param = m.get('TaskParam')
        if m.get('TaskType') is not None:
            self.task_type = m.get('TaskType')
        return self


class UpdateDISyncTaskResponseBodyData(TeaModel):
    def __init__(self, message=None, status=None):
        # The reason why the sync node failed to be updated. If the sync node was updated, this parameter is left empty.
        self.message = message  # type: str
        # Indicates whether the sync node was updated. Valid values:
        # 
        # *   success: The sync node was updated.
        # *   fail: The sync node failed to be updated.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDISyncTaskResponseBodyData, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.message is not None:
            result['Message'] = self.message
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class UpdateDISyncTaskResponseBody(TeaModel):
    def __init__(self, data=None, request_id=None, success=None):
        # The information that indicates whether the sync node was updated.
        self.data = data  # type: UpdateDISyncTaskResponseBodyData
        # The ID of the request. You can locate logs and troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.success = success  # type: bool

    def validate(self):
        if self.data:
            self.data.validate()

    def to_map(self):
        _map = super(UpdateDISyncTaskResponseBody, self).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
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            temp_model = UpdateDISyncTaskResponseBodyData()
            self.data = temp_model.from_map(m['Data'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateDISyncTaskResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateDISyncTaskResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateDISyncTaskResponse, self).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=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 = UpdateDISyncTaskResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateDataServiceApiRequest(TeaModel):
    def __init__(self, api_description=None, api_id=None, api_path=None, project_id=None, protocols=None,
                 registration_details=None, request_method=None, resource_group_id=None, response_content_type=None,
                 script_details=None, tenant_id=None, timeout=None, visible_range=None, wizard_details=None):
        # The description of the API.
        self.api_description = api_description  # type: str
        # The ID of the API.
        self.api_id = api_id  # type: long
        # The path of the API.
        self.api_path = api_path  # type: str
        # The ID of the workspace.
        self.project_id = project_id  # type: long
        # The protocol used by the API. Valid values: 0 and 1. The value 0 indicates HTTP. The value 1 indicates HTTPS. You can specify multiple protocols. Separate multiple protocols with commas (,).
        self.protocols = protocols  # type: str
        # The details of the API generated by registration. For more information, see the RegistrationDetails parameter returned by the [GetDataServiceApi](~~174013~~) operation.
        self.registration_details = registration_details  # type: str
        # The request method of the API. Valid values: 0, 1, 2, and 3. The value 0 indicates the GET method. The value 1 indicates the POST method. The value 2 indicates the PUT method. The value 3 indicates the DELETE method. APIs generated in wizard or script mode support the GET and POST methods. APIs generated by registration support the GET, POST, PUT, and DELETE methods.
        self.request_method = request_method  # type: int
        self.resource_group_id = resource_group_id  # type: long
        # The format in which the response of the API request is returned. Valid values: 0 and 1. The value 0 indicates the JSON format. The value 1 indicates the XML format. APIs generated in wizard or script mode support the JSON format. APIs generated by registration support the JSON and XML formats.
        self.response_content_type = response_content_type  # type: int
        # The details of the API generated in script mode. For more information, see the ScriptDetails parameter returned by the [GetDataServiceApi](~~174013~~) operation.
        self.script_details = script_details  # type: str
        # The ID of the tenant.
        self.tenant_id = tenant_id  # type: long
        # The timeout period of the API request. Unit: milliseconds. Valid values: (0,30000].
        self.timeout = timeout  # type: int
        # The scope in which the API is visible. Valid values: 0 and 1. The value 0 indicates that the API is visible within the workspace. The value 1 indicates that the API is visible only to its owner.
        self.visible_range = visible_range  # type: int
        # The details of the API generated in wizard mode. For more information, see the WizardDetails parameter returned by the [GetDataServiceApi](~~174013~~) operation.
        self.wizard_details = wizard_details  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDataServiceApiRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_description is not None:
            result['ApiDescription'] = self.api_description
        if self.api_id is not None:
            result['ApiId'] = self.api_id
        if self.api_path is not None:
            result['ApiPath'] = self.api_path
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.protocols is not None:
            result['Protocols'] = self.protocols
        if self.registration_details is not None:
            result['RegistrationDetails'] = self.registration_details
        if self.request_method is not None:
            result['RequestMethod'] = self.request_method
        if self.resource_group_id is not None:
            result['ResourceGroupId'] = self.resource_group_id
        if self.response_content_type is not None:
            result['ResponseContentType'] = self.response_content_type
        if self.script_details is not None:
            result['ScriptDetails'] = self.script_details
        if self.tenant_id is not None:
            result['TenantId'] = self.tenant_id
        if self.timeout is not None:
            result['Timeout'] = self.timeout
        if self.visible_range is not None:
            result['VisibleRange'] = self.visible_range
        if self.wizard_details is not None:
            result['WizardDetails'] = self.wizard_details
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ApiDescription') is not None:
            self.api_description = m.get('ApiDescription')
        if m.get('ApiId') is not None:
            self.api_id = m.get('ApiId')
        if m.get('ApiPath') is not None:
            self.api_path = m.get('ApiPath')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Protocols') is not None:
            self.protocols = m.get('Protocols')
        if m.get('RegistrationDetails') is not None:
            self.registration_details = m.get('RegistrationDetails')
        if m.get('RequestMethod') is not None:
            self.request_method = m.get('RequestMethod')
        if m.get('ResourceGroupId') is not None:
            self.resource_group_id = m.get('ResourceGroupId')
        if m.get('ResponseContentType') is not None:
            self.response_content_type = m.get('ResponseContentType')
        if m.get('ScriptDetails') is not None:
            self.script_details = m.get('ScriptDetails')
        if m.get('TenantId') is not None:
            self.tenant_id = m.get('TenantId')
        if m.get('Timeout') is not None:
            self.timeout = m.get('Timeout')
        if m.get('VisibleRange') is not None:
            self.visible_range = m.get('VisibleRange')
        if m.get('WizardDetails') is not None:
            self.wizard_details = m.get('WizardDetails')
        return self


class UpdateDataServiceApiResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the information about the API is updated.
        self.data = data  # type: bool
        # The error code.
        self.error_code = error_code  # type: str
        # The error message.
        self.error_message = error_message  # type: str
        # The HTTP status code.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDataServiceApiResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateDataServiceApiResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateDataServiceApiResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateDataServiceApiResponse, self).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=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 = UpdateDataServiceApiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateDataSourceRequest(TeaModel):
    def __init__(self, content=None, data_source_id=None, description=None, env_type=None, status=None):
        # The ID of the data source that you want to update. You can call the [ListDataSources](~~211431~~) operation to obtain the ID.
        self.content = content  # type: str
        # Indicates whether the data source is updated.
        self.data_source_id = data_source_id  # type: long
        # The details about the data source that you want to update.
        # 
        # You are not allowed to change the type of the data source. For example, you are not allowed to change the data source type from MaxCompute to mysql.
        # 
        # Examples of details of some common data sources:
        # 
        # *   odps
        # 
        # ```
        # 
        # {
        #   "accessId": "xssssss",
        #   "accessKey": "xsaxsaxsa",
        #   "authType": 2,
        #   "endpoint": "http://service.odps.aliyun.com/api",
        #   "project": "xsaxsax",
        #   "tag": "public"
        # }
        #                                 
        # ```
        # 
        # *   mysql
        # 
        # ```
        # 
        # {
        #   "database": "xsaxsa",
        #   "instanceName": "rm-xsaxsa",
        #   "password": "xsaxsa",
        #   "rdsOwnerId": "xasxsa",
        #   "regionId": "cn-shanghai",
        #   "tag": "rds",
        #   "username": "xsaxsa"
        # }
        #                                 
        # ```
        # 
        # *   rds
        # 
        # ```
        # 
        # {
        #   "configType": 1,
        #   "tag": "rds",
        #   "database": "xsaxsa",
        #   "username": "xsaxsa",
        #   "password": "xssaxsa$32050",
        #   "instanceName": "rm-xsaxs",
        #   "rdsOwnerId": "11111111"
        # }
        #                                 
        # ```
        # 
        # *   oss
        # 
        # ```
        # 
        # {
        #   "accessId": "sssssxx",
        #   "accessKey": "xsaxaxsaxs",
        #   "bucket": "xsa-xs-xs",
        #   "endpoint": "http://oss-cn-shanghai.aliyuncs.com",
        #   "tag": "public"
        # }
        #                                 
        # ```
        # 
        # *   sqlserver
        # 
        # ```
        # 
        # {
        #   "jdbcUrl": "jdbc:sqlserver://xsaxsa-xsaxsa.database.xxx.cnv:123;DatabaseName=xsxs-xsxs",
        #   "password": "sdasda$fs",
        #   "tag": "public",
        #   "username": "sxaxacdacdd"
        # }
        #                                 
        # ```
        # 
        # *   polardb
        # 
        # ```
        # 
        # {
        #   "clusterId": "pc-sdadsadsa",
        #   "database": "dsadsadsa",
        #   "ownerId": "121212122",
        #   "password": "sdasdafssa",
        #   "region": "cn-shanghai",
        #   "tag": "polardb",
        #   "username": "asdadsads"
        # }
        #                                 
        # ```
        # 
        # *   oracle
        # 
        # ```
        # 
        # {
        #   "jdbcUrl": "jdbc:oracle:saaa:@xxxxx:1521:PROD",
        #   "password": "sxasaxsa",
        #   "tag": "public",
        #   "username": "sasfadfa"
        # }
        #                                 
        # ```
        # 
        # *   mongodb
        # 
        # ```
        # 
        # {
        #   "address": "[\"xsaxxsa.mongodb.rds.aliyuncs.com:3717\"]",
        #   "database": "admin",
        #   "password": "sadsda@",
        #   "tag": "public",
        #   "username": "dsadsadas"
        # }
        #                                 
        # ```
        # 
        # *   emr
        # 
        # ```
        # 
        # {
        #   "accessId": "xsaxsa",
        #   "emrClusterId": "C-dsads",
        #   "emrResourceQueueName": "default",
        #   "emrEndpoint": "emr.aliyuncs.com",
        #   "accessKey": "dsadsad",
        #   "emrUserId": "224833315798889783",
        #   "name": "sasdsadsa",
        #   "emrAccessMode": "simple",
        #   "region": "cn-shanghai",
        #   "authType": "2",
        #   "emrProjectId": "FP-sdadsad"
        # }
        #                                 
        # ```
        # 
        # *   postgresql
        # 
        # ```
        # 
        # {
        #   "jdbcUrl": "jdbc:postgresql://xxxx:1921/ssss",
        #   "password": "sdadsads",
        #   "tag": "public",
        #   "username": "sdsasda"
        # }
        #                                 
        # ```
        # 
        # *   analyticdb_for_mysql
        # 
        # ```
        # 
        # {
        #   "instanceId": "am-sadsada",
        #   "database": "xsxsx",
        #   "username": "xsxsa",
        #   "password": "asdadsa",
        #   "connectionString": "am-xssxsxs.ads.aliyuncs.com:3306"
        # }
        #                                 
        # ```
        # 
        # *   hybriddb_for_postgresql
        # 
        # ```
        # 
        # {
        #   "connectionString": "gp-xsaxsaxa-master.gpdbmaster.rds.aliyuncs.com",
        #   "database": "xsaxsaxas",
        #   "password": "xsaxsaxsa@11",
        #   "instanceId": "gp-xsaxsaxsa",
        #   "port": "541132",
        #   "ownerId": "xsaxsaxsas",
        #   "username": "sadsad"
        # }
        #                                 
        # ```
        # 
        # *   holo
        # 
        # ```
        # 
        # {
        #   "accessId": "xsaxsaxs",
        #   "accessKey": "xsaxsaxsa",
        #   "database": "xsaxsaxsa",
        #   "instanceId": "xsaxa",
        #   "tag": "aliyun"
        # }
        #                                 
        # ```
        # 
        # *   kafka
        # 
        # ```
        # 
        # {
        #   "instanceId": "xsax-cn-xsaxsa",
        #   "regionId": "cn-shanghai",
        #   "tag": "aliyun",
        #   "ownerId": "1212121212112"
        # }
        #                                 
        # ```
        self.description = description  # type: str
        # The status of the data source. The parameter is deprecated. Do not use this parameter.
        self.env_type = env_type  # type: int
        # The HTTP status code returned.
        self.status = status  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDataSourceRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.data_source_id is not None:
            result['DataSourceId'] = self.data_source_id
        if self.description is not None:
            result['Description'] = self.description
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.status is not None:
            result['Status'] = self.status
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('DataSourceId') is not None:
            self.data_source_id = m.get('DataSourceId')
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class UpdateDataSourceResponseBody(TeaModel):
    def __init__(self, data=None, http_status_code=None, request_id=None, success=None):
        # Indicates whether the request is successful.
        self.data = data  # type: bool
        # The ID of the request.
        self.http_status_code = http_status_code  # type: str
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateDataSourceResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateDataSourceResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateDataSourceResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateDataSourceResponse, self).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=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 = UpdateDataSourceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateFileRequest(TeaModel):
    def __init__(self, advanced_settings=None, auto_parsing=None, auto_rerun_interval_millis=None,
                 auto_rerun_times=None, connection_name=None, content=None, cron_express=None, cycle_type=None,
                 dependent_node_id_list=None, dependent_type=None, end_effect_date=None, file_description=None, file_folder_path=None,
                 file_id=None, file_name=None, ignore_parent_skip_running_property=None, input_list=None,
                 input_parameters=None, output_list=None, output_parameters=None, owner=None, para_value=None, project_id=None,
                 project_identifier=None, rerun_mode=None, resource_group_identifier=None, scheduler_type=None,
                 start_effect_date=None, start_immediately=None, stop=None):
        # The advanced configurations of the node.
        # 
        # This parameter is valid only for an EMR Spark Streaming node or an EMR Streaming SQL node. This parameter corresponds to the Advanced Settings tab of the node in the [DataWorks console](https://workbench.data.aliyun.com/console).
        # 
        # This parameter is configured in the JSON format.
        self.advanced_settings = advanced_settings  # type: str
        # Specifies whether the automatic parsing feature is enabled for the file. Valid values:
        # 
        # *   true: The automatic parsing feature is enabled for the file.
        # *   false: The automatic parsing feature is not enabled for the file.
        # 
        # This parameter corresponds to the Analyze Code parameter that is displayed after Same Cycle is selected in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.auto_parsing = auto_parsing  # type: bool
        # The interval between two consecutive automatic reruns after an error occurs. Unit: milliseconds. Maximum value: 1800000 (30 minutes).
        # 
        # This parameter corresponds to the Rerun Interval parameter that is displayed after the Auto Rerun upon Error check box is selected in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        # 
        # The interval that you specify in the DataWorks console is measured in minutes. Pay attention to the conversion between the units of time when you call the operation.
        self.auto_rerun_interval_millis = auto_rerun_interval_millis  # type: int
        # The number of automatic reruns that are allowed after an error occurs.
        self.auto_rerun_times = auto_rerun_times  # type: int
        # The name of the connected data source that is used to run the node. You can call the [ListDataSources](~~211431~~) operation to query the available data sources of the workspace.
        self.connection_name = connection_name  # type: str
        # The code of the file. The code format varies based on the file type. To view the code format for a specific file type, go to Operation Center, right-click a node of the file type, and then select View Code.
        self.content = content  # type: str
        # The CRON expression that represents the periodic scheduling policy of the node. This parameter corresponds to the Cron Expression parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console). After you configure the Scheduling Cycle and Run At parameters in the DataWorks console, DataWorks automatically generates a value for the Cron Expression parameter.
        # 
        # Examples:
        # 
        # *   CRON expression for a node that is scheduled to run at 05:30 every day: `00 30 05 * * ?`
        # *   CRON expression for a node that is scheduled to run at the fifteenth minute of each hour: `00 15 * * * ?`
        # *   CRON expression for a node that is scheduled to run every 10 minutes: `00 00/10 * * * ?`
        # *   CRON expression for a node that is scheduled to run every 10 minutes from 08:00 to 17:00 every day: `00 00-59/10 8-23 * * * ?`
        # *   CRON expression for a node that is scheduled to run at 00:20 on the first day of each month: `00 20 00 1 * ?`
        # *   CRON expression for a node that is scheduled to run every three months starting from 00:10 on January 1: `00 10 00 1 1-12/3 ?`
        # *   CRON expression for a node that is scheduled to run at 00:05 every Tuesday and Friday: `00 05 00 * * 2,5`
        # 
        # The scheduling system of DataWorks imposes the following limits on CRON expressions:
        # 
        # *   A node can be scheduled to run at a minimum interval of 5 minutes.
        # *   A node can be scheduled to run at 00:05 every day at the earliest.
        self.cron_express = cron_express  # type: str
        # The type of the scheduling cycle of the node that corresponds to the file. Valid values: NOT_DAY and DAY. The value NOT_DAY indicates that the node is scheduled to run by minute or hour. The value DAY indicates that the node is scheduled to run by day, week, or month.
        # 
        # This parameter corresponds to the Scheduling Cycle parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.cycle_type = cycle_type  # type: str
        # The ID of the node on which the node corresponding to the file depends when the DependentType parameter is set to USER_DEFINE. Multiple IDs are separated by commas (,).
        # 
        # The value of this parameter corresponds to the ID of the node that you specified after you select Previous Cycle and set Depend On to Other Nodes in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.dependent_node_id_list = dependent_node_id_list  # type: str
        # The type of the cross-cycle scheduling dependency of the node that corresponds to the file. Valid values:
        # 
        # *   SELF: The instance generated for the node in the current cycle depends on the instance generated for the node in the previous cycle.
        # *   CHILD: The instance generated for the node in the current cycle depends on the instances generated for the descendant nodes at the nearest level of the node in the previous cycle.
        # *   USER_DEFINE: The instance generated for the node in the current cycle depends on the instances generated for one or more specified nodes in the previous cycle.
        # *   NONE: No cross-cycle scheduling dependency type is selected for the node.
        self.dependent_type = dependent_type  # type: str
        # The end time of automatic scheduling. Set this parameter to a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        # 
        # This parameter corresponds to the end time specified for the Validity Period parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.end_effect_date = end_effect_date  # type: long
        # The description of the file.
        self.file_description = file_description  # type: str
        # The path of the file.
        self.file_folder_path = file_folder_path  # type: str
        # The ID of the file. You can call the [ListFiles](~~173942~~) operation to obtain the ID.
        self.file_id = file_id  # type: long
        # The name of the file. You can set the FileName parameter to a new value to change the file name.
        # 
        # You can call the [ListFiles](~~173942~~) operation to query the ID of the file whose name you want to change. Then, you can set the FileId parameter to the ID and set the FileName parameter to a new value when you call the [UpdateFile](~~173951~~) operation.
        self.file_name = file_name  # type: str
        self.ignore_parent_skip_running_property = ignore_parent_skip_running_property  # type: bool
        # The output name of the parent file on which the current file depends. If you specify multiple output names, separate them with commas (,).
        # 
        # This parameter corresponds to the Output Name parameter under Parent Nodes in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.input_list = input_list  # type: str
        # The input parameters of the node. This parameter is configured in the JSON format. For more information about the input parameters, refer to the InputContextParameterList parameter in the Response parameters section of the [GetFile](~~173954~~) operation.
        # 
        # This parameter corresponds to the Input Parameters table in the Input and Output Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.input_parameters = input_parameters  # type: str
        # The output name of the current file.
        # 
        # This parameter corresponds to the Output Name parameter in the Dependencies section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.output_list = output_list  # type: str
        # The output parameters of the node. This parameter is configured in the JSON format. For more information about the output parameters, refer to the OutputContextParameterList parameter in the Response parameters section of the [GetFile](~~173954~~) operation.
        # 
        # This parameter corresponds to the Output Parameters table in the Input and Output Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.output_parameters = output_parameters  # type: str
        # The ID of the file owner.
        self.owner = owner  # type: str
        # The scheduling parameters of the node.
        # 
        # This parameter corresponds to the Parameters section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console). For more information, see [Configure scheduling parameters](~~137548~~).
        self.para_value = para_value  # type: str
        # The ID of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace ID.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the workspace name.
        # 
        # You must configure this parameter or the ProjectId parameter to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str
        # Specifies whether the node that corresponds to the file can be rerun. Valid values:
        # 
        # *   ALL_ALLOWED: The node can be rerun regardless of whether it is successfully run or fails to run.
        # *   FAILURE_ALLOWED: The node can be rerun only after it fails to run.
        # *   ALL_DENIED: The node cannot be rerun regardless of whether it is successfully run or fails to run.
        # 
        # This parameter corresponds to the Rerun parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.rerun_mode = rerun_mode  # type: str
        # The identifier of the resource group that is used to run the node. You can call the [ListResourceGroups](~~173913~~) operation to query the available resource groups in the workspace.
        self.resource_group_identifier = resource_group_identifier  # type: str
        # The scheduling type of the node. Valid values:
        # 
        # *   NORMAL: The node is an auto triggered node.
        # *   MANUAL: The node is a manually triggered node. Manually triggered nodes cannot be automatically triggered. They correspond to the nodes in the Manually Triggered Workflows pane.
        # *   PAUSE: The node is a paused node.
        # *   SKIP: The inner node is a dry-run node. Dry-run nodes are started as scheduled but the scheduling system sets the status of the nodes to succeeded when the scheduling system starts to run the nodes.
        self.scheduler_type = scheduler_type  # type: str
        # The start time of automatic scheduling. Set this parameter to a UNIX timestamp representing the number of milliseconds that have elapsed since January 1, 1970, 00:00:00 UTC.
        # 
        # This parameter corresponds to the Validity Period parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.start_effect_date = start_effect_date  # type: long
        # Specifies whether to immediately run a node after the node is deployed to the production environment. Valid values:
        # 
        # *   true: A node is immediately run after the node is deployed to the production environment.
        # *   false: A node is not immediately run after the node is deployed to the production environment.
        # 
        # This parameter is valid only for an EMR Spark Streaming node or an EMR Streaming SQL node. This parameter corresponds to the Start Method parameter in the Schedule section of the Configure tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.start_immediately = start_immediately  # type: bool
        # Specifies whether to suspend the scheduling of the node. Valid values:
        # 
        # *   true: suspends the scheduling of the node.
        # *   false: does not suspend the scheduling of the node.
        # 
        # This parameter corresponds to the Recurrence parameter in the Schedule section of the Properties tab in the [DataWorks console](https://workbench.data.aliyun.com/console).
        self.stop = stop  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateFileRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.advanced_settings is not None:
            result['AdvancedSettings'] = self.advanced_settings
        if self.auto_parsing is not None:
            result['AutoParsing'] = self.auto_parsing
        if self.auto_rerun_interval_millis is not None:
            result['AutoRerunIntervalMillis'] = self.auto_rerun_interval_millis
        if self.auto_rerun_times is not None:
            result['AutoRerunTimes'] = self.auto_rerun_times
        if self.connection_name is not None:
            result['ConnectionName'] = self.connection_name
        if self.content is not None:
            result['Content'] = self.content
        if self.cron_express is not None:
            result['CronExpress'] = self.cron_express
        if self.cycle_type is not None:
            result['CycleType'] = self.cycle_type
        if self.dependent_node_id_list is not None:
            result['DependentNodeIdList'] = self.dependent_node_id_list
        if self.dependent_type is not None:
            result['DependentType'] = self.dependent_type
        if self.end_effect_date is not None:
            result['EndEffectDate'] = self.end_effect_date
        if self.file_description is not None:
            result['FileDescription'] = self.file_description
        if self.file_folder_path is not None:
            result['FileFolderPath'] = self.file_folder_path
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.file_name is not None:
            result['FileName'] = self.file_name
        if self.ignore_parent_skip_running_property is not None:
            result['IgnoreParentSkipRunningProperty'] = self.ignore_parent_skip_running_property
        if self.input_list is not None:
            result['InputList'] = self.input_list
        if self.input_parameters is not None:
            result['InputParameters'] = self.input_parameters
        if self.output_list is not None:
            result['OutputList'] = self.output_list
        if self.output_parameters is not None:
            result['OutputParameters'] = self.output_parameters
        if self.owner is not None:
            result['Owner'] = self.owner
        if self.para_value is not None:
            result['ParaValue'] = self.para_value
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.rerun_mode is not None:
            result['RerunMode'] = self.rerun_mode
        if self.resource_group_identifier is not None:
            result['ResourceGroupIdentifier'] = self.resource_group_identifier
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        if self.start_effect_date is not None:
            result['StartEffectDate'] = self.start_effect_date
        if self.start_immediately is not None:
            result['StartImmediately'] = self.start_immediately
        if self.stop is not None:
            result['Stop'] = self.stop
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AdvancedSettings') is not None:
            self.advanced_settings = m.get('AdvancedSettings')
        if m.get('AutoParsing') is not None:
            self.auto_parsing = m.get('AutoParsing')
        if m.get('AutoRerunIntervalMillis') is not None:
            self.auto_rerun_interval_millis = m.get('AutoRerunIntervalMillis')
        if m.get('AutoRerunTimes') is not None:
            self.auto_rerun_times = m.get('AutoRerunTimes')
        if m.get('ConnectionName') is not None:
            self.connection_name = m.get('ConnectionName')
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('CronExpress') is not None:
            self.cron_express = m.get('CronExpress')
        if m.get('CycleType') is not None:
            self.cycle_type = m.get('CycleType')
        if m.get('DependentNodeIdList') is not None:
            self.dependent_node_id_list = m.get('DependentNodeIdList')
        if m.get('DependentType') is not None:
            self.dependent_type = m.get('DependentType')
        if m.get('EndEffectDate') is not None:
            self.end_effect_date = m.get('EndEffectDate')
        if m.get('FileDescription') is not None:
            self.file_description = m.get('FileDescription')
        if m.get('FileFolderPath') is not None:
            self.file_folder_path = m.get('FileFolderPath')
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('FileName') is not None:
            self.file_name = m.get('FileName')
        if m.get('IgnoreParentSkipRunningProperty') is not None:
            self.ignore_parent_skip_running_property = m.get('IgnoreParentSkipRunningProperty')
        if m.get('InputList') is not None:
            self.input_list = m.get('InputList')
        if m.get('InputParameters') is not None:
            self.input_parameters = m.get('InputParameters')
        if m.get('OutputList') is not None:
            self.output_list = m.get('OutputList')
        if m.get('OutputParameters') is not None:
            self.output_parameters = m.get('OutputParameters')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('ParaValue') is not None:
            self.para_value = m.get('ParaValue')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('RerunMode') is not None:
            self.rerun_mode = m.get('RerunMode')
        if m.get('ResourceGroupIdentifier') is not None:
            self.resource_group_identifier = m.get('ResourceGroupIdentifier')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        if m.get('StartEffectDate') is not None:
            self.start_effect_date = m.get('StartEffectDate')
        if m.get('StartImmediately') is not None:
            self.start_immediately = m.get('StartImmediately')
        if m.get('Stop') is not None:
            self.stop = m.get('Stop')
        return self


class UpdateFileResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, success=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateFileResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateFileResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateFileResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateFileResponse, self).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=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 = UpdateFileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateFolderRequest(TeaModel):
    def __init__(self, folder_id=None, folder_name=None, project_id=None, project_identifier=None):
        # The ID of the folder. You can call the [ListFolders](~~173955~~) operation to query the ID.
        self.folder_id = folder_id  # type: str
        # The name of the folder.
        self.folder_name = folder_name  # type: str
        # The ID of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Management page to obtain the ID. You must specify either this parameter or ProjectIdentifier to determine the DataWorks workspace to which the operation is applied.
        self.project_id = project_id  # type: long
        # The name of the DataWorks workspace. You can log on to the DataWorks console and go to the Workspace Settings panel to obtain the name. You must specify either this parameter or ProjectId to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateFolderRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.folder_id is not None:
            result['FolderId'] = self.folder_id
        if self.folder_name is not None:
            result['FolderName'] = self.folder_name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FolderId') is not None:
            self.folder_id = m.get('FolderId')
        if m.get('FolderName') is not None:
            self.folder_name = m.get('FolderName')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        return self


class UpdateFolderResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, success=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateFolderResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateFolderResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateFolderResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateFolderResponse, self).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=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 = UpdateFolderResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateIDEEventResultRequest(TeaModel):
    def __init__(self, check_result=None, check_result_tip=None, extension_code=None, message_id=None):
        # The summary information of the check result. The information is displayed in DataStudio. If an alert is reported or the event fails the check, you can troubleshoot errors based on the information.
        self.check_result = check_result  # type: str
        # The ID of the request. You can troubleshoot errors based on the ID.
        self.check_result_tip = check_result_tip  # type: str
        # The check status of the extension point event. Valid values:
        # 
        # *   OK: The event passes the check.
        # *   FAIL: The event fails to pass the check. You must check and handle the reported error at the earliest opportunity to ensure that your program is run as expected.
        # *   WARN: The event passes the check, but an alert is reported.
        self.extension_code = extension_code  # type: str
        # The ID of the extension. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Extensions tab of the Open Platform page to view the ID.
        self.message_id = message_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateIDEEventResultRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.check_result is not None:
            result['CheckResult'] = self.check_result
        if self.check_result_tip is not None:
            result['CheckResultTip'] = self.check_result_tip
        if self.extension_code is not None:
            result['ExtensionCode'] = self.extension_code
        if self.message_id is not None:
            result['MessageId'] = self.message_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CheckResult') is not None:
            self.check_result = m.get('CheckResult')
        if m.get('CheckResultTip') is not None:
            self.check_result_tip = m.get('CheckResultTip')
        if m.get('ExtensionCode') is not None:
            self.extension_code = m.get('ExtensionCode')
        if m.get('MessageId') is not None:
            self.message_id = m.get('MessageId')
        return self


class UpdateIDEEventResultResponseBody(TeaModel):
    def __init__(self, request_id=None):
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateIDEEventResultResponseBody, self).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=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


class UpdateIDEEventResultResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateIDEEventResultResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateIDEEventResultResponse, self).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=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 = UpdateIDEEventResultResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateMetaCategoryRequest(TeaModel):
    def __init__(self, category_id=None, comment=None, name=None):
        # The ID of the category.
        self.category_id = category_id  # type: long
        # The remarks of the category.
        self.comment = comment  # type: str
        # The name of the category.
        self.name = name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateMetaCategoryRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.category_id is not None:
            result['CategoryId'] = self.category_id
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.name is not None:
            result['Name'] = self.name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CategoryId') is not None:
            self.category_id = m.get('CategoryId')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        return self


class UpdateMetaCategoryResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the category was updated.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request was successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateMetaCategoryResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateMetaCategoryResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateMetaCategoryResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateMetaCategoryResponse, self).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=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 = UpdateMetaCategoryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateMetaCollectionRequest(TeaModel):
    def __init__(self, comment=None, name=None, qualified_name=None):
        # The ID of the request. You can use the ID to query logs and troubleshoot issues.
        self.comment = comment  # type: str
        # The comment of the collection.
        # 
        # The comment must be 1 to 64 characters in length.
        self.name = name  # type: str
        # The name of the collection.
        self.qualified_name = qualified_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateMetaCollectionRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.name is not None:
            result['Name'] = self.name
        if self.qualified_name is not None:
            result['QualifiedName'] = self.qualified_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('QualifiedName') is not None:
            self.qualified_name = m.get('QualifiedName')
        return self


class UpdateMetaCollectionResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, status=None,
                 success=None):
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.error_code = error_code  # type: str
        # The error code returned.
        self.error_message = error_message  # type: str
        # The error message returned.
        self.http_status_code = http_status_code  # type: int
        # The result of the operation. Valid values:
        # 
        # true: succeeded
        # 
        # false: failed
        self.request_id = request_id  # type: str
        # The HTTP status code returned.
        self.status = status  # type: bool
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateMetaCollectionResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.status is not None:
            result['Status'] = self.status
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateMetaCollectionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateMetaCollectionResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateMetaCollectionResponse, self).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=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 = UpdateMetaCollectionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateMetaTableRequest(TeaModel):
    def __init__(self, added_labels=None, caption=None, category_id=None, env_type=None, new_owner_id=None,
                 project_id=None, removed_labels=None, schema=None, table_guid=None, table_name=None, visibility=None):
        # The names of the labels that you want to add. Separate the labels with commas (,).
        self.added_labels = added_labels  # type: str
        # The display name of the table.
        self.caption = caption  # type: str
        # The ID of the category that you want to associate.
        self.category_id = category_id  # type: long
        # The environment of the DataWorks workspace. Valid values: 0 and 1. The value 0 indicates the development environment. The value 1 indicates the production environment.
        self.env_type = env_type  # type: int
        # The ID of the new owner. If this parameter is not specified, the owner ID is not updated.
        self.new_owner_id = new_owner_id  # type: str
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long
        # The names of labels that you want to delete. Separate the labels with commas (,).
        self.removed_labels = removed_labels  # type: str
        # The schema information of the table. You need to configure this parameter if you enable the table schema in MaxCompute.
        self.schema = schema  # type: str
        # The globally unique identifier (GUID) of the table. Specify the GUID in the format of odps.{projectName}.{tableName}.
        self.table_guid = table_guid  # type: str
        # The name of the table.
        self.table_name = table_name  # type: str
        # The scope in which the table is visible. Valid values: 0, 1, and 2. The value 0 indicates that the table is invisible to all workspace members. The value 1 indicates that the table is visible to all workspace members. The value 2 indicates that the table is visible to workspace members.
        self.visibility = visibility  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateMetaTableRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.added_labels is not None:
            result['AddedLabels'] = self.added_labels
        if self.caption is not None:
            result['Caption'] = self.caption
        if self.category_id is not None:
            result['CategoryId'] = self.category_id
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.new_owner_id is not None:
            result['NewOwnerId'] = self.new_owner_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.removed_labels is not None:
            result['RemovedLabels'] = self.removed_labels
        if self.schema is not None:
            result['Schema'] = self.schema
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        if self.table_name is not None:
            result['TableName'] = self.table_name
        if self.visibility is not None:
            result['Visibility'] = self.visibility
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AddedLabels') is not None:
            self.added_labels = m.get('AddedLabels')
        if m.get('Caption') is not None:
            self.caption = m.get('Caption')
        if m.get('CategoryId') is not None:
            self.category_id = m.get('CategoryId')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('NewOwnerId') is not None:
            self.new_owner_id = m.get('NewOwnerId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RemovedLabels') is not None:
            self.removed_labels = m.get('RemovedLabels')
        if m.get('Schema') is not None:
            self.schema = m.get('Schema')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        if m.get('Visibility') is not None:
            self.visibility = m.get('Visibility')
        return self


class UpdateMetaTableResponseBody(TeaModel):
    def __init__(self, request_id=None, update_result=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the metadata information about the table is updated.
        self.update_result = update_result  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateMetaTableResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.update_result is not None:
            result['UpdateResult'] = self.update_result
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('UpdateResult') is not None:
            self.update_result = m.get('UpdateResult')
        return self


class UpdateMetaTableResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateMetaTableResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateMetaTableResponse, self).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=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 = UpdateMetaTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateMetaTableIntroWikiRequest(TeaModel):
    def __init__(self, content=None, table_guid=None):
        # The details of the instructions on how to use the metatable.
        self.content = content  # type: str
        # The GUID of the metatable. Specify the GUID in the format of odps.{projectName}.{tableName}.
        self.table_guid = table_guid  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateMetaTableIntroWikiRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        return self


class UpdateMetaTableIntroWikiResponseBody(TeaModel):
    def __init__(self, request_id=None, update_result=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # The updated instructions.
        self.update_result = update_result  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateMetaTableIntroWikiResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.update_result is not None:
            result['UpdateResult'] = self.update_result
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('UpdateResult') is not None:
            self.update_result = m.get('UpdateResult')
        return self


class UpdateMetaTableIntroWikiResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateMetaTableIntroWikiResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateMetaTableIntroWikiResponse, self).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=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 = UpdateMetaTableIntroWikiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateNodeOwnerRequest(TeaModel):
    def __init__(self, node_id=None, project_env=None, user_id=None):
        # The ID of the node. You can call the [ListNodes](~~173979~~) operation to query the ID.
        self.node_id = node_id  # type: long
        # The environment where the node runs. Valid values: DEV and PROD. The value DEV indicates the development environment. The value PROD indicates the production environment.
        self.project_env = project_env  # type: str
        # The Alibaba Cloud account ID of the node owner. You can log on to the DataWorks console and move the pointer over the profile picture in the upper-right corner to view the ID.
        self.user_id = user_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateNodeOwnerRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.user_id is not None:
            result['UserId'] = self.user_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('UserId') is not None:
            self.user_id = m.get('UserId')
        return self


class UpdateNodeOwnerResponseBody(TeaModel):
    def __init__(self, request_id=None, success=None):
        # The ID of the request. You can use the ID to obtain logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: indicates that the request is successful.
        # *   false: indicates that the request fails.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateNodeOwnerResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateNodeOwnerResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateNodeOwnerResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateNodeOwnerResponse, self).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=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 = UpdateNodeOwnerResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateNodeRunModeRequest(TeaModel):
    def __init__(self, node_id=None, project_env=None, scheduler_type=None):
        # The ID of the node. You can call the [ListNodes](~~173979~~) operation to query the ID.
        self.node_id = node_id  # type: long
        # The environment where the node runs. Valid values: DEV and PROD. The value DEV indicates the development environment. The value PROD indicates the production environment.
        self.project_env = project_env  # type: str
        # The operation that you want to perform on the node. Valid values:
        # 
        # *   0: indicates that you want to unfreeze the node.
        # *   2: indicates that you want to freeze the node.
        self.scheduler_type = scheduler_type  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateNodeRunModeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.node_id is not None:
            result['NodeId'] = self.node_id
        if self.project_env is not None:
            result['ProjectEnv'] = self.project_env
        if self.scheduler_type is not None:
            result['SchedulerType'] = self.scheduler_type
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('NodeId') is not None:
            self.node_id = m.get('NodeId')
        if m.get('ProjectEnv') is not None:
            self.project_env = m.get('ProjectEnv')
        if m.get('SchedulerType') is not None:
            self.scheduler_type = m.get('SchedulerType')
        return self


class UpdateNodeRunModeResponseBody(TeaModel):
    def __init__(self, request_id=None, success=None):
        # The ID of the request. You can use the ID to obtain logs and troubleshoot issues.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: indicates that the request is successful.
        # *   false: indicates that the request fails.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateNodeRunModeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateNodeRunModeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateNodeRunModeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateNodeRunModeResponse, self).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=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 = UpdateNodeRunModeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateQualityFollowerRequest(TeaModel):
    def __init__(self, alarm_mode=None, follower=None, follower_id=None, project_id=None, project_name=None):
        # The notification method. Valid values: 1, 2, 4, and 5. 1 indicates that the notification is sent by email. 2 indicates that the notification is sent by email and text message. 4 indicates that the notification is sent by a DingTalk chatbot. 5 indicates that the notification is sent by a DingTalk chatbot to all members in a DingTalk group.
        self.alarm_mode = alarm_mode  # type: int
        # The name of the subscriber.
        self.follower = follower  # type: str
        # The ID of the subscription relationship.
        self.follower_id = follower_id  # type: long
        self.project_id = project_id  # type: long
        # The name of the computing engine instance or data source.
        self.project_name = project_name  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateQualityFollowerRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alarm_mode is not None:
            result['AlarmMode'] = self.alarm_mode
        if self.follower is not None:
            result['Follower'] = self.follower
        if self.follower_id is not None:
            result['FollowerId'] = self.follower_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlarmMode') is not None:
            self.alarm_mode = m.get('AlarmMode')
        if m.get('Follower') is not None:
            self.follower = m.get('Follower')
        if m.get('FollowerId') is not None:
            self.follower_id = m.get('FollowerId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class UpdateQualityFollowerResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the subscription relationship is updated.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateQualityFollowerResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateQualityFollowerResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateQualityFollowerResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateQualityFollowerResponse, self).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=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 = UpdateQualityFollowerResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateQualityRuleRequest(TeaModel):
    def __init__(self, block_type=None, checker=None, comment=None, critical_threshold=None, entity_id=None,
                 expect_value=None, id=None, method_name=None, open_switch=None, operator=None, predict_type=None,
                 project_id=None, project_name=None, property=None, property_type=None, rule_name=None, rule_type=None,
                 template_id=None, trend=None, warning_threshold=None, where_condition=None):
        # The strength of the monitoring rule. The strength of a monitoring rule indicates the importance of the rule. Valid values:
        # 
        # *   1: indicates that the monitoring rule is a strong rule.
        # 
        # *   0: indicates that the monitoring rule is a weak rule.
        # 
        #     You can specify whether a monitoring rule is a strong rule based on your business requirements. If a strong rule is used and a critical alert is triggered, nodes are blocked.
        self.block_type = block_type  # type: int
        # The ID of the checker. You can call the [ListQualityRules](~~173995~~) operation to obtain the ID of the checker.
        self.checker = checker  # type: int
        # The description of the monitoring rule.
        self.comment = comment  # type: str
        # The threshold for a critical alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements. If a strong rule is used and an error alert is triggered, nodes are blocked.
        self.critical_threshold = critical_threshold  # type: str
        # The ID of the partition filter expression. You can call the [GetQualityEntity](~~173995~~) operation to obtain the ID of the partition filter expression.
        self.entity_id = entity_id  # type: long
        # The expected value of the monitoring result.
        self.expect_value = expect_value  # type: str
        # The ID of the monitoring rule. You can call the [ListQualityRules](~~173995~~) operation to obtain the ID of the monitoring rule.
        self.id = id  # type: long
        # The method that is used to collect sample data, such as avg, count, sum, min, max, count_distinct, user_defined, table_count, table_size, table_dt_load_count, table_dt_refuseload_count, null_value, null_value/table_count, (table_count-count_distinct)/table_count, or table_count-count_distinct.
        self.method_name = method_name  # type: str
        # Specifies whether to enable the monitoring rule in the production environment.
        # 
        # *   true: The monitoring rule is triggered when the associated auto triggered node that generates the output data starts to run.
        # *   false: The monitoring rule is not triggered when the associated auto triggered node that generates the output data starts to run.
        self.open_switch = open_switch  # type: bool
        # The comparison operator, such as >, >=, =, ≠, <, or <=.
        self.operator = operator  # type: str
        # Specifies whether the threshold is a dynamic threshold. Valid values:
        # 
        # *   0: indicates that the threshold is not a dynamic threshold.
        # *   2: indicates that the threshold is a dynamic threshold.
        self.predict_type = predict_type  # type: int
        self.project_id = project_id  # type: long
        # The name of the compute engine instance or data source. You can log on to the [DataWorks console](https://workbench.data.aliyun.com/console) and go to the Workspace Management page to obtain the name.
        self.project_name = project_name  # type: str
        # The name of the field to be monitored.
        self.property = property  # type: str
        # The data type of the field.
        self.property_type = property_type  # type: str
        # The name of the monitoring rule.
        self.rule_name = rule_name  # type: str
        # The type of the monitoring rule. Valid values:
        # 
        # *   0: The monitoring rule is created by the system.
        # *   1: The monitoring rule is created by a user.
        # *   2: The monitoring rule is a workspace-level rule.
        self.rule_type = rule_type  # type: int
        # The ID of the monitoring template. You can call the [ListQualityRules](~~173995~~) operation to obtain the ID of the monitoring template that is used to create the monitoring rule.
        self.template_id = template_id  # type: int
        # The trend of the monitoring result. Valid values:
        # 
        # *   up: increasing
        # *   down: decreasing
        # *   abs: absolute value
        self.trend = trend  # type: str
        # The threshold for a warning alert. The threshold indicates the deviation of the monitoring result from the expected value. You can customize this threshold based on your business requirements.
        self.warning_threshold = warning_threshold  # type: str
        # The filter condition or custom SQL statement that is used for monitoring.
        self.where_condition = where_condition  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateQualityRuleRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.block_type is not None:
            result['BlockType'] = self.block_type
        if self.checker is not None:
            result['Checker'] = self.checker
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.critical_threshold is not None:
            result['CriticalThreshold'] = self.critical_threshold
        if self.entity_id is not None:
            result['EntityId'] = self.entity_id
        if self.expect_value is not None:
            result['ExpectValue'] = self.expect_value
        if self.id is not None:
            result['Id'] = self.id
        if self.method_name is not None:
            result['MethodName'] = self.method_name
        if self.open_switch is not None:
            result['OpenSwitch'] = self.open_switch
        if self.operator is not None:
            result['Operator'] = self.operator
        if self.predict_type is not None:
            result['PredictType'] = self.predict_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.property is not None:
            result['Property'] = self.property
        if self.property_type is not None:
            result['PropertyType'] = self.property_type
        if self.rule_name is not None:
            result['RuleName'] = self.rule_name
        if self.rule_type is not None:
            result['RuleType'] = self.rule_type
        if self.template_id is not None:
            result['TemplateId'] = self.template_id
        if self.trend is not None:
            result['Trend'] = self.trend
        if self.warning_threshold is not None:
            result['WarningThreshold'] = self.warning_threshold
        if self.where_condition is not None:
            result['WhereCondition'] = self.where_condition
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('BlockType') is not None:
            self.block_type = m.get('BlockType')
        if m.get('Checker') is not None:
            self.checker = m.get('Checker')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CriticalThreshold') is not None:
            self.critical_threshold = m.get('CriticalThreshold')
        if m.get('EntityId') is not None:
            self.entity_id = m.get('EntityId')
        if m.get('ExpectValue') is not None:
            self.expect_value = m.get('ExpectValue')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('MethodName') is not None:
            self.method_name = m.get('MethodName')
        if m.get('OpenSwitch') is not None:
            self.open_switch = m.get('OpenSwitch')
        if m.get('Operator') is not None:
            self.operator = m.get('Operator')
        if m.get('PredictType') is not None:
            self.predict_type = m.get('PredictType')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('Property') is not None:
            self.property = m.get('Property')
        if m.get('PropertyType') is not None:
            self.property_type = m.get('PropertyType')
        if m.get('RuleName') is not None:
            self.rule_name = m.get('RuleName')
        if m.get('RuleType') is not None:
            self.rule_type = m.get('RuleType')
        if m.get('TemplateId') is not None:
            self.template_id = m.get('TemplateId')
        if m.get('Trend') is not None:
            self.trend = m.get('Trend')
        if m.get('WarningThreshold') is not None:
            self.warning_threshold = m.get('WarningThreshold')
        if m.get('WhereCondition') is not None:
            self.where_condition = m.get('WhereCondition')
        return self


class UpdateQualityRuleResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # Indicates whether the monitoring rule is updated.
        self.data = data  # type: bool
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateQualityRuleResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateQualityRuleResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateQualityRuleResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateQualityRuleResponse, self).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=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 = UpdateQualityRuleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateRemindRequest(TeaModel):
    def __init__(self, alert_interval=None, alert_methods=None, alert_targets=None, alert_unit=None,
                 baseline_ids=None, biz_process_ids=None, detail=None, dnd_end=None, max_alert_times=None, node_ids=None,
                 project_id=None, remind_id=None, remind_name=None, remind_type=None, remind_unit=None, robot_urls=None,
                 use_flag=None, webhooks=None):
        # The recipient to whom alert notifications are sent. Valid values: OWNER and OTHER. The value OWNER indicates that alert notifications are sent to the object owner. The value OTHER indicates that alert notifications are sent to a specified user.
        self.alert_interval = alert_interval  # type: int
        # Specifies whether to enable the alert rule. Valid values:
        # 
        # *   true: enables the alert rule.
        # *   false: disables the alert rule.
        self.alert_methods = alert_methods  # type: str
        # The webhook URL of the DingTalk chatbot. You can specify multiple webhook URLs. Separate them with commas (,).
        # 
        # If this parameter is set to undefined, the specified webhook URLs are cleared.
        self.alert_targets = alert_targets  # type: str
        # The value format required by this parameter varies based on the value that you specify for the AlertUnit parameter. Take note of the following items:
        # 
        # *   If the AlertUnit parameter is set to OWNER, leave this parameter empty.
        # *   If the AlertUnit parameter is set to OTHER, set this parameter to the unique ID (UID) of the specified user. You can specify multiple IDs. Separate them with commas (,). You can specify a maximum of 10 IDs.
        self.alert_unit = alert_unit  # type: str
        # The ID of the workflow to which the custom alert rule is applied.. An alert rule can monitor a maximum of five workflows. Separate multiple IDs with commas (,).
        # 
        # This parameter takes effect when you set the RemindUnit parameter to BIZPROCESS.
        self.baseline_ids = baseline_ids  # type: str
        # The maximum number of alerts. Valid values: 1 to 10. Default value: 3.
        self.biz_process_ids = biz_process_ids  # type: str
        # The notification method. Valid values:
        # 
        # *   MAIL: Alert notifications are sent by emails.
        # *   SMS: Alert notifications are sent by text messages.
        # *   PHONE: Alert notifications are sent by phone calls. You can use this notification method only in DataWorks Professional Edition or more advanced editions.
        # *   DINGROBOTS: Alert notifications are sent by DingTalk messages. You can use this notification method only if the RobotUrls parameter is configured.
        # *   WEBHOOKS (WeCom or Lark chatbot): Alert notifications are sent by WeCom or Lark messages. If you want to use this notification method, you must configure the Webhooks parameter.
        # 
        # You can specify multiple notification methods. Separate the specified notification methods with commas (,).
        self.detail = detail  # type: str
        # The ID of the node to which the custom alert rule is applied.. An alert rule can monitor a maximum of 50 nodes. Separate multiple IDs with commas (,).
        # 
        # This parameter takes effect when you set the RemindUnit parameter to NODE.
        self.dnd_end = dnd_end  # type: str
        # The details of the conditions that trigger an alert.
        # 
        # *   If the RemindType parameter is set to FINISHED, leave this parameter empty.
        # 
        # *   If the RemindType parameter is set to UNFINISHED, set this parameter to key-value pairs. Example: {"hour":23,"minu":59}. Valid values of hour: 0 to 47. Valid values of minu: 0 to 59.
        # 
        # *   If the RemindType parameter is set to ERROR, leave this parameter empty.
        # 
        # *   If the RemindType parameter is set to CYCLE_UNFINISHED, set this parameter to key-value pairs in the JSON format. Example: {"1":"05:50","2":"06:50","3":"07:50","4":"08:50","5":"09:50","6":"10:50","7":"11:50","8":"12:50","9":"13:50","10":"14:50","11":"15:50","12":"16:50","13":"17:50","14":"18:50","15":"19:50","16":"20:50","17":"21:50","18":"22:50","19":"23:50","20":"24:50","21":"25:50"}.
        # 
        #     A key in the JSON string indicates the sequence number of a cycle. Valid values of keys: 1 to 288. A value in the JSON string indicates the time in point when a monitored instance times out in the relevant cycle. Values must be in the format of hh:mm. Valid values of hh: 0 to 47. Valid values of mm: 0 to 59.
        # 
        # *   If the RemindType parameter is set to TIMEOUT, set this parameter to the timeout period. Unit: seconds. Example: 1800. This indicates that an alert notification is sent if the duration of a monitored instance exceeds 30 minutes.
        self.max_alert_times = max_alert_times  # type: int
        # The ID of the workspace to which the custom alert rule is applied.. Only one workspace can be specified for a custom alert rule.
        # 
        # This parameter takes effect when you set the RemindUnit parameter to PROJECT.
        self.node_ids = node_ids  # type: str
        # The condition that triggers the alert rule. Valid values:
        # 
        # *   FINISHED: The system monitors an instance when it starts to run and sends an alert notification after the running of the instance is complete.
        # *   UNFINISHED: The system monitors an instance when it starts to run and sends an alert notification if the instance is still running at the specified point in time.
        # *   ERROR: The system monitors an instance when it starts to run and sends an alert notification if an error occurs.
        # *   CYCLE_UNFINISHED: The system sends an alert notification if a monitored instance is still running at the end of the specified cycle. In most cases, you can configure this trigger condition for node instances that are scheduled to run by hour.
        # *   TIMEOUT: The system monitors an instance when it starts to run and sends an alert notification if the instance is still running after the specified period ends. In most cases, you can configure this trigger condition to monitor the duration of node instances.
        # 
        # For more information, see [Manage custom alert rules](~~138172~~).
        self.project_id = project_id  # type: long
        # The end of the period during which no alert notifications are sent. Specify the time in the hh:mm format. Valid values of hh: 0 to 23. Valid values of mm: 0 to 59.
        self.remind_id = remind_id  # type: long
        # The type of the object to which the custom alert rule is applied.. Valid values:
        # 
        # *   NODE: node
        # *   BASELINE: baseline
        # *   PROJECT: workspace
        # *   BIZPROCESS: workflow
        self.remind_name = remind_name  # type: str
        # The intervals at which alert notifications are sent. Unit: seconds. Minimum value: 1200. Default value: 1800.
        self.remind_type = remind_type  # type: str
        # The ID of the baseline to which the custom alert rule is applied.. An alert rule can monitor a maximum of five baselines. Separate multiple IDs with commas (,).
        # 
        # This parameter takes effect when you set the RemindUnit parameter to BASELINE.
        self.remind_unit = remind_unit  # type: str
        # The HTTP status code returned.
        self.robot_urls = robot_urls  # type: str
        # The webhook URL of the WeCom or Lark chatbot. You can specify multiple webhook URLs. Separate the specified webhook URLs with commas (,). The WEBHOOKS notification method must be specified for alertMethods. If this parameter is set to undefined, the specified webhook URLs are cleared.
        # 
        # Only DataWorks Enterprise Edition supports this parameter.
        # 
        # The webhook URL-based alerting feature is supported in the following regions: China (Shanghai), China (Chengdu), China (Zhangjiakou), China (Beijing), China (Hangzhou), China (Shenzhen), China (Hong Kong), Germany (Frankfurt), and Singapore.
        self.use_flag = use_flag  # type: bool
        # Indicates whether the modification to the custom alert rule succeeds.
        self.webhooks = webhooks  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateRemindRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alert_interval is not None:
            result['AlertInterval'] = self.alert_interval
        if self.alert_methods is not None:
            result['AlertMethods'] = self.alert_methods
        if self.alert_targets is not None:
            result['AlertTargets'] = self.alert_targets
        if self.alert_unit is not None:
            result['AlertUnit'] = self.alert_unit
        if self.baseline_ids is not None:
            result['BaselineIds'] = self.baseline_ids
        if self.biz_process_ids is not None:
            result['BizProcessIds'] = self.biz_process_ids
        if self.detail is not None:
            result['Detail'] = self.detail
        if self.dnd_end is not None:
            result['DndEnd'] = self.dnd_end
        if self.max_alert_times is not None:
            result['MaxAlertTimes'] = self.max_alert_times
        if self.node_ids is not None:
            result['NodeIds'] = self.node_ids
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.remind_id is not None:
            result['RemindId'] = self.remind_id
        if self.remind_name is not None:
            result['RemindName'] = self.remind_name
        if self.remind_type is not None:
            result['RemindType'] = self.remind_type
        if self.remind_unit is not None:
            result['RemindUnit'] = self.remind_unit
        if self.robot_urls is not None:
            result['RobotUrls'] = self.robot_urls
        if self.use_flag is not None:
            result['UseFlag'] = self.use_flag
        if self.webhooks is not None:
            result['Webhooks'] = self.webhooks
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AlertInterval') is not None:
            self.alert_interval = m.get('AlertInterval')
        if m.get('AlertMethods') is not None:
            self.alert_methods = m.get('AlertMethods')
        if m.get('AlertTargets') is not None:
            self.alert_targets = m.get('AlertTargets')
        if m.get('AlertUnit') is not None:
            self.alert_unit = m.get('AlertUnit')
        if m.get('BaselineIds') is not None:
            self.baseline_ids = m.get('BaselineIds')
        if m.get('BizProcessIds') is not None:
            self.biz_process_ids = m.get('BizProcessIds')
        if m.get('Detail') is not None:
            self.detail = m.get('Detail')
        if m.get('DndEnd') is not None:
            self.dnd_end = m.get('DndEnd')
        if m.get('MaxAlertTimes') is not None:
            self.max_alert_times = m.get('MaxAlertTimes')
        if m.get('NodeIds') is not None:
            self.node_ids = m.get('NodeIds')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('RemindId') is not None:
            self.remind_id = m.get('RemindId')
        if m.get('RemindName') is not None:
            self.remind_name = m.get('RemindName')
        if m.get('RemindType') is not None:
            self.remind_type = m.get('RemindType')
        if m.get('RemindUnit') is not None:
            self.remind_unit = m.get('RemindUnit')
        if m.get('RobotUrls') is not None:
            self.robot_urls = m.get('RobotUrls')
        if m.get('UseFlag') is not None:
            self.use_flag = m.get('UseFlag')
        if m.get('Webhooks') is not None:
            self.webhooks = m.get('Webhooks')
        return self


class UpdateRemindResponseBody(TeaModel):
    def __init__(self, data=None, error_code=None, error_message=None, http_status_code=None, request_id=None,
                 success=None):
        # The ID of the request. You can use the ID to troubleshoot issues.
        self.data = data  # type: bool
        self.error_code = error_code  # type: str
        # Indicates whether the request was successful. Valid values:
        # 
        # *   true: The request was successful.
        # *   false: The request failed.
        self.error_message = error_message  # type: str
        # The error message returned.
        self.http_status_code = http_status_code  # type: int
        # The error code returned.
        self.request_id = request_id  # type: str
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateRemindResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.data is not None:
            result['Data'] = self.data
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Data') is not None:
            self.data = m.get('Data')
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateRemindResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateRemindResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateRemindResponse, self).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=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 = UpdateRemindResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateTableRequestColumns(TeaModel):
    def __init__(self, column_name=None, column_name_cn=None, column_type=None, comment=None, is_partition_col=None,
                 length=None, seq_number=None):
        # The comment of the field.
        self.column_name = column_name  # type: str
        # The name of the field.
        self.column_name_cn = column_name_cn  # type: str
        # The sequence number of the field. If the field is a partition field, this parameter is not supported.
        self.column_type = column_type  # type: str
        # The type of the field. For more information, see MaxCompute field types.
        self.comment = comment  # type: str
        # The ID of the associated topic.
        self.is_partition_col = is_partition_col  # type: bool
        # Specifies whether the field is a partition field. Valid values: 0 and 1. The value 0 indicates that the field is not a partition field. The value 1 indicates that the field is a partition field.
        self.length = length  # type: int
        # The length of the field.
        self.seq_number = seq_number  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateTableRequestColumns, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.column_name_cn is not None:
            result['ColumnNameCn'] = self.column_name_cn
        if self.column_type is not None:
            result['ColumnType'] = self.column_type
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.is_partition_col is not None:
            result['IsPartitionCol'] = self.is_partition_col
        if self.length is not None:
            result['Length'] = self.length
        if self.seq_number is not None:
            result['SeqNumber'] = self.seq_number
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('ColumnNameCn') is not None:
            self.column_name_cn = m.get('ColumnNameCn')
        if m.get('ColumnType') is not None:
            self.column_type = m.get('ColumnType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('IsPartitionCol') is not None:
            self.is_partition_col = m.get('IsPartitionCol')
        if m.get('Length') is not None:
            self.length = m.get('Length')
        if m.get('SeqNumber') is not None:
            self.seq_number = m.get('SeqNumber')
        return self


class UpdateTableRequestThemes(TeaModel):
    def __init__(self, theme_id=None, theme_level=None):
        # The level that corresponds to the topic ID.
        self.theme_id = theme_id  # type: long
        # The ID of the request.
        self.theme_level = theme_level  # type: int

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateTableRequestThemes, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.theme_id is not None:
            result['ThemeId'] = self.theme_id
        if self.theme_level is not None:
            result['ThemeLevel'] = self.theme_level
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ThemeId') is not None:
            self.theme_id = m.get('ThemeId')
        if m.get('ThemeLevel') is not None:
            self.theme_level = m.get('ThemeLevel')
        return self


class UpdateTableRequest(TeaModel):
    def __init__(self, app_guid=None, category_id=None, columns=None, comment=None, create_if_not_exists=None,
                 endpoint=None, env_type=None, external_table_type=None, has_part=None, is_view=None, life_cycle=None,
                 location=None, logical_level_id=None, owner_id=None, physics_level_id=None, project_id=None, schema=None,
                 table_name=None, themes=None, visibility=None):
        # Specifies whether the table exists. Valid values:
        # 
        # *   true: The table exists.
        # *   false: The table does not exist.
        # 
        # This parameter is deprecated. Do not use this parameter.
        self.app_guid = app_guid  # type: str
        # The ID of the logical level.
        self.category_id = category_id  # type: long
        self.columns = columns  # type: list[UpdateTableRequestColumns]
        # The schema information of the table. You need to enter the schema information of the table if you enable the table schema in MaxCompute.
        self.comment = comment  # type: str
        # Specifies whether the table that you want to update is a partitioned table. Valid values: 0 and 1. The value 0 indicates that the table is not a partitioned table. The value 1 indicates that the table is a partitioned table. This parameter is deprecated. Do not use this parameter.
        # 
        # The Column.N.isPartitionCol parameter is used instead of the HasPart parameter to specify whether the MaxCompute table is a partitioned table. If the Column.N.isPartitionCol parameter is set to 1, the MaxCompute table is a partitioned table.
        self.create_if_not_exists = create_if_not_exists  # type: bool
        # The environment of the DataWorks workspace. Valid values: 0 and 1. The value 0 indicates the development environment. The value 1 indicates the production environment.
        self.endpoint = endpoint  # type: str
        # The globally unique identifier (GUID) of the MaxCompute project. Specify the GUID in the odps.{projectName} format.
        self.env_type = env_type  # type: int
        # The storage location of the external table. This parameter is deprecated. Do not use this parameter.
        self.external_table_type = external_table_type  # type: str
        # The comment.
        self.has_part = has_part  # type: int
        # The scope in which the table is visible. Valid values: 0, 1, and 2. The value 0 indicates that the table is invisible to all workspace members. The value 1 indicates that the table is visible to all workspace members. The value 2 indicates that the table is visible to workspace members.
        self.is_view = is_view  # type: int
        # The ID of the associated category.
        self.life_cycle = life_cycle  # type: int
        # The ID of the DataWorks workspace. You can log on to the DataWorks console to obtain the ID of the DataWorks workspace.
        self.location = location  # type: str
        # The ID of the physical level.
        self.logical_level_id = logical_level_id  # type: long
        self.owner_id = owner_id  # type: str
        # The type of the external table. Valid values: 0, 1, 2, and 3. The value 0 indicates that the external table is an OSS external table. The value 1 indicates that the external table is a Tablestore external table. The value 2 indicates that the external table is a volume external table. The value 3 indicates that the external table is a MySQL external table. This parameter is deprecated. Do not use this parameter.
        self.physics_level_id = physics_level_id  # type: long
        # The name of the MaxCompute table.
        self.project_id = project_id  # type: long
        # The display name of the field.
        self.schema = schema  # type: str
        # The endpoint of MaxCompute. If this parameter is left empty, the endpoint of the MaxCompute project is used.
        self.table_name = table_name  # type: str
        self.themes = themes  # type: list[UpdateTableRequestThemes]
        # The lifecycle of the table. Unit: days. If this parameter is left empty, the table is permanently stored.
        self.visibility = visibility  # type: int

    def validate(self):
        if self.columns:
            for k in self.columns:
                if k:
                    k.validate()
        if self.themes:
            for k in self.themes:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(UpdateTableRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.app_guid is not None:
            result['AppGuid'] = self.app_guid
        if self.category_id is not None:
            result['CategoryId'] = self.category_id
        result['Columns'] = []
        if self.columns is not None:
            for k in self.columns:
                result['Columns'].append(k.to_map() if k else None)
        if self.comment is not None:
            result['Comment'] = self.comment
        if self.create_if_not_exists is not None:
            result['CreateIfNotExists'] = self.create_if_not_exists
        if self.endpoint is not None:
            result['Endpoint'] = self.endpoint
        if self.env_type is not None:
            result['EnvType'] = self.env_type
        if self.external_table_type is not None:
            result['ExternalTableType'] = self.external_table_type
        if self.has_part is not None:
            result['HasPart'] = self.has_part
        if self.is_view is not None:
            result['IsView'] = self.is_view
        if self.life_cycle is not None:
            result['LifeCycle'] = self.life_cycle
        if self.location is not None:
            result['Location'] = self.location
        if self.logical_level_id is not None:
            result['LogicalLevelId'] = self.logical_level_id
        if self.owner_id is not None:
            result['OwnerId'] = self.owner_id
        if self.physics_level_id is not None:
            result['PhysicsLevelId'] = self.physics_level_id
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.schema is not None:
            result['Schema'] = self.schema
        if self.table_name is not None:
            result['TableName'] = self.table_name
        result['Themes'] = []
        if self.themes is not None:
            for k in self.themes:
                result['Themes'].append(k.to_map() if k else None)
        if self.visibility is not None:
            result['Visibility'] = self.visibility
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AppGuid') is not None:
            self.app_guid = m.get('AppGuid')
        if m.get('CategoryId') is not None:
            self.category_id = m.get('CategoryId')
        self.columns = []
        if m.get('Columns') is not None:
            for k in m.get('Columns'):
                temp_model = UpdateTableRequestColumns()
                self.columns.append(temp_model.from_map(k))
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        if m.get('CreateIfNotExists') is not None:
            self.create_if_not_exists = m.get('CreateIfNotExists')
        if m.get('Endpoint') is not None:
            self.endpoint = m.get('Endpoint')
        if m.get('EnvType') is not None:
            self.env_type = m.get('EnvType')
        if m.get('ExternalTableType') is not None:
            self.external_table_type = m.get('ExternalTableType')
        if m.get('HasPart') is not None:
            self.has_part = m.get('HasPart')
        if m.get('IsView') is not None:
            self.is_view = m.get('IsView')
        if m.get('LifeCycle') is not None:
            self.life_cycle = m.get('LifeCycle')
        if m.get('Location') is not None:
            self.location = m.get('Location')
        if m.get('LogicalLevelId') is not None:
            self.logical_level_id = m.get('LogicalLevelId')
        if m.get('OwnerId') is not None:
            self.owner_id = m.get('OwnerId')
        if m.get('PhysicsLevelId') is not None:
            self.physics_level_id = m.get('PhysicsLevelId')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('Schema') is not None:
            self.schema = m.get('Schema')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        self.themes = []
        if m.get('Themes') is not None:
            for k in m.get('Themes'):
                temp_model = UpdateTableRequestThemes()
                self.themes.append(temp_model.from_map(k))
        if m.get('Visibility') is not None:
            self.visibility = m.get('Visibility')
        return self


class UpdateTableResponseBodyTaskInfo(TeaModel):
    def __init__(self, content=None, next_task_id=None, status=None, task_id=None):
        self.content = content  # type: str
        # The ID of the current subtask.
        self.next_task_id = next_task_id  # type: str
        # The ID of the subtask that you want to run. If this parameter is left empty, all subtasks are complete. You can call the [GetDDLJobStatus](~~185659~~) operation to query the status of the subtask based on the subtask ID.
        self.status = status  # type: str
        # Details about the status of the current subtask.
        # 
        # *   If the current subtask succeeds, success is returned.
        # *   If the current subtask fails, the error details are displayed.
        self.task_id = task_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateTableResponseBodyTaskInfo, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.next_task_id is not None:
            result['NextTaskId'] = self.next_task_id
        if self.status is not None:
            result['Status'] = self.status
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('NextTaskId') is not None:
            self.next_task_id = m.get('NextTaskId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        return self


class UpdateTableResponseBody(TeaModel):
    def __init__(self, request_id=None, task_info=None):
        # The information about the request task.
        # 
        # After a request task is submitted, it is divided into multiple subtasks that are run in sequence. After the current subtask is complete, the next subtask starts to run. After all subtasks are complete, the request task is complete. If a request task is aborted due to one of the following issues, address the issue based on the error code and initiate the request task again:
        # 
        # *   The request task fails to be submitted.
        # *   After the request task is submitted, a subtask fails to run.
        self.request_id = request_id  # type: str
        # The status of the current subtask. Valid values:
        # 
        # *   operating: The subtask is running.
        # *   success: The subtask succeeds.
        # *   failure: The subtask fails to run. For more information about the error details, see the Content parameter.
        self.task_info = task_info  # type: UpdateTableResponseBodyTaskInfo

    def validate(self):
        if self.task_info:
            self.task_info.validate()

    def to_map(self):
        _map = super(UpdateTableResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.task_info is not None:
            result['TaskInfo'] = self.task_info.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TaskInfo') is not None:
            temp_model = UpdateTableResponseBodyTaskInfo()
            self.task_info = temp_model.from_map(m['TaskInfo'])
        return self


class UpdateTableResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateTableResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateTableResponse, self).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=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 = UpdateTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateTableAddColumnRequestColumn(TeaModel):
    def __init__(self, column_name=None, column_name_cn=None, column_type=None, comment=None):
        # The name of the field.
        self.column_name = column_name  # type: str
        # The display name of the field.
        self.column_name_cn = column_name_cn  # type: str
        # The type of the field. For more information, see MaxCompute field types.
        self.column_type = column_type  # type: str
        # The comment of the field.
        self.comment = comment  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateTableAddColumnRequestColumn, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.column_name is not None:
            result['ColumnName'] = self.column_name
        if self.column_name_cn is not None:
            result['ColumnNameCn'] = self.column_name_cn
        if self.column_type is not None:
            result['ColumnType'] = self.column_type
        if self.comment is not None:
            result['Comment'] = self.comment
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ColumnName') is not None:
            self.column_name = m.get('ColumnName')
        if m.get('ColumnNameCn') is not None:
            self.column_name_cn = m.get('ColumnNameCn')
        if m.get('ColumnType') is not None:
            self.column_type = m.get('ColumnType')
        if m.get('Comment') is not None:
            self.comment = m.get('Comment')
        return self


class UpdateTableAddColumnRequest(TeaModel):
    def __init__(self, column=None, table_guid=None):
        self.column = column  # type: list[UpdateTableAddColumnRequestColumn]
        # The globally unique identifier (GUID) of the MaxCompute table. Specify the GUID in the odps.projectName.tableName format.
        self.table_guid = table_guid  # type: str

    def validate(self):
        if self.column:
            for k in self.column:
                if k:
                    k.validate()

    def to_map(self):
        _map = super(UpdateTableAddColumnRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        result['Column'] = []
        if self.column is not None:
            for k in self.column:
                result['Column'].append(k.to_map() if k else None)
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.column = []
        if m.get('Column') is not None:
            for k in m.get('Column'):
                temp_model = UpdateTableAddColumnRequestColumn()
                self.column.append(temp_model.from_map(k))
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        return self


class UpdateTableAddColumnResponseBodyTaskInfo(TeaModel):
    def __init__(self, content=None, next_task_id=None, status=None, task_id=None):
        # Details about the status of the current subtask. Valid values:
        # 
        # *   If the current subtask succeeds, success is returned.
        # *   If the current subtask fails, the error details are displayed.
        self.content = content  # type: str
        # The ID of the subtask that you want to run. If this parameter is left empty, all subtasks are complete. You can call the [GetDDLJobStatus](~~185659~~) operation to query the status of the subtask based on the subtask ID.
        self.next_task_id = next_task_id  # type: str
        # The status of the current subtask. Valid values:
        # 
        # *   operating: The subtask is running.
        # *   success: The subtask succeeds.
        # *   failure: The subtask fails to run. For more information about the error details, see the Content parameter.
        self.status = status  # type: str
        # The ID of the current subtask.
        self.task_id = task_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateTableAddColumnResponseBodyTaskInfo, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        if self.next_task_id is not None:
            result['NextTaskId'] = self.next_task_id
        if self.status is not None:
            result['Status'] = self.status
        if self.task_id is not None:
            result['TaskId'] = self.task_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Content') is not None:
            self.content = m.get('Content')
        if m.get('NextTaskId') is not None:
            self.next_task_id = m.get('NextTaskId')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        return self


class UpdateTableAddColumnResponseBody(TeaModel):
    def __init__(self, request_id=None, task_info=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # The information about the request task.
        # 
        # After a request task is submitted, it is divided into multiple subtasks that are run in sequence. After the current subtask is complete, the next subtask starts to run. After all subtasks are complete, the request task is complete. If a request task is aborted due to one of the following issues, address the issue based on the error code and initiate the request task again:
        # 
        # *   The request task fails to be submitted.
        # *   After the request task is submitted, a subtask fails to run.
        self.task_info = task_info  # type: UpdateTableAddColumnResponseBodyTaskInfo

    def validate(self):
        if self.task_info:
            self.task_info.validate()

    def to_map(self):
        _map = super(UpdateTableAddColumnResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.task_info is not None:
            result['TaskInfo'] = self.task_info.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TaskInfo') is not None:
            temp_model = UpdateTableAddColumnResponseBodyTaskInfo()
            self.task_info = temp_model.from_map(m['TaskInfo'])
        return self


class UpdateTableAddColumnResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateTableAddColumnResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateTableAddColumnResponse, self).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=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 = UpdateTableAddColumnResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateTableLevelRequest(TeaModel):
    def __init__(self, description=None, level_id=None, level_type=None, name=None, project_id=None):
        # The description of the table level.
        self.description = description  # type: str
        # The ID of the table level to be updated. You can call the ListTableLevel operation to obtain the ID.
        self.level_id = level_id  # type: long
        # The type of the table level. Valid values: 1 and 2. A value of 1 indicates the logical level. A value of 2 indicates the physical level.
        self.level_type = level_type  # type: int
        # The name of the table level.
        self.name = name  # type: str
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateTableLevelRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        if self.level_id is not None:
            result['LevelId'] = self.level_id
        if self.level_type is not None:
            result['LevelType'] = self.level_type
        if self.name is not None:
            result['Name'] = self.name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Description') is not None:
            self.description = m.get('Description')
        if m.get('LevelId') is not None:
            self.level_id = m.get('LevelId')
        if m.get('LevelType') is not None:
            self.level_type = m.get('LevelType')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        return self


class UpdateTableLevelResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, success=None,
                 update_result=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool
        # Indicates whether the update result is returned.
        self.update_result = update_result  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateTableLevelResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        if self.update_result is not None:
            result['UpdateResult'] = self.update_result
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        if m.get('UpdateResult') is not None:
            self.update_result = m.get('UpdateResult')
        return self


class UpdateTableLevelResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateTableLevelResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateTableLevelResponse, self).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=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 = UpdateTableLevelResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateTableModelInfoRequest(TeaModel):
    def __init__(self, first_level_theme_id=None, level_id=None, level_type=None, second_level_theme_id=None,
                 table_guid=None):
        # The ID of the first-level table folder.
        self.first_level_theme_id = first_level_theme_id  # type: long
        # The ID of the table level.
        self.level_id = level_id  # type: long
        # The type of the table level. Valid values: 1 and 2. A value of 1 indicates the logical level. A value of 2 indicates the physical level.
        self.level_type = level_type  # type: int
        # The ID of the second-level table folder.
        self.second_level_theme_id = second_level_theme_id  # type: long
        # The globally unique identifier (GUID) of the table. Specify the GUID in the format of odps.{projectName}.{tableName}.
        self.table_guid = table_guid  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateTableModelInfoRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.first_level_theme_id is not None:
            result['FirstLevelThemeId'] = self.first_level_theme_id
        if self.level_id is not None:
            result['LevelId'] = self.level_id
        if self.level_type is not None:
            result['LevelType'] = self.level_type
        if self.second_level_theme_id is not None:
            result['SecondLevelThemeId'] = self.second_level_theme_id
        if self.table_guid is not None:
            result['TableGuid'] = self.table_guid
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FirstLevelThemeId') is not None:
            self.first_level_theme_id = m.get('FirstLevelThemeId')
        if m.get('LevelId') is not None:
            self.level_id = m.get('LevelId')
        if m.get('LevelType') is not None:
            self.level_type = m.get('LevelType')
        if m.get('SecondLevelThemeId') is not None:
            self.second_level_theme_id = m.get('SecondLevelThemeId')
        if m.get('TableGuid') is not None:
            self.table_guid = m.get('TableGuid')
        return self


class UpdateTableModelInfoResponseBody(TeaModel):
    def __init__(self, request_id=None, update_result=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.update_result = update_result  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateTableModelInfoResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.update_result is not None:
            result['UpdateResult'] = self.update_result
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('UpdateResult') is not None:
            self.update_result = m.get('UpdateResult')
        return self


class UpdateTableModelInfoResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateTableModelInfoResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateTableModelInfoResponse, self).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=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 = UpdateTableModelInfoResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateTableThemeRequest(TeaModel):
    def __init__(self, name=None, project_id=None, theme_id=None):
        # The name of the table folder.
        self.name = name  # type: str
        # The ID of the DataWorks workspace.
        self.project_id = project_id  # type: long
        # The ID of the table folder.
        self.theme_id = theme_id  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateTableThemeRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.name is not None:
            result['Name'] = self.name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.theme_id is not None:
            result['ThemeId'] = self.theme_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ThemeId') is not None:
            self.theme_id = m.get('ThemeId')
        return self


class UpdateTableThemeResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, success=None,
                 update_result=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful. Valid values:
        # 
        # *   true: The request is successful.
        # *   false: The request fails.
        self.success = success  # type: bool
        # Indicates whether the update result is returned. Valid values:
        # 
        # *   true: The update result is returned.
        # *   false: The update result is not returned.
        self.update_result = update_result  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateTableThemeResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        if self.update_result is not None:
            result['UpdateResult'] = self.update_result
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        if m.get('UpdateResult') is not None:
            self.update_result = m.get('UpdateResult')
        return self


class UpdateTableThemeResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateTableThemeResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateTableThemeResponse, self).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=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 = UpdateTableThemeResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateUdfFileRequest(TeaModel):
    def __init__(self, class_name=None, cmd_description=None, example=None, file_folder_path=None, file_id=None,
                 function_type=None, parameter_description=None, project_id=None, project_identifier=None, resources=None,
                 return_value=None, udf_description=None):
        # The name of the class in which the function is defined. This parameter corresponds to the Class Name parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.class_name = class_name  # type: str
        # The syntax used for calling the function. This parameter corresponds to the Expression Syntax parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.cmd_description = cmd_description  # type: str
        # The example for calling the function. This parameter corresponds to the Example parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.example = example  # type: str
        # The path of the folder in which the function file is stored.
        self.file_folder_path = file_folder_path  # type: str
        # The ID of the file.
        self.file_id = file_id  # type: str
        # The type of the function. Valid values: MATH, AGGREGATE, STRING, DATE, ANALYTIC, and OTHER. This parameter corresponds to the Function Type parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.function_type = function_type  # type: str
        # The description of the input parameters of the function. This parameter corresponds to the Parameter Description parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.parameter_description = parameter_description  # type: str
        # The ID of the DataWorks workspace. You can click the Workspace Manage icon in the upper-right corner of the DataStudio page to go to the Workspace Management page and view the workspace ID.
        self.project_id = project_id  # type: long
        # The unique identifier of the DataWorks workspace. You can click the identifier in the upper-left corner of the DataStudio page to switch to another workspace.
        # 
        # You must specify either this parameter or ProjectId to determine the DataWorks workspace to which the operation is applied.
        self.project_identifier = project_identifier  # type: str
        # The names of the resources that are referenced by the function. This parameter corresponds to the Resources parameter in the Register Function section of the configuration tab of the function in the DataWorks console. Separate multiple resource names with commas (,).
        self.resources = resources  # type: str
        # The description of the return value of the function. This parameter corresponds to the Return Value parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.return_value = return_value  # type: str
        # The description of the function. This parameter corresponds to the Description parameter in the Register Function section of the configuration tab of the function in the DataWorks console.
        self.udf_description = udf_description  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateUdfFileRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.class_name is not None:
            result['ClassName'] = self.class_name
        if self.cmd_description is not None:
            result['CmdDescription'] = self.cmd_description
        if self.example is not None:
            result['Example'] = self.example
        if self.file_folder_path is not None:
            result['FileFolderPath'] = self.file_folder_path
        if self.file_id is not None:
            result['FileId'] = self.file_id
        if self.function_type is not None:
            result['FunctionType'] = self.function_type
        if self.parameter_description is not None:
            result['ParameterDescription'] = self.parameter_description
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_identifier is not None:
            result['ProjectIdentifier'] = self.project_identifier
        if self.resources is not None:
            result['Resources'] = self.resources
        if self.return_value is not None:
            result['ReturnValue'] = self.return_value
        if self.udf_description is not None:
            result['UdfDescription'] = self.udf_description
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ClassName') is not None:
            self.class_name = m.get('ClassName')
        if m.get('CmdDescription') is not None:
            self.cmd_description = m.get('CmdDescription')
        if m.get('Example') is not None:
            self.example = m.get('Example')
        if m.get('FileFolderPath') is not None:
            self.file_folder_path = m.get('FileFolderPath')
        if m.get('FileId') is not None:
            self.file_id = m.get('FileId')
        if m.get('FunctionType') is not None:
            self.function_type = m.get('FunctionType')
        if m.get('ParameterDescription') is not None:
            self.parameter_description = m.get('ParameterDescription')
        if m.get('ProjectId') is not None:
            self.project_id = m.get('ProjectId')
        if m.get('ProjectIdentifier') is not None:
            self.project_identifier = m.get('ProjectIdentifier')
        if m.get('Resources') is not None:
            self.resources = m.get('Resources')
        if m.get('ReturnValue') is not None:
            self.return_value = m.get('ReturnValue')
        if m.get('UdfDescription') is not None:
            self.udf_description = m.get('UdfDescription')
        return self


class UpdateUdfFileResponseBody(TeaModel):
    def __init__(self, error_code=None, error_message=None, http_status_code=None, request_id=None, success=None):
        # The error code returned.
        self.error_code = error_code  # type: str
        # The error message returned.
        self.error_message = error_message  # type: str
        # The HTTP status code returned.
        self.http_status_code = http_status_code  # type: int
        # The ID of the request. You can troubleshoot issues based on the ID.
        self.request_id = request_id  # type: str
        # Indicates whether the request is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateUdfFileResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['ErrorCode'] = self.error_code
        if self.error_message is not None:
            result['ErrorMessage'] = self.error_message
        if self.http_status_code is not None:
            result['HttpStatusCode'] = self.http_status_code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ErrorCode') is not None:
            self.error_code = m.get('ErrorCode')
        if m.get('ErrorMessage') is not None:
            self.error_message = m.get('ErrorMessage')
        if m.get('HttpStatusCode') is not None:
            self.http_status_code = m.get('HttpStatusCode')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateUdfFileResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateUdfFileResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateUdfFileResponse, self).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=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 = UpdateUdfFileResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateWorkbenchEventResultRequest(TeaModel):
    def __init__(self, check_result=None, check_result_tip=None, extension_code=None, message_id=None):
        # The check status of the extension point event. Valid values: OK and Fail. A value of OK indicates that the event passes the check. A value of FAIL indicates that the event fails to pass the check.
        self.check_result = check_result  # type: str
        # The cause of the check failure.
        self.check_result_tip = check_result_tip  # type: str
        # The code of the extension.
        self.extension_code = extension_code  # type: str
        # The ID of the message received when the related extension point event is triggered after you enable message subscription by using the OpenEvent module.
        self.message_id = message_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateWorkbenchEventResultRequest, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.check_result is not None:
            result['CheckResult'] = self.check_result
        if self.check_result_tip is not None:
            result['CheckResultTip'] = self.check_result_tip
        if self.extension_code is not None:
            result['ExtensionCode'] = self.extension_code
        if self.message_id is not None:
            result['MessageId'] = self.message_id
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('CheckResult') is not None:
            self.check_result = m.get('CheckResult')
        if m.get('CheckResultTip') is not None:
            self.check_result_tip = m.get('CheckResultTip')
        if m.get('ExtensionCode') is not None:
            self.extension_code = m.get('ExtensionCode')
        if m.get('MessageId') is not None:
            self.message_id = m.get('MessageId')
        return self


class UpdateWorkbenchEventResultResponseBody(TeaModel):
    def __init__(self, request_id=None, success=None):
        # The ID of the request.
        self.request_id = request_id  # type: str
        # Indicates whether the call is successful.
        self.success = success  # type: bool

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateWorkbenchEventResultResponseBody, self).to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.success is not None:
            result['Success'] = self.success
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Success') is not None:
            self.success = m.get('Success')
        return self


class UpdateWorkbenchEventResultResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateWorkbenchEventResultResponseBody

    def validate(self):
        self.validate_required(self.headers, 'headers')
        self.validate_required(self.status_code, 'status_code')
        self.validate_required(self.body, 'body')
        if self.body:
            self.body.validate()

    def to_map(self):
        _map = super(UpdateWorkbenchEventResultResponse, self).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=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 = UpdateWorkbenchEventResultResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


