# -*- 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 AbolishDataServiceApiRequest(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(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):
        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(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):
        self.collection_qualified_name = collection_qualified_name  # type: str
        self.entity_qualified_name = entity_qualified_name  # 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
        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 AddMetaCollectionEntityResponseBody(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(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):
        self.client_token = client_token  # type: str
        self.project_id = project_id  # type: long
        self.role_code = role_code  # type: str
        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):
        self.category_id = category_id  # type: long
        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):
        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(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):
        self.approve_action = approve_action  # type: int
        self.approve_comment = approve_comment  # type: str
        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):
        self.approve_success = approve_success  # type: bool
        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 ChangeResourceManagerResourceGroupRequest(TeaModel):
    def __init__(self, resource_id=None, resource_manager_resource_group_id=None, resource_type=None):
        self.resource_id = resource_id  # type: str
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        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):
        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(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):
        self.check_detail_url = check_detail_url  # type: str
        self.checker_instance_id = checker_instance_id  # type: str
        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):
        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):
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.database_name = database_name  # type: str
        self.partition = partition  # 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(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):
        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(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):
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.database_name = database_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(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, overtime_settings=None,
                 owner=None, priority=None, project_id=None, task_ids=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.overtime_settings = overtime_settings  # type: list[CreateBaselineRequestOvertimeSettings]
        self.owner = owner  # type: str
        self.priority = priority  # type: int
        self.project_id = project_id  # type: long
        self.task_ids = task_ids  # type: str

    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
        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.task_ids is not None:
            result['TaskIds'] = self.task_ids
        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')
        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')
        if m.get('TaskIds') is not None:
            self.task_ids = m.get('TaskIds')
        return self


class CreateBaselineResponseBody(TeaModel):
    def __init__(self, data=None, dynamic_error_code=None, dynamic_error_message=None, error_code=None,
                 error_message=None, http_status_code=None, request_id=None, success=None):
        self.data = data  # type: long
        self.dynamic_error_code = dynamic_error_code  # type: str
        self.dynamic_error_message = dynamic_error_message  # type: str
        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.dynamic_error_code is not None:
            result['DynamicErrorCode'] = self.dynamic_error_code
        if self.dynamic_error_message is not None:
            result['DynamicErrorMessage'] = self.dynamic_error_message
        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('DynamicErrorCode') is not None:
            self.dynamic_error_code = m.get('DynamicErrorCode')
        if m.get('DynamicErrorMessage') is not None:
            self.dynamic_error_message = m.get('DynamicErrorMessage')
        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):
        self.connection_type = connection_type  # type: str
        self.content = content  # type: str
        self.description = description  # type: str
        self.env_type = env_type  # type: int
        self.name = name  # type: str
        self.project_id = project_id  # type: long
        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):
        self.data = data  # type: long
        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(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 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_method=None,
                 response_content_type=None, script_details=None, tenant_id=None, timeout=None, visible_range=None, wizard_details=None):
        self.api_description = api_description  # type: str
        self.api_mode = api_mode  # type: int
        self.api_name = api_name  # type: str
        self.api_path = api_path  # type: str
        self.folder_id = folder_id  # type: long
        self.group_id = group_id  # type: str
        self.project_id = project_id  # type: long
        self.protocols = protocols  # type: str
        self.registration_details = registration_details  # type: str
        self.request_method = request_method  # type: int
        self.response_content_type = response_content_type  # type: int
        self.script_details = script_details  # type: str
        self.tenant_id = tenant_id  # type: long
        self.timeout = timeout  # type: int
        self.visible_range = visible_range  # type: int
        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_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
        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('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:
            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 CreateDataServiceApiResponseBody(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(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):
        self.api_id = api_id  # type: long
        self.authorized_project_id = authorized_project_id  # type: long
        self.end_time = end_time  # 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(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):
        self.request_id = request_id  # type: str
        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):
        self.folder_name = folder_name  # type: str
        self.group_id = group_id  # type: str
        self.parent_id = parent_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(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):
        self.folder_id = folder_id  # type: long
        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):
        self.api_gateway_group_id = api_gateway_group_id  # type: str
        self.description = description  # type: str
        self.group_name = group_name  # type: str
        self.project_id = project_id  # type: long
        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):
        self.group_id = group_id  # type: str
        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):
        self.content = content  # type: str
        self.data_source_type = data_source_type  # type: str
        self.description = description  # type: str
        self.env_type = env_type  # type: int
        self.name = name  # type: str
        self.project_id = project_id  # type: long
        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):
        self.data = data  # type: long
        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):
        self.description = description  # type: str
        self.export_mode = export_mode  # type: str
        self.export_object_status = export_object_status  # type: str
        self.incremental_since = incremental_since  # type: long
        self.name = name  # type: str
        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):
        self.data = data  # type: long
        self.request_id = request_id  # type: str
        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, 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, 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):
        self.advanced_settings = advanced_settings  # type: str
        self.auto_parsing = auto_parsing  # type: bool
        self.auto_rerun_interval_millis = auto_rerun_interval_millis  # type: int
        self.auto_rerun_times = auto_rerun_times  # type: int
        self.connection_name = connection_name  # type: str
        self.content = content  # type: str
        self.cron_express = cron_express  # type: str
        self.cycle_type = cycle_type  # type: str
        self.dependent_node_id_list = dependent_node_id_list  # type: str
        self.dependent_type = dependent_type  # type: str
        self.end_effect_date = end_effect_date  # type: long
        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.input_list = input_list  # type: str
        self.input_parameters = input_parameters  # type: str
        self.output_parameters = output_parameters  # type: str
        self.owner = owner  # type: str
        self.para_value = para_value  # type: str
        self.project_id = project_id  # type: long
        self.project_identifier = project_identifier  # type: str
        self.rerun_mode = rerun_mode  # type: str
        self.resource_group_id = resource_group_id  # type: long
        self.resource_group_identifier = resource_group_identifier  # type: str
        self.scheduler_type = scheduler_type  # type: str
        self.start_effect_date = start_effect_date  # type: long
        self.start_immediately = start_immediately  # type: bool
        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.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.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('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('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):
        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(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):
        self.folder_path = folder_path  # type: str
        self.project_id = project_id  # type: long
        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):
        self.data = data  # type: str
        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(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):
        self.calculate_engine_map = calculate_engine_map  # type: str
        self.commit_rule = commit_rule  # type: str
        self.description = description  # type: str
        self.name = name  # type: str
        self.package_file = package_file  # type: str
        self.package_type = package_type  # type: str
        self.project_id = project_id  # type: long
        self.resource_group_map = resource_group_map  # type: str
        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):
        self.calculate_engine_map = calculate_engine_map  # type: str
        self.commit_rule = commit_rule  # type: str
        self.description = description  # type: str
        self.name = name  # type: str
        self.package_file_object = package_file_object  # type: READABLE
        self.package_type = package_type  # type: str
        self.project_id = project_id  # type: long
        self.resource_group_map = resource_group_map  # type: str
        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):
        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(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):
        self.comment = comment  # type: str
        self.name = name  # type: str
        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):
        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):
        self.data = data  # type: CreateMetaCategoryResponseBodyData
        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(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):
        self.collection_type = collection_type  # type: str
        self.comment = comment  # type: str
        self.name = name  # type: str
        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):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: str
        self.qualified_name = qualified_name  # type: str
        # Id of the request
        self.request_id = request_id  # type: str
        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):
        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):
        self.actions = actions  # type: str
        self.column_meta_list = column_meta_list  # type: list[CreatePermissionApplyOrderRequestApplyObjectColumnMetaList]
        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]
        self.apply_reason = apply_reason  # type: str
        self.apply_user_ids = apply_user_ids  # type: str
        self.deadline = deadline  # type: long
        self.engine_type = engine_type  # type: str
        self.max_compute_project_name = max_compute_project_name  # type: str
        self.order_type = order_type  # type: int
        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):
        self.flow_id = flow_id  # type: list[str]
        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):
        self.client_token = client_token  # type: str
        self.project_id = project_id  # type: long
        self.role_code = role_code  # type: str
        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_name=None, table_name=None):
        self.entity_level = entity_level  # type: int
        self.env_type = env_type  # type: str
        self.match_expression = match_expression  # type: str
        self.project_name = project_name  # type: str
        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_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('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):
        self.data = data  # type: int
        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(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_name=None):
        self.alarm_mode = alarm_mode  # type: int
        self.entity_id = entity_id  # type: long
        self.follower = follower  # type: str
        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_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('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):
        self.data = data  # type: int
        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(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):
        self.env_type = env_type  # type: str
        self.match_expression = match_expression  # type: str
        self.node_id = node_id  # type: long
        self.project_id = project_id  # type: long
        self.project_name = project_name  # type: str
        self.table_name = table_name  # type: str
        self.target_node_project_id = target_node_project_id  # type: long
        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):
        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(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_name=None, property=None,
                 property_type=None, rule_name=None, rule_type=None, template_id=None, trend=None, warning_threshold=None,
                 where_condition=None):
        self.block_type = block_type  # type: int
        self.checker = checker  # type: int
        self.comment = comment  # type: str
        self.critical_threshold = critical_threshold  # type: str
        self.entity_id = entity_id  # type: long
        self.expect_value = expect_value  # type: str
        self.method_name = method_name  # type: str
        self.operator = operator  # type: str
        self.predict_type = predict_type  # type: int
        self.project_name = project_name  # type: str
        self.property = property  # type: str
        self.property_type = property_type  # type: str
        self.rule_name = rule_name  # type: str
        self.rule_type = rule_type  # type: int
        self.template_id = template_id  # type: int
        self.trend = trend  # type: str
        self.warning_threshold = warning_threshold  # type: str
        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_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('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):
        self.data = data  # type: str
        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(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):
        self.alert_interval = alert_interval  # type: int
        self.alert_methods = alert_methods  # type: str
        self.alert_targets = alert_targets  # type: str
        self.alert_unit = alert_unit  # type: str
        self.baseline_ids = baseline_ids  # type: str
        self.biz_process_ids = biz_process_ids  # type: str
        self.detail = detail  # type: str
        self.dnd_end = dnd_end  # type: str
        self.max_alert_times = max_alert_times  # type: int
        self.node_ids = node_ids  # type: str
        self.project_id = project_id  # type: long
        self.remind_name = remind_name  # type: str
        self.remind_type = remind_type  # type: str
        self.remind_unit = remind_unit  # type: str
        self.robot_urls = robot_urls  # type: str
        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):
        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(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 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):
        self.column_name = column_name  # type: str
        self.column_name_cn = column_name_cn  # type: str
        self.column_type = column_type  # type: str
        self.comment = comment  # type: str
        self.is_partition_col = is_partition_col  # type: bool
        self.length = length  # type: int
        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):
        self.theme_id = theme_id  # type: long
        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):
        self.app_guid = app_guid  # type: str
        self.category_id = category_id  # type: long
        self.client_token = client_token  # type: str
        self.columns = columns  # type: list[CreateTableRequestColumns]
        self.comment = comment  # type: str
        self.endpoint = endpoint  # type: str
        self.env_type = env_type  # type: int
        self.external_table_type = external_table_type  # type: str
        self.has_part = has_part  # type: int
        self.is_view = is_view  # type: int
        self.life_cycle = life_cycle  # type: int
        self.location = location  # type: str
        self.logical_level_id = logical_level_id  # type: long
        self.owner_id = owner_id  # type: str
        self.physics_level_id = physics_level_id  # type: long
        self.project_id = project_id  # type: long
        self.schema = schema  # type: str
        self.table_name = table_name  # type: str
        self.themes = themes  # type: list[CreateTableRequestThemes]
        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
        self.next_task_id = next_task_id  # type: str
        self.status = status  # type: str
        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):
        self.request_id = request_id  # type: str
        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):
        self.description = description  # type: str
        self.level_type = level_type  # type: int
        self.name = name  # type: str
        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):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        self.level_id = level_id  # type: long
        self.request_id = request_id  # type: str
        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):
        self.level = level  # type: int
        self.name = name  # type: str
        self.parent_id = parent_id  # type: long
        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):
        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
        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, 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):
        self.class_name = class_name  # type: str
        self.cmd_description = cmd_description  # type: str
        self.example = example  # type: str
        self.file_folder_path = file_folder_path  # type: str
        self.file_name = file_name  # type: str
        self.function_type = function_type  # type: str
        self.parameter_description = parameter_description  # type: str
        self.project_id = project_id  # type: long
        self.project_identifier = project_identifier  # type: str
        self.resources = resources  # type: str
        self.return_value = return_value  # type: str
        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.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('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):
        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(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, dynamic_error_code=None, dynamic_error_message=None, error_code=None,
                 error_message=None, http_status_code=None, request_id=None, success=None):
        self.data = data  # type: bool
        self.dynamic_error_code = dynamic_error_code  # type: str
        self.dynamic_error_message = dynamic_error_message  # type: str
        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.dynamic_error_code is not None:
            result['DynamicErrorCode'] = self.dynamic_error_code
        if self.dynamic_error_message is not None:
            result['DynamicErrorMessage'] = self.dynamic_error_message
        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('DynamicErrorCode') is not None:
            self.dynamic_error_code = m.get('DynamicErrorCode')
        if m.get('DynamicErrorMessage') is not None:
            self.dynamic_error_message = m.get('DynamicErrorMessage')
        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):
        self.business_id = business_id  # type: long
        self.project_id = project_id  # type: long
        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):
        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(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 DeleteDISyncTaskRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, task_type=None):
        self.file_id = file_id  # type: long
        self.project_id = project_id  # type: long
        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
        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):
        self.data = data  # type: DeleteDISyncTaskResponseBodyData
        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(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):
        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(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):
        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(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):
        self.api_id = api_id  # type: long
        self.authorized_project_id = authorized_project_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(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):
        self.request_id = request_id  # type: str
        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):
        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):
        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(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):
        self.file_id = file_id  # type: long
        self.project_id = project_id  # type: long
        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):
        self.deployment_id = deployment_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(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):
        self.folder_id = folder_id  # type: str
        self.project_id = project_id  # type: long
        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):
        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(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):
        self.category_id = category_id  # type: long
        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):
        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(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 DeleteMetaCategoryRequest(TeaModel):
    def __init__(self, category_id=None):
        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):
        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(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):
        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):
        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(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):
        self.collection_qualified_name = collection_qualified_name  # type: str
        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):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        # Id of the request
        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(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):
        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_name=None):
        self.entity_id = entity_id  # type: long
        self.env_type = env_type  # type: str
        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_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('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):
        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(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_name=None):
        self.follower_id = follower_id  # type: long
        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_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('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):
        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(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):
        self.env_type = env_type  # type: str
        self.match_expression = match_expression  # type: str
        self.node_id = node_id  # type: long
        self.project_id = project_id  # type: long
        self.project_name = project_name  # type: str
        self.table_name = table_name  # type: str
        self.target_node_project_id = target_node_project_id  # type: long
        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):
        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(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_name=None, rule_id=None):
        self.project_name = project_name  # type: str
        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_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('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):
        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(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):
        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):
        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(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):
        self.app_guid = app_guid  # type: str
        self.env_type = env_type  # type: int
        self.project_id = project_id  # type: long
        self.schema = schema  # type: str
        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):
        self.content = content  # type: str
        self.next_task_id = next_task_id  # type: str
        self.status = status  # type: str
        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):
        self.request_id = request_id  # type: str
        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):
        self.level_id = level_id  # type: long
        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):
        self.delete_result = delete_result  # type: bool
        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):
        self.project_id = project_id  # type: long
        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):
        self.delete_result = delete_result  # 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(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):
        self.file_id = file_id  # type: long
        self.project_id = project_id  # type: long
        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
        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):
        self.data = data  # type: DeployDISyncTaskResponseBodyData
        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(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):
        self.comment = comment  # type: str
        self.file_id = file_id  # type: long
        self.node_id = node_id  # type: long
        self.project_id = project_id  # type: long
        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):
        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(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):
        self.data = data  # type: str
        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):
        self.desensitize_data = desensitize_data  # type: str
        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):
        self.business_id = business_id  # type: str
        self.folder_id = folder_id  # type: str
        self.project_id = project_id  # type: long
        self.project_identifier = project_identifier  # type: str
        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):
        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(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):
        self.data_source_type = data_source_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.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):
        self.binding_calc_engine_id = binding_calc_engine_id  # type: int
        self.connect_status = connect_status  # type: int
        self.content = content  # type: str
        self.data_source_type = data_source_type  # 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(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):
        self.data_sources = data_sources  # type: list[ExportDataSourcesResponseBodyDataDataSources]
        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.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):
        self.data = data  # type: ExportDataSourcesResponseBodyData
        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(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):
        self.client_token = client_token  # type: str
        self.project_id = project_id  # type: long
        self.task_param = task_param  # type: str
        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
        self.process_id = process_id  # type: long
        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):
        self.data = data  # type: GenerateDISyncTaskConfigForCreatingResponseBodyData
        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(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):
        self.client_token = client_token  # type: str
        self.project_id = project_id  # type: long
        self.task_id = task_id  # type: long
        self.task_param = task_param  # type: str
        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
        self.process_id = process_id  # type: long
        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):
        self.data = data  # type: GenerateDISyncTaskConfigForUpdatingResponseBodyData
        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(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, over_time_settings=None, owner=None, priority=None,
                 project_id=None, task_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[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.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
        self.task_ids = task_ids  # type: list[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
        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
        if self.task_ids is not None:
            result['TaskIds'] = self.task_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 = 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')
        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')
        if m.get('TaskIds') is not None:
            self.task_ids = m.get('TaskIds')
        return self


class GetBaselineResponseBody(TeaModel):
    def __init__(self, data=None, dynamic_error_code=None, dynamic_error_message=None, error_code=None,
                 error_message=None, http_status_code=None, request_id=None, success=None):
        self.data = data  # type: GetBaselineResponseBodyData
        self.dynamic_error_code = dynamic_error_code  # type: str
        self.dynamic_error_message = dynamic_error_message  # type: str
        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.dynamic_error_code is not None:
            result['DynamicErrorCode'] = self.dynamic_error_code
        if self.dynamic_error_message is not None:
            result['DynamicErrorMessage'] = self.dynamic_error_message
        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('DynamicErrorCode') is not None:
            self.dynamic_error_code = m.get('DynamicErrorCode')
        if m.get('DynamicErrorMessage') is not None:
            self.dynamic_error_message = m.get('DynamicErrorMessage')
        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):
        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):
        self.baseline_id = baseline_id  # type: long
        self.baseline_name = baseline_name  # type: str
        self.baseline_type = baseline_type  # type: str
        self.exp_hour = exp_hour  # type: int
        self.exp_minu = exp_minu  # type: int
        self.hour_exp_detail = hour_exp_detail  # type: str
        self.hour_sla_detail = hour_sla_detail  # type: str
        self.is_default = is_default  # type: bool
        self.owner = owner  # type: str
        self.priority = priority  # type: int
        self.project_id = project_id  # type: long
        self.sla_hour = sla_hour  # type: int
        self.sla_minu = sla_minu  # type: int
        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):
        self.data = data  # type: GetBaselineConfigResponseBodyData
        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(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):
        self.baseline_id = baseline_id  # type: long
        self.bizdate = bizdate  # type: str
        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, bizdate=None, cyc_time=None, end_cast=None, finish_time=None, in_group_id=None,
                 instance_id=None, node_id=None, node_name=None, owner=None, project_id=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.bizdate = bizdate  # type: long
        self.cyc_time = cyc_time  # type: long
        self.end_cast = end_cast  # type: long
        self.finish_time = finish_time  # 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.project_id = project_id  # 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.bizdate is not None:
            result['Bizdate'] = self.bizdate
        if self.cyc_time is not None:
            result['CycTime'] = self.cyc_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.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.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('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('Bizdate') is not None:
            self.bizdate = m.get('Bizdate')
        if m.get('CycTime') is not None:
            self.cyc_time = m.get('CycTime')
        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('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('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 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: long

    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
        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):
        self.baseline_id = baseline_id  # type: long
        self.bizdate = bizdate  # type: str
        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):
        self.end_cast = end_cast  # type: long
        self.finish_time = finish_time  # 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.project_id = project_id  # type: long
        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):
        self.end_cast = end_cast  # type: long
        self.finish_time = finish_time  # 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.project_id = project_id  # type: long
        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):
        self.baseline_id = baseline_id  # type: long
        self.baseline_name = baseline_name  # type: str
        self.bizdate = bizdate  # type: long
        self.block_instance = block_instance  # type: GetBaselineStatusResponseBodyDataBlockInstance
        self.buffer = buffer  # type: float
        self.end_cast = end_cast  # type: long
        self.exp_time = exp_time  # type: long
        self.finish_status = finish_status  # type: str
        self.finish_time = finish_time  # type: long
        self.in_group_id = in_group_id  # type: int
        self.last_instance = last_instance  # type: GetBaselineStatusResponseBodyDataLastInstance
        self.owner = owner  # type: str
        self.priority = priority  # type: int
        self.project_id = project_id  # type: long
        self.sla_time = sla_time  # type: long
        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):
        self.data = data  # type: GetBaselineStatusResponseBodyData
        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(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):
        self.business_id = business_id  # type: long
        self.project_id = project_id  # type: long
        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):
        self.business_id = business_id  # type: long
        self.business_name = business_name  # type: str
        self.description = description  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str
        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):
        self.data = data  # type: GetBusinessResponseBodyData
        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(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):
        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):
        self.content = content  # type: str
        self.next_task_id = next_task_id  # type: str
        self.status = status  # type: str
        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):
        self.data = data  # type: GetDDLJobStatusResponseBodyData
        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 GetDISyncInstanceInfoRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, task_type=None):
        self.file_id = file_id  # type: long
        self.project_id = project_id  # type: long
        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
        self.status = status  # type: str
        self.step_id = step_id  # type: long
        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):
        self.creator_name = creator_name  # type: str
        self.id = id  # type: long
        self.status = status  # type: str
        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):
        self.message = message  # type: str
        self.name = name  # type: str
        self.solution_info = solution_info  # type: GetDISyncInstanceInfoResponseBodyDataSolutionInfo
        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):
        self.data = data  # type: GetDISyncInstanceInfoResponseBodyData
        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(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):
        self.file_id = file_id  # type: long
        self.project_id = project_id  # type: long
        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):
        self.creator_name = creator_name  # type: str
        self.id = id  # type: long
        self.name = name  # type: str
        self.process_content = process_content  # type: str
        self.process_extra = process_extra  # type: str
        self.project_id = project_id  # type: long
        self.source_type = source_type  # type: str
        self.start_time = start_time  # type: str
        self.status = status  # type: str
        self.submit_time = submit_time  # type: str
        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):
        self.code = code  # type: str
        self.message = message  # type: str
        self.solution_detail = solution_detail  # type: GetDISyncTaskResponseBodyDataSolutionDetail
        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):
        self.data = data  # type: GetDISyncTaskResponseBodyData
        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(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):
        self.dag_id = dag_id  # type: long
        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):
        self.bizdate = bizdate  # type: long
        self.create_time = create_time  # type: long
        self.create_user = create_user  # type: str
        # DagId。
        self.dag_id = dag_id  # type: long
        self.finish_time = finish_time  # type: long
        # Gmtdate。
        self.gmtdate = gmtdate  # type: long
        self.modify_time = modify_time  # type: long
        self.name = name  # type: str
        self.op_seq = op_seq  # type: long
        self.project_id = project_id  # type: long
        self.start_time = start_time  # type: long
        self.status = status  # type: str
        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):
        self.data = data  # type: GetDagResponseBodyData
        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(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):
        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(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):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        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):
        self.column_name = column_name  # type: str
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.failed_result_sample = failed_result_sample  # type: str
        self.registration_error_codes = registration_error_codes  # type: list[GetDataServiceApiResponseBodyDataRegistrationDetailsRegistrationErrorCodes]
        self.registration_request_parameters = registration_request_parameters  # type: list[GetDataServiceApiResponseBodyDataRegistrationDetailsRegistrationRequestParameters]
        self.service_content_type = service_content_type  # type: int
        self.service_host = service_host  # type: str
        self.service_path = service_path  # type: str
        self.service_request_body_description = service_request_body_description  # type: str
        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):
        self.connection_id = connection_id  # type: long
        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):
        self.column_name = column_name  # type: str
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.column_name = column_name  # type: str
        self.example_value = example_value  # type: str
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        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):
        self.is_paged_response = is_paged_response  # type: bool
        self.script = script  # type: str
        self.script_connection = script_connection  # type: GetDataServiceApiResponseBodyDataScriptDetailsScriptConnection
        self.script_request_parameters = script_request_parameters  # type: list[GetDataServiceApiResponseBodyDataScriptDetailsScriptRequestParameters]
        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):
        self.connection_id = connection_id  # type: long
        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):
        self.column_name = column_name  # type: str
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.column_name = column_name  # type: str
        self.example_value = example_value  # type: str
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        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):
        self.is_paged_response = is_paged_response  # type: bool
        self.wizard_connection = wizard_connection  # type: GetDataServiceApiResponseBodyDataWizardDetailsWizardConnection
        self.wizard_request_parameters = wizard_request_parameters  # type: list[GetDataServiceApiResponseBodyDataWizardDetailsWizardRequestParameters]
        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):
        self.api_id = api_id  # type: long
        self.api_mode = api_mode  # type: int
        self.api_name = api_name  # type: str
        self.api_path = api_path  # type: str
        self.created_time = created_time  # type: str
        self.creator_id = creator_id  # type: str
        self.description = description  # type: str
        self.folder_id = folder_id  # type: long
        self.group_id = group_id  # type: str
        self.modified_time = modified_time  # type: str
        self.operator_id = operator_id  # type: str
        self.project_id = project_id  # type: long
        self.protocols = protocols  # type: list[int]
        self.registration_details = registration_details  # type: GetDataServiceApiResponseBodyDataRegistrationDetails
        self.request_method = request_method  # type: int
        self.response_content_type = response_content_type  # type: int
        self.script_details = script_details  # type: GetDataServiceApiResponseBodyDataScriptDetails
        self.status = status  # type: int
        self.tenant_id = tenant_id  # type: long
        self.timeout = timeout  # type: int
        self.visible_range = visible_range  # type: int
        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):
        self.data = data  # type: GetDataServiceApiResponseBodyData
        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(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):
        self.application_id = application_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(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):
        self.application_code = application_code  # type: str
        self.application_id = application_id  # type: long
        self.application_key = application_key  # type: str
        self.application_name = application_name  # type: str
        self.application_secret = application_secret  # type: str
        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):
        self.data = data  # type: GetDataServiceApplicationResponseBodyData
        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(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):
        self.folder_id = folder_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(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):
        self.created_time = created_time  # type: str
        self.folder_id = folder_id  # type: long
        self.folder_name = folder_name  # type: str
        self.group_id = group_id  # type: str
        self.modified_time = modified_time  # type: str
        self.parent_id = parent_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(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):
        self.folder = folder  # type: GetDataServiceFolderResponseBodyFolder
        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):
        self.group_id = group_id  # type: str
        self.project_id = project_id  # type: long
        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):
        self.api_gateway_group_id = api_gateway_group_id  # type: str
        self.created_time = created_time  # type: str
        self.creator_id = creator_id  # type: str
        self.description = description  # type: str
        self.group_id = group_id  # type: str
        self.group_name = group_name  # type: str
        self.modified_time = modified_time  # type: str
        self.project_id = project_id  # type: long
        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):
        self.group = group  # type: GetDataServiceGroupResponseBodyGroup
        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):
        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(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):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        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):
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.failed_result_sample = failed_result_sample  # type: str
        self.registration_error_codes = registration_error_codes  # type: list[GetDataServicePublishedApiResponseBodyDataRegistrationDetailsRegistrationErrorCodes]
        self.registration_request_parameters = registration_request_parameters  # type: list[GetDataServicePublishedApiResponseBodyDataRegistrationDetailsRegistrationRequestParameters]
        self.service_content_type = service_content_type  # type: int
        self.service_host = service_host  # type: str
        self.service_path = service_path  # type: str
        self.service_request_body_description = service_request_body_description  # type: str
        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):
        self.connection_id = connection_id  # type: long
        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):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        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):
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.example_value = example_value  # type: str
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        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):
        self.failed_result_sample = failed_result_sample  # type: str
        self.is_paged_response = is_paged_response  # type: bool
        self.script = script  # type: str
        self.script_connection = script_connection  # type: GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptConnection
        self.script_error_codes = script_error_codes  # type: list[GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptErrorCodes]
        self.script_request_parameters = script_request_parameters  # type: list[GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptRequestParameters]
        self.script_response_parameters = script_response_parameters  # type: list[GetDataServicePublishedApiResponseBodyDataScriptDetailsScriptResponseParameters]
        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):
        self.connection_id = connection_id  # type: long
        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):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        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):
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.example_value = example_value  # type: str
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        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):
        self.failed_result_sample = failed_result_sample  # type: str
        self.is_paged_response = is_paged_response  # type: bool
        self.successful_result_sample = successful_result_sample  # type: str
        self.wizard_connection = wizard_connection  # type: GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardConnection
        self.wizard_error_codes = wizard_error_codes  # type: list[GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardErrorCodes]
        self.wizard_request_parameters = wizard_request_parameters  # type: list[GetDataServicePublishedApiResponseBodyDataWizardDetailsWizardRequestParameters]
        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):
        self.api_id = api_id  # type: long
        self.api_mode = api_mode  # type: int
        self.api_name = api_name  # type: str
        self.api_path = api_path  # type: str
        self.created_time = created_time  # type: str
        self.creator_id = creator_id  # type: str
        self.description = description  # type: str
        self.group_id = group_id  # type: str
        self.modified_time = modified_time  # type: str
        self.operator_id = operator_id  # type: str
        self.project_id = project_id  # type: long
        self.protocols = protocols  # type: list[int]
        self.registration_details = registration_details  # type: GetDataServicePublishedApiResponseBodyDataRegistrationDetails
        self.request_method = request_method  # type: int
        self.response_content_type = response_content_type  # type: int
        self.script_details = script_details  # type: GetDataServicePublishedApiResponseBodyDataScriptDetails
        self.status = status  # type: int
        self.tenant_id = tenant_id  # type: long
        self.timeout = timeout  # type: int
        self.visible_range = visible_range  # type: int
        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):
        self.data = data  # type: GetDataServicePublishedApiResponseBodyData
        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(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):
        self.datasource_name = datasource_name  # type: str
        self.env_type = env_type  # type: str
        self.page_number = page_number  # type: long
        self.page_size = page_size  # type: long
        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):
        self.message = message  # type: str
        self.meta = meta  # type: str
        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):
        self.data = data  # type: GetDataSourceMetaResponseBodyData
        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(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):
        self.deployment_id = deployment_id  # type: long
        self.project_id = project_id  # type: long
        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):
        self.checking_status = checking_status  # type: int
        self.create_time = create_time  # type: long
        self.creator_id = creator_id  # type: str
        self.error_message = error_message  # type: str
        self.execute_time = execute_time  # type: long
        self.from_environment = from_environment  # type: int
        self.handler_id = handler_id  # type: str
        self.name = name  # type: str
        self.status = status  # type: int
        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]
        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):
        self.data = data  # type: GetDeploymentResponseBodyData
        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(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):
        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):
        self.event_code = event_code  # type: str
        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):
        self.category_code = category_code  # type: str
        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):
        self.bind_event_list = bind_event_list  # type: list[GetExtensionResponseBodyExtensionBindEventList]
        self.detail_url = detail_url  # type: str
        self.event_category_list = event_category_list  # type: list[GetExtensionResponseBodyExtensionEventCategoryList]
        self.extension_code = extension_code  # type: str
        self.extension_desc = extension_desc  # type: str
        self.extension_name = extension_name  # type: str
        self.help_doc_url = help_doc_url  # type: str
        self.option_setting = option_setting  # type: str
        self.parameter_setting = parameter_setting  # type: str
        self.project_testing = project_testing  # type: long
        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):
        self.extension = extension  # type: GetExtensionResponseBodyExtension
        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):
        self.file_id = file_id  # type: long
        self.node_id = node_id  # type: long
        self.project_id = project_id  # type: long
        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_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.advanced_settings = advanced_settings  # type: str
        self.auto_parsing = auto_parsing  # type: bool
        self.biz_id = biz_id  # type: long
        self.business_id = business_id  # type: long
        self.commit_status = commit_status  # type: int
        self.connection_name = connection_name  # type: str
        self.content = content  # type: str
        self.create_time = create_time  # type: long
        self.create_user = create_user  # type: str
        self.current_version = current_version  # type: int
        self.deleted_status = deleted_status  # type: str
        self.file_description = file_description  # type: str
        self.file_folder_id = file_folder_id  # type: str
        self.file_name = file_name  # type: str
        self.file_type = file_type  # type: int
        self.is_max_compute = is_max_compute  # type: bool
        self.last_edit_time = last_edit_time  # type: long
        self.last_edit_user = last_edit_user  # type: str
        self.node_id = node_id  # type: long
        self.owner = owner  # type: str
        self.parent_id = parent_id  # type: long
        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_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('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):
        self.input = input  # type: str
        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):
        self.parameter_name = parameter_name  # type: str
        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):
        self.output = output  # type: str
        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):
        self.description = description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.type = type  # type: str
        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):
        self.auto_rerun_interval_millis = auto_rerun_interval_millis  # type: int
        self.auto_rerun_times = auto_rerun_times  # type: int
        self.cron_express = cron_express  # type: str
        self.cycle_type = cycle_type  # type: str
        self.dependent_node_id_list = dependent_node_id_list  # type: str
        self.dependent_type = dependent_type  # type: str
        self.end_effect_date = end_effect_date  # type: long
        self.input_list = input_list  # type: list[GetFileResponseBodyDataNodeConfigurationInputList]
        self.input_parameters = input_parameters  # type: list[GetFileResponseBodyDataNodeConfigurationInputParameters]
        self.output_list = output_list  # type: list[GetFileResponseBodyDataNodeConfigurationOutputList]
        self.output_parameters = output_parameters  # type: list[GetFileResponseBodyDataNodeConfigurationOutputParameters]
        self.para_value = para_value  # type: str
        self.rerun_mode = rerun_mode  # type: str
        self.resource_group_id = resource_group_id  # type: long
        self.scheduler_type = scheduler_type  # type: str
        self.start_effect_date = start_effect_date  # type: long
        self.start_immediately = start_immediately  # type: bool
        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):
        self.file = file  # type: GetFileResponseBodyDataFile
        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):
        self.data = data  # type: GetFileResponseBodyData
        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(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):
        self.project_env = project_env  # type: str
        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):
        self.count = count  # type: int
        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):
        self.program_type_and_counts = program_type_and_counts  # type: list[GetFileTypeStatisticResponseBodyProgramTypeAndCounts]
        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):
        self.file_id = file_id  # type: long
        self.file_version = file_version  # 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(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):
        self.change_type = change_type  # type: str
        self.comment = comment  # type: str
        self.commit_time = commit_time  # type: long
        self.commit_user = commit_user  # type: str
        self.file_content = file_content  # type: str
        self.file_name = file_name  # type: str
        self.file_property_content = file_property_content  # type: str
        self.file_version = file_version  # type: int
        self.is_current_prod = is_current_prod  # type: bool
        self.node_content = node_content  # type: str
        self.node_id = node_id  # type: long
        self.status = status  # type: str
        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):
        self.data = data  # type: GetFileVersionResponseBodyData
        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(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):
        self.folder_id = folder_id  # type: str
        self.folder_path = folder_path  # type: str
        self.project_id = project_id  # type: long
        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):
        self.folder_id = folder_id  # type: str
        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):
        self.data = data  # type: GetFolderResponseBodyData
        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(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):
        self.message_id = message_id  # type: str
        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):
        self.business_id = business_id  # type: long
        self.current_version = current_version  # type: long
        self.data_source_name = data_source_name  # type: str
        self.folder_id = folder_id  # type: str
        self.owner = owner  # type: str
        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):
        self.input = input  # type: str
        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):
        self.output = output  # type: str
        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):
        self.auto_rerun_interval_millis = auto_rerun_interval_millis  # type: long
        self.auto_rerun_times = auto_rerun_times  # type: long
        self.cron_express = cron_express  # type: str
        self.cycle_type = cycle_type  # type: str
        self.dependent_node_id_list = dependent_node_id_list  # type: str
        self.dependent_type = dependent_type  # type: str
        self.input_list = input_list  # type: list[GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfigurationInputList]
        self.output_list = output_list  # type: list[GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfigurationOutputList]
        self.para_value = para_value  # type: str
        self.rerun_mode = rerun_mode  # type: str
        self.resource_group_id = resource_group_id  # type: long
        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):
        self.change_type = change_type  # type: str
        self.comment = comment  # type: str
        self.committor = committor  # type: str
        self.content = content  # type: str
        self.file_id = file_id  # type: long
        self.file_name = file_name  # type: str
        self.file_property_content = file_property_content  # type: GetIDEEventDetailResponseBodyEventDetailCommittedFileFilePropertyContent
        self.file_type = file_type  # type: long
        self.node_configuration = node_configuration  # type: GetIDEEventDetailResponseBodyEventDetailCommittedFileNodeConfiguration
        self.node_id = node_id  # type: long
        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):
        self.business_id = business_id  # type: long
        self.content = content  # type: str
        self.current_version = current_version  # type: long
        self.data_source_name = data_source_name  # type: str
        self.file_id = file_id  # type: long
        self.file_name = file_name  # type: str
        self.file_type = file_type  # type: long
        self.folder_id = folder_id  # type: str
        self.node_id = node_id  # type: long
        self.owner = owner  # type: str
        self.parent_file_id = parent_file_id  # type: long
        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):
        self.content = content  # type: str
        self.data_source_name = data_source_name  # type: str
        self.file_id = file_id  # type: long
        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):
        self.column_name = column_name  # type: str
        self.column_type = column_type  # type: str
        self.comment = comment  # type: str
        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):
        self.columns = columns  # type: list[GetIDEEventDetailResponseBodyEventDetailTableModelColumns]
        self.comment = comment  # type: str
        self.data_source_name = data_source_name  # type: str
        self.env = env  # type: str
        self.life_cycle = life_cycle  # type: long
        self.location = location  # type: str
        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):
        self.committed_file = committed_file  # type: GetIDEEventDetailResponseBodyEventDetailCommittedFile
        self.deleted_file = deleted_file  # type: GetIDEEventDetailResponseBodyEventDetailDeletedFile
        self.file_execution_command = file_execution_command  # type: GetIDEEventDetailResponseBodyEventDetailFileExecutionCommand
        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):
        self.event_detail = event_detail  # type: GetIDEEventDetailResponseBodyEventDetail
        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):
        self.instance_id = instance_id  # type: long
        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):
        self.baseline_id = baseline_id  # 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.bizdate = bizdate  # type: long
        self.business_id = business_id  # type: long
        self.connection = connection  # type: str
        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.dqc_description = dqc_description  # type: str
        self.dqc_type = dqc_type  # type: int
        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.priority = priority  # type: int
        self.related_flow_id = related_flow_id  # type: long
        self.repeat_interval = repeat_interval  # type: long
        self.repeatability = repeatability  # type: bool
        self.status = status  # type: str
        self.task_rerun_time = task_rerun_time  # type: int
        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):
        self.data = data  # type: GetInstanceResponseBodyData
        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(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):
        self.instance_history_id = instance_history_id  # type: long
        self.instance_id = instance_id  # type: long
        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):
        self.data = data  # type: str
        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(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):
        self.biz_date = biz_date  # type: str
        self.project_env = project_env  # type: str
        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):
        self.failure_count = failure_count  # type: int
        self.not_run_count = not_run_count  # type: int
        self.running_count = running_count  # type: int
        self.success_count = success_count  # type: int
        self.total_count = total_count  # type: int
        self.wait_res_count = wait_res_count  # type: int
        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):
        self.request_id = request_id  # type: str
        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):
        self.biz_date = biz_date  # type: str
        self.dag_type = dag_type  # type: str
        self.project_env = project_env  # type: str
        self.project_id = project_id  # type: long
        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):
        self.failure_count = failure_count  # type: int
        self.not_run_count = not_run_count  # type: int
        self.running_count = running_count  # type: int
        self.success_count = success_count  # type: int
        self.total_count = total_count  # type: int
        self.wait_res_count = wait_res_count  # type: int
        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):
        self.request_id = request_id  # type: str
        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):
        self.page_num = page_num  # type: int
        self.page_size = page_size  # type: int
        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):
        self.category_id = category_id  # type: long
        self.comment = comment  # type: str
        self.create_time = create_time  # type: long
        self.depth = depth  # type: int
        self.last_operator_id = last_operator_id  # type: str
        self.modified_time = modified_time  # type: long
        self.name = name  # type: str
        self.owner_id = owner_id  # type: str
        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):
        self.data_entity_list = data_entity_list  # type: list[GetMetaCategoryResponseBodyDataDataEntityList]
        self.page_num = page_num  # type: int
        self.page_size = page_size  # type: int
        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):
        self.data = data  # type: GetMetaCategoryResponseBodyData
        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(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):
        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):
        self.collection = collection  # type: Collection
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        self.http_status_code = http_status_code  # type: int
        # Id of the request
        self.request_id = request_id  # type: str
        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):
        self.cluster_id = cluster_id  # type: str
        self.column_guid = column_guid  # type: str
        self.column_name = column_name  # type: str
        self.data_source_type = data_source_type  # type: str
        self.database_name = database_name  # type: str
        self.direction = direction  # type: str
        self.page_num = page_num  # type: int
        self.page_size = page_size  # type: int
        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):
        self.cluster_id = cluster_id  # type: str
        self.column_guid = column_guid  # type: str
        self.column_name = column_name  # type: str
        self.database_name = database_name  # type: str
        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):
        self.data_entity_list = data_entity_list  # type: list[GetMetaColumnLineageResponseBodyDataDataEntityList]
        self.page_num = page_num  # type: int
        self.page_size = page_size  # type: int
        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):
        self.data = data  # type: GetMetaColumnLineageResponseBodyData
        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(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):
        self.app_guid = app_guid  # type: str
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        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):
        self.app_guid = app_guid  # type: str
        self.cluster_biz_id = cluster_biz_id  # type: str
        self.comment = comment  # type: str
        self.create_time = create_time  # type: long
        self.endpoint = endpoint  # type: str
        self.env_type = env_type  # type: int
        self.location = location  # type: str
        self.modify_time = modify_time  # type: long
        self.name = name  # type: str
        self.owner_id = owner_id  # type: str
        self.owner_name = owner_name  # type: str
        self.project_id = project_id  # type: long
        self.project_name = project_name  # type: str
        self.project_name_cn = project_name_cn  # type: str
        self.tenant_id = tenant_id  # type: long
        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):
        self.data = data  # type: GetMetaDBInfoResponseBodyData
        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):
        self.app_guid = app_guid  # type: str
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.database_name = database_name  # type: str
        self.page_number = page_number  # type: int
        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
        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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.table_entity_list = table_entity_list  # type: list[GetMetaDBTableListResponseBodyDataTableEntityList]
        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):
        self.data = data  # type: GetMetaDBTableListResponseBodyData
        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):
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.database_name = database_name  # type: str
        self.extension = extension  # type: bool
        self.table_guid = table_guid  # type: str
        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):
        self.caption = caption  # type: str
        self.cluster_id = cluster_id  # type: str
        self.column_count = column_count  # type: int
        self.comment = comment  # type: str
        self.create_time = create_time  # type: long
        self.data_size = data_size  # type: long
        self.database_name = database_name  # type: str
        self.env_type = env_type  # type: int
        self.favorite_count = favorite_count  # type: long
        self.is_partition_table = is_partition_table  # type: bool
        self.is_view = is_view  # type: bool
        self.is_visible = is_visible  # type: int
        self.last_access_time = last_access_time  # type: long
        self.last_ddl_time = last_ddl_time  # type: long
        self.last_modify_time = last_modify_time  # type: long
        self.life_cycle = life_cycle  # type: int
        self.location = location  # type: str
        self.owner_id = owner_id  # type: str
        self.partition_keys = partition_keys  # type: str
        self.project_id = project_id  # type: long
        self.project_name = project_name  # type: str
        self.read_count = read_count  # type: long
        self.schema = schema  # type: str
        self.table_guid = table_guid  # type: str
        self.table_name = table_name  # type: str
        self.tenant_id = tenant_id  # type: long
        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):
        self.data = data  # type: GetMetaTableBasicInfoResponseBodyData
        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(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):
        self.change_type = change_type  # type: str
        self.end_date = end_date  # type: str
        self.object_type = object_type  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.start_date = start_date  # type: str
        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):
        self.change_content = change_content  # type: str
        self.change_type = change_type  # type: str
        self.create_time = create_time  # type: long
        self.modified_time = modified_time  # type: long
        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):
        self.data_entity_list = data_entity_list  # type: list[GetMetaTableChangeLogResponseBodyDataDataEntityList]
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        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):
        self.data = data  # type: GetMetaTableChangeLogResponseBodyData
        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(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):
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.database_name = database_name  # type: str
        self.page_num = page_num  # type: int
        self.page_size = page_size  # type: int
        self.table_guid = table_guid  # type: str
        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):
        self.caption = caption  # type: str
        self.column_guid = column_guid  # type: str
        self.column_name = column_name  # type: str
        self.column_type = column_type  # type: str
        self.comment = comment  # type: str
        self.is_foreign_key = is_foreign_key  # type: bool
        self.is_partition_column = is_partition_column  # type: bool
        self.is_primary_key = is_primary_key  # type: bool
        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):
        self.column_list = column_list  # type: list[GetMetaTableColumnResponseBodyDataColumnList]
        self.page_num = page_num  # type: int
        self.page_size = page_size  # type: int
        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):
        self.data = data  # type: GetMetaTableColumnResponseBodyData
        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(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):
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.database_name = database_name  # type: str
        self.page_num = page_num  # type: int
        self.page_size = page_size  # type: int
        self.table_guid = table_guid  # type: str
        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):
        self.caption = caption  # type: str
        self.column_guid = column_guid  # type: str
        self.column_name = column_name  # type: str
        self.column_type = column_type  # type: str
        self.comment = comment  # type: str
        self.is_foreign_key = is_foreign_key  # type: bool
        self.is_partition_column = is_partition_column  # type: bool
        self.is_primary_key = is_primary_key  # type: bool
        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):
        self.cluster_id = cluster_id  # type: str
        self.column_list = column_list  # type: list[GetMetaTableFullInfoResponseBodyDataColumnList]
        self.comment = comment  # type: str
        self.create_time = create_time  # type: long
        self.data_size = data_size  # type: long
        self.database_name = database_name  # type: str
        self.env_type = env_type  # type: int
        self.is_visible = is_visible  # type: int
        self.last_access_time = last_access_time  # type: long
        self.last_ddl_time = last_ddl_time  # type: long
        self.last_modify_time = last_modify_time  # type: long
        self.life_cycle = life_cycle  # type: int
        self.location = location  # type: str
        self.owner_id = owner_id  # type: str
        self.partition_keys = partition_keys  # type: str
        self.project_id = project_id  # type: long
        self.project_name = project_name  # type: str
        self.schema = schema  # type: str
        self.table_guid = table_guid  # type: str
        self.table_name = table_name  # type: str
        self.tenant_id = tenant_id  # type: long
        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):
        self.data = data  # type: GetMetaTableFullInfoResponseBodyData
        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(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):
        self.table_guid = table_guid  # type: str
        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):
        self.content = content  # type: str
        self.create_time = create_time  # type: long
        self.creator = creator  # type: str
        self.creator_name = creator_name  # type: str
        self.modified_time = modified_time  # type: long
        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):
        self.data = data  # type: GetMetaTableIntroWikiResponseBodyData
        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(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):
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.database_name = database_name  # type: str
        self.direction = direction  # type: str
        self.next_primary_key = next_primary_key  # type: str
        self.page_size = page_size  # type: int
        self.table_guid = table_guid  # type: str
        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, table_guid=None, table_name=None):
        self.create_timestamp = create_timestamp  # type: long
        self.table_guid = table_guid  # type: str
        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.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('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):
        self.data_entity_list = data_entity_list  # type: list[GetMetaTableLineageResponseBodyDataDataEntityList]
        self.has_next = has_next  # type: bool
        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):
        self.data = data  # type: GetMetaTableLineageResponseBodyData
        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(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):
        self.end_date = end_date  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.start_date = start_date  # type: str
        self.table_guid = table_guid  # type: str
        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):
        self.end_time = end_time  # type: str
        self.project_id = project_id  # type: long
        self.start_time = start_time  # type: str
        self.table_guid = table_guid  # type: str
        self.task_id = task_id  # type: str
        self.task_instance_id = task_instance_id  # type: long
        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):
        self.data_entity_list = data_entity_list  # type: list[GetMetaTableOutputResponseBodyDataDataEntityList]
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        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):
        self.data = data  # type: GetMetaTableOutputResponseBodyData
        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(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):
        self.order = order  # type: str
        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):
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.database_name = database_name  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.sort_criterion = sort_criterion  # type: GetMetaTablePartitionRequestSortCriterion
        self.table_guid = table_guid  # type: str
        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):
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.database_name = database_name  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.sort_criterion_shrink = sort_criterion_shrink  # 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(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):
        self.comment = comment  # type: str
        self.create_time = create_time  # type: long
        self.data_size = data_size  # type: long
        self.modified_time = modified_time  # type: long
        self.partition_guid = partition_guid  # type: str
        self.partition_location = partition_location  # type: str
        self.partition_name = partition_name  # type: str
        self.partition_path = partition_path  # type: str
        self.partition_type = partition_type  # type: str
        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):
        self.data_entity_list = data_entity_list  # type: list[GetMetaTablePartitionResponseBodyDataDataEntityList]
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        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):
        self.data = data  # type: GetMetaTablePartitionResponseBodyData
        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(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):
        self.data_source_type = data_source_type  # type: str
        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):
        self.description = description  # type: str
        self.level_id = level_id  # type: long
        self.name = name  # type: str
        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):
        self.level = level  # type: int
        self.name = name  # type: str
        self.parent_id = parent_id  # type: long
        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):
        self.level = level  # type: list[GetMetaTableThemeLevelResponseBodyEntityLevel]
        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):
        self.entity = entity  # type: GetMetaTableThemeLevelResponseBodyEntity
        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.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):
        self.migration_id = migration_id  # type: long
        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):
        self.task_name = task_name  # type: str
        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):
        self.data = data  # type: list[GetMigrationProcessResponseBodyData]
        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(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):
        self.migration_id = migration_id  # type: long
        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):
        self.create_user = create_user  # type: str
        self.download_url = download_url  # type: str
        self.gmt_create = gmt_create  # type: long
        self.gmt_modified = gmt_modified  # type: long
        self.migration_id = migration_id  # type: long
        self.name = name  # type: str
        self.op_user = op_user  # type: str
        self.project_id = project_id  # type: long
        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):
        self.data = data  # type: GetMigrationSummaryResponseBodyData
        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(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):
        self.node_id = node_id  # type: long
        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, 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):
        self.baseline_id = baseline_id  # type: long
        self.business_id = business_id  # type: long
        self.connection = connection  # type: str
        self.cron_express = cron_express  # type: str
        self.description = description  # type: str
        self.dqc_description = dqc_description  # type: str
        self.dqc_type = dqc_type  # type: int
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.owner_id = owner_id  # type: str
        self.param_values = param_values  # type: str
        self.priority = priority  # type: int
        self.program_type = program_type  # type: str
        self.project_id = project_id  # type: long
        self.related_flow_id = related_flow_id  # type: long
        self.repeat_interval = repeat_interval  # type: long
        self.repeatability = repeatability  # type: str
        self.res_group_name = res_group_name  # type: str
        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.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('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('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 GetNodeResponseBody(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: GetNodeResponseBodyData
        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(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):
        self.node_id = node_id  # type: long
        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):
        self.baseline_id = baseline_id  # type: long
        self.cron_express = cron_express  # type: str
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.owner_id = owner_id  # type: str
        self.priority = priority  # type: int
        self.program_type = program_type  # type: str
        self.project_id = project_id  # type: long
        self.repeatability = repeatability  # type: bool
        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):
        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):
        self.data = data  # type: GetNodeChildrenResponseBodyData
        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(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):
        self.node_id = node_id  # type: long
        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):
        self.data = data  # type: str
        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(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):
        self.node_id = node_id  # type: long
        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):
        self.baseline_id = baseline_id  # type: long
        self.cron_express = cron_express  # type: str
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.owner_id = owner_id  # type: str
        self.priority = priority  # type: int
        self.program_type = program_type  # type: str
        self.project_id = project_id  # type: long
        self.repeatability = repeatability  # type: bool
        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):
        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):
        self.data = data  # type: GetNodeParentsResponseBodyData
        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(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):
        self.date = date  # type: str
        self.name = name  # type: str
        self.page_no = page_no  # type: int
        self.page_size = page_size  # type: int
        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):
        self.request_id = request_id  # type: str
        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):
        self.date = date  # type: str
        self.name = name  # type: str
        self.op_type = op_type  # type: str
        self.page_no = page_no  # type: int
        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):
        self.op_sensitive_data = op_sensitive_data  # type: str
        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):
        self.extension_code = extension_code  # type: str
        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
        # Id of the request
        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):
        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):
        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):
        self.column_comment = column_comment  # type: str
        self.column_name = column_name  # 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
        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')
        return self


class GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMetaObjectMetaList(TeaModel):
    def __init__(self, column_meta_list=None, object_name=None):
        self.column_meta_list = column_meta_list  # type: list[GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMetaObjectMetaListColumnMetaList]
        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):
        self.max_compute_project_name = max_compute_project_name  # type: str
        self.object_meta_list = object_meta_list  # type: list[GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContentProjectMetaObjectMetaList]
        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):
        self.apply_reason = apply_reason  # type: str
        self.deadline = deadline  # type: long
        self.order_type = order_type  # type: int
        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):
        self.grantee_id = grantee_id  # type: str
        self.grantee_name = grantee_name  # type: str
        self.grantee_type = grantee_type  # type: int
        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):
        self.apply_base_id = apply_base_id  # type: str
        self.apply_timestamp = apply_timestamp  # type: long
        self.approve_account_list = approve_account_list  # type: list[GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveAccountList]
        self.approve_content = approve_content  # type: GetPermissionApplyOrderDetailResponseBodyApplyOrderDetailApproveContent
        self.flow_id = flow_id  # type: str
        self.flow_status = flow_status  # type: int
        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):
        self.apply_order_detail = apply_order_detail  # type: GetPermissionApplyOrderDetailResponseBodyApplyOrderDetail
        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):
        self.project_id = project_id  # type: long

    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
        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 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):
        self.appkey = appkey  # type: str
        self.base_project = base_project  # type: bool
        self.default_di_resource_group_identifier = default_di_resource_group_identifier  # type: str
        self.destination = destination  # type: int
        self.dev_storage_quota = dev_storage_quota  # 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.max_flow_node = max_flow_node  # type: int
        self.prod_storage_quota = prod_storage_quota  # type: str
        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[GetProjectResponseBodyDataTags]
        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(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):
        self.data = data  # type: GetProjectResponseBodyData
        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(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_name=None, table_name=None):
        self.env_type = env_type  # type: str
        self.match_expression = match_expression  # type: str
        self.project_name = project_name  # type: str
        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_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('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):
        self.create_time = create_time  # type: long
        self.entity_level = entity_level  # type: int
        self.env_type = env_type  # type: str
        self.followers = followers  # type: str
        self.has_relative_node = has_relative_node  # type: bool
        self.id = id  # type: long
        self.match_expression = match_expression  # type: str
        self.modify_time = modify_time  # type: long
        self.modify_user = modify_user  # type: str
        self.on_duty = on_duty  # type: str
        self.on_duty_account_name = on_duty_account_name  # type: str
        self.project_name = project_name  # type: str
        self.relative_node = relative_node  # type: str
        self.sql = sql  # type: int
        self.table_name = table_name  # type: str
        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):
        self.data = data  # type: list[GetQualityEntityResponseBodyData]
        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(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_name=None):
        self.entity_id = entity_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_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('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class GetQualityFollowerResponseBodyData(TeaModel):
    def __init__(self, alarm_mode=None, entity_id=None, follower=None, follower_account_name=None, id=None,
                 project_name=None, table_name=None):
        self.alarm_mode = alarm_mode  # type: int
        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.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.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.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('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('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_name=None, rule_id=None):
        self.project_name = project_name  # type: str
        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_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('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, 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):
        self.block_type = block_type  # type: int
        self.checker = checker  # type: int
        self.checker_name = checker_name  # type: str
        self.comment = comment  # type: str
        self.critical_threshold = critical_threshold  # type: str
        self.entity_id = entity_id  # type: long
        self.expect_value = expect_value  # type: str
        self.fix_check = fix_check  # type: bool
        self.id = id  # type: long
        self.method_id = method_id  # type: int
        self.method_name = method_name  # type: str
        self.on_duty = on_duty  # type: str
        self.on_duty_account_name = on_duty_account_name  # type: str
        self.operator = operator  # type: str
        self.predict_type = predict_type  # type: int
        self.property = property  # type: str
        self.rule_name = rule_name  # type: str
        self.rule_type = rule_type  # type: int
        self.template_id = template_id  # type: int
        self.template_name = template_name  # type: str
        self.trend = trend  # type: str
        self.warning_threshold = warning_threshold  # type: str
        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.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('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):
        self.data = data  # type: GetQualityRuleResponseBodyData
        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(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):
        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):
        self.baseline_id = baseline_id  # type: long
        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):
        self.biz_id = biz_id  # type: long
        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):
        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(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):
        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):
        self.at_all = at_all  # type: bool
        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):
        self.alert_interval = alert_interval  # type: int
        self.alert_methods = alert_methods  # type: list[str]
        self.alert_targets = alert_targets  # type: list[str]
        self.alert_unit = alert_unit  # type: str
        self.baselines = baselines  # type: list[GetRemindResponseBodyDataBaselines]
        self.biz_processes = biz_processes  # type: list[GetRemindResponseBodyDataBizProcesses]
        self.detail = detail  # type: str
        self.dnd_end = dnd_end  # type: str
        self.dnd_start = dnd_start  # type: str
        self.founder = founder  # type: str
        self.max_alert_times = max_alert_times  # type: int
        self.nodes = nodes  # type: list[GetRemindResponseBodyDataNodes]
        self.projects = projects  # type: list[GetRemindResponseBodyDataProjects]
        self.remind_id = remind_id  # type: long
        self.remind_name = remind_name  # type: str
        self.remind_type = remind_type  # type: str
        self.remind_unit = remind_unit  # type: str
        self.robots = robots  # type: list[GetRemindResponseBodyDataRobots]
        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):
        self.data = data  # type: GetRemindResponseBodyData
        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(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):
        self.name = name  # type: str
        self.page_no = page_no  # type: int
        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):
        self.request_id = request_id  # type: str
        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):
        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
        self.alert_time = alert_time  # type: long
        self.assigner = assigner  # type: str
        self.baseline_buffer = baseline_buffer  # type: long
        self.baseline_id = baseline_id  # type: long
        self.baseline_in_group_id = baseline_in_group_id  # type: int
        self.baseline_name = baseline_name  # type: str
        self.baseline_status = baseline_status  # type: str
        self.buffer = buffer  # type: long
        self.deal_time = deal_time  # type: long
        self.deal_user = deal_user  # type: str
        self.fix_time = fix_time  # type: long
        self.happen_time = happen_time  # type: long
        self.instance_id = instance_id  # type: long
        self.next_alert_time = next_alert_time  # type: long
        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
        self.topic_id = topic_id  # type: long
        self.topic_name = topic_name  # type: str
        self.topic_status = topic_status  # type: str
        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):
        self.data = data  # type: GetTopicResponseBodyData
        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(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):
        self.data_sources = data_sources  # type: str
        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):
        self.message = message  # type: str
        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):
        self.data = data  # type: ImportDataSourcesResponseBodyData
        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(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):
        self.alert_methods = alert_methods  # type: str
        self.alert_rule_types = alert_rule_types  # type: str
        self.alert_user = alert_user  # type: str
        self.baseline_id = baseline_id  # type: long
        self.begin_time = begin_time  # type: str
        self.end_time = end_time  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        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):
        self.instance_id = instance_id  # type: long
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.project_id = project_id  # type: long
        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):
        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(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):
        self.baseline_id = baseline_id  # type: long
        self.baseline_name = baseline_name  # type: str
        self.baseline_owner = baseline_owner  # type: str
        self.bizdate = bizdate  # type: long
        self.in_group_id = in_group_id  # type: int
        self.project_id = project_id  # type: long
        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):
        self.instance_id = instance_id  # type: long
        self.node_id = node_id  # type: long
        self.topic_id = topic_id  # type: long
        self.topic_name = topic_name  # type: str
        self.topic_owner = topic_owner  # type: str
        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):
        self.alert_id = alert_id  # type: long
        self.alert_message_status = alert_message_status  # type: str
        self.alert_method = alert_method  # type: str
        self.alert_time = alert_time  # type: long
        self.alert_user = alert_user  # type: str
        self.content = content  # type: str
        self.instances = instances  # type: list[ListAlertMessagesResponseBodyDataAlertMessagesInstances]
        self.nodes = nodes  # type: list[ListAlertMessagesResponseBodyDataAlertMessagesNodes]
        self.remind_id = remind_id  # type: long
        self.remind_name = remind_name  # type: str
        self.sla_alert = sla_alert  # type: ListAlertMessagesResponseBodyDataAlertMessagesSlaAlert
        self.source = source  # type: str
        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):
        self.alert_messages = alert_messages  # type: list[ListAlertMessagesResponseBodyDataAlertMessages]
        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.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):
        self.data = data  # type: ListAlertMessagesResponseBodyData
        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(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):
        self.baseline_types = baseline_types  # type: str
        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
        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):
        self.baseline_id = baseline_id  # type: long
        self.baseline_name = baseline_name  # type: str
        self.baseline_type = baseline_type  # type: str
        self.exp_hour = exp_hour  # type: int
        self.exp_minu = exp_minu  # type: int
        self.hour_exp_detail = hour_exp_detail  # type: str
        self.hour_sla_detail = hour_sla_detail  # type: str
        self.is_default = is_default  # type: bool
        self.owner = owner  # type: str
        self.priority = priority  # type: int
        self.project_id = project_id  # type: long
        self.sla_hour = sla_hour  # type: int
        self.sla_minu = sla_minu  # type: int
        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):
        self.baselines = baselines  # type: list[ListBaselineConfigsResponseBodyDataBaselines]
        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.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):
        self.data = data  # type: ListBaselineConfigsResponseBodyData
        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(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):
        self.baseline_types = baseline_types  # type: str
        self.bizdate = bizdate  # type: str
        self.finish_status = finish_status  # type: str
        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.search_text = search_text  # type: str
        self.status = status  # type: str
        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):
        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.end_cast = end_cast  # type: long
        self.exp_time = exp_time  # type: long
        self.finish_status = finish_status  # type: str
        self.finish_time = finish_time  # 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.sla_time = sla_time  # type: long
        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):
        self.baseline_statuses = baseline_statuses  # type: list[ListBaselineStatusesResponseBodyDataBaselineStatuses]
        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.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):
        self.data = data  # type: ListBaselineStatusesResponseBodyData
        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(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, dynamic_error_code=None, dynamic_error_message=None, error_code=None,
                 error_message=None, http_status_code=None, request_id=None, success=None):
        self.data = data  # type: ListBaselinesResponseBodyData
        self.dynamic_error_code = dynamic_error_code  # type: str
        self.dynamic_error_message = dynamic_error_message  # type: str
        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.dynamic_error_code is not None:
            result['DynamicErrorCode'] = self.dynamic_error_code
        if self.dynamic_error_message is not None:
            result['DynamicErrorMessage'] = self.dynamic_error_message
        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('DynamicErrorCode') is not None:
            self.dynamic_error_code = m.get('DynamicErrorCode')
        if m.get('DynamicErrorMessage') is not None:
            self.dynamic_error_message = m.get('DynamicErrorMessage')
        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):
        self.keyword = keyword  # 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(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):
        self.business_id = business_id  # type: long
        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.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):
        self.business = business  # type: list[ListBusinessResponseBodyDataBusiness]
        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.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):
        self.data = data  # type: ListBusinessResponseBodyData
        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(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 ListDIProjectConfigRequest(TeaModel):
    def __init__(self, destination_type=None, project_id=None, source_type=None):
        self.destination_type = destination_type  # type: str
        self.project_id = project_id  # type: long
        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):
        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):
        self.data = data  # type: ListDIProjectConfigResponseBodyData
        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(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):
        self.op_seq = op_seq  # type: long
        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):
        self.bizdate = bizdate  # type: long
        self.create_time = create_time  # type: long
        self.create_user = create_user  # type: str
        # DagId。
        self.dag_id = dag_id  # type: long
        self.finish_time = finish_time  # type: long
        # Gmtdate。
        self.gmtdate = gmtdate  # type: long
        self.modify_time = modify_time  # type: long
        self.name = name  # type: str
        self.op_seq = op_seq  # type: long
        self.project_id = project_id  # type: long
        self.start_time = start_time  # type: long
        self.status = status  # type: str
        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):
        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):
        self.data = data  # type: ListDagsResponseBodyData
        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(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):
        self.api_name_keyword = api_name_keyword  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        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):
        self.created_time = created_time  # type: str
        self.creator_id = creator_id  # type: str
        self.end_time = end_time  # type: str
        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):
        self.api_id = api_id  # type: long
        self.api_name = api_name  # type: str
        self.api_path = api_path  # type: str
        self.api_status = api_status  # type: int
        self.authorization_records = authorization_records  # type: list[ListDataServiceApiAuthoritiesResponseBodyDataApiAuthorizationListAuthorizationRecords]
        self.created_time = created_time  # type: str
        self.creator_id = creator_id  # type: str
        self.group_id = group_id  # type: str
        self.modified_time = modified_time  # type: str
        self.project_id = project_id  # type: long
        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):
        self.api_authorization_list = api_authorization_list  # type: list[ListDataServiceApiAuthoritiesResponseBodyDataApiAuthorizationList]
        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.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):
        self.data = data  # type: ListDataServiceApiAuthoritiesResponseBodyData
        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(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):
        self.api_id = api_id  # type: long
        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):
        self.api_id = api_id  # type: long
        self.cost_time = cost_time  # type: int
        self.create_time = create_time  # type: long
        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
        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):
        self.data = data  # type: list[ListDataServiceApiTestResponseBodyData]
        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):
        self.api_name_keyword = api_name_keyword  # type: str
        self.api_path_keyword = api_path_keyword  # type: str
        self.creator_id = creator_id  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        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):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        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):
        self.column_name = column_name  # type: str
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.failed_result_sample = failed_result_sample  # type: str
        self.registration_error_codes = registration_error_codes  # type: list[ListDataServiceApisResponseBodyDataApisRegistrationDetailsRegistrationErrorCodes]
        self.registration_request_parameters = registration_request_parameters  # type: list[ListDataServiceApisResponseBodyDataApisRegistrationDetailsRegistrationRequestParameters]
        self.service_content_type = service_content_type  # type: int
        self.service_host = service_host  # type: str
        self.service_path = service_path  # type: str
        self.service_request_body_description = service_request_body_description  # type: str
        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):
        self.connection_id = connection_id  # type: long
        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):
        self.column_name = column_name  # type: str
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.column_name = column_name  # type: str
        self.example_value = example_value  # type: str
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        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):
        self.is_paged_response = is_paged_response  # type: bool
        self.script = script  # type: str
        self.script_connection = script_connection  # type: ListDataServiceApisResponseBodyDataApisScriptDetailsScriptConnection
        self.script_request_parameters = script_request_parameters  # type: list[ListDataServiceApisResponseBodyDataApisScriptDetailsScriptRequestParameters]
        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):
        self.connection_id = connection_id  # type: long
        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):
        self.column_name = column_name  # type: str
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.column_name = column_name  # type: str
        self.example_value = example_value  # type: str
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        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):
        self.is_paged_response = is_paged_response  # type: bool
        self.wizard_connection = wizard_connection  # type: ListDataServiceApisResponseBodyDataApisWizardDetailsWizardConnection
        self.wizard_request_parameters = wizard_request_parameters  # type: list[ListDataServiceApisResponseBodyDataApisWizardDetailsWizardRequestParameters]
        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):
        self.api_id = api_id  # type: long
        self.api_mode = api_mode  # type: int
        self.api_name = api_name  # type: str
        self.api_path = api_path  # type: str
        self.created_time = created_time  # type: str
        self.creator_id = creator_id  # type: str
        self.description = description  # type: str
        self.folder_id = folder_id  # type: long
        self.group_id = group_id  # type: str
        self.modified_time = modified_time  # type: str
        self.operator_id = operator_id  # type: str
        self.project_id = project_id  # type: long
        self.protocols = protocols  # type: list[int]
        self.registration_details = registration_details  # type: ListDataServiceApisResponseBodyDataApisRegistrationDetails
        self.request_method = request_method  # type: int
        self.response_content_type = response_content_type  # type: int
        self.script_details = script_details  # type: ListDataServiceApisResponseBodyDataApisScriptDetails
        self.status = status  # type: int
        self.tenant_id = tenant_id  # type: long
        self.timeout = timeout  # type: int
        self.visible_range = visible_range  # type: int
        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):
        self.apis = apis  # type: list[ListDataServiceApisResponseBodyDataApis]
        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.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):
        self.data = data  # type: ListDataServiceApisResponseBodyData
        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(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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id_list = project_id_list  # type: str
        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):
        self.application_id = application_id  # type: long
        self.application_name = application_name  # type: str
        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):
        self.applications = applications  # type: list[ListDataServiceApplicationsResponseBodyDataApplications]
        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.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):
        self.data = data  # type: ListDataServiceApplicationsResponseBodyData
        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(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):
        self.api_name_keyword = api_name_keyword  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        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):
        self.api_id = api_id  # type: long
        self.api_name = api_name  # type: str
        self.api_path = api_path  # type: str
        self.api_status = api_status  # type: int
        self.created_time = created_time  # type: str
        self.creator_id = creator_id  # type: str
        self.grant_created_time = grant_created_time  # type: str
        self.grant_end_time = grant_end_time  # type: str
        self.grant_operator_id = grant_operator_id  # type: str
        self.group_id = group_id  # type: str
        self.modified_time = modified_time  # type: str
        self.project_id = project_id  # type: long
        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):
        self.api_authorized_list = api_authorized_list  # type: list[ListDataServiceAuthorizedApisResponseBodyDataApiAuthorizedList]
        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.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):
        self.data = data  # type: ListDataServiceAuthorizedApisResponseBodyData
        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(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):
        self.folder_name_keyword = folder_name_keyword  # type: str
        self.group_id = group_id  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        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):
        self.created_time = created_time  # type: str
        self.folder_id = folder_id  # type: long
        self.folder_name = folder_name  # type: str
        self.group_id = group_id  # type: str
        self.modified_time = modified_time  # type: str
        self.parent_id = parent_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(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):
        self.folders = folders  # type: list[ListDataServiceFoldersResponseBodyFolderPagingResultFolders]
        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.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):
        self.folder_paging_result = folder_paging_result  # type: ListDataServiceFoldersResponseBodyFolderPagingResult
        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):
        self.group_name_keyword = group_name_keyword  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        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):
        self.api_gateway_group_id = api_gateway_group_id  # type: str
        self.created_time = created_time  # type: str
        self.creator_id = creator_id  # type: str
        self.description = description  # type: str
        self.group_id = group_id  # type: str
        self.group_name = group_name  # type: str
        self.modified_time = modified_time  # type: str
        self.project_id = project_id  # type: long
        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):
        self.groups = groups  # type: list[ListDataServiceGroupsResponseBodyGroupPagingResultGroups]
        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.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):
        self.group_paging_result = group_paging_result  # type: ListDataServiceGroupsResponseBodyGroupPagingResult
        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):
        self.api_name_keyword = api_name_keyword  # type: str
        self.api_path_keyword = api_path_keyword  # type: str
        self.creator_id = creator_id  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: long
        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):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        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):
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.failed_result_sample = failed_result_sample  # type: str
        self.registration_error_codes = registration_error_codes  # type: list[ListDataServicePublishedApisResponseBodyDataApisRegistrationDetailsRegistrationErrorCodes]
        self.registration_request_parameters = registration_request_parameters  # type: list[ListDataServicePublishedApisResponseBodyDataApisRegistrationDetailsRegistrationRequestParameters]
        self.service_content_type = service_content_type  # type: int
        self.service_host = service_host  # type: str
        self.service_path = service_path  # type: str
        self.service_request_body_description = service_request_body_description  # type: str
        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):
        self.connection_id = connection_id  # type: long
        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):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        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):
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.example_value = example_value  # type: str
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        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):
        self.failed_result_sample = failed_result_sample  # type: str
        self.is_paged_response = is_paged_response  # type: bool
        self.script = script  # type: str
        self.script_connection = script_connection  # type: ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptConnection
        self.script_error_codes = script_error_codes  # type: list[ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptErrorCodes]
        self.script_request_parameters = script_request_parameters  # type: list[ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptRequestParameters]
        self.script_response_parameters = script_response_parameters  # type: list[ListDataServicePublishedApisResponseBodyDataApisScriptDetailsScriptResponseParameters]
        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):
        self.connection_id = connection_id  # type: long
        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):
        self.error_code = error_code  # type: str
        self.error_message = error_message  # type: str
        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):
        self.default_value = default_value  # type: str
        self.example_value = example_value  # type: str
        self.is_required_parameter = is_required_parameter  # type: bool
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        self.parameter_name = parameter_name  # type: str
        self.parameter_operator = parameter_operator  # type: int
        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):
        self.example_value = example_value  # type: str
        self.parameter_data_type = parameter_data_type  # type: int
        self.parameter_description = parameter_description  # type: str
        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):
        self.failed_result_sample = failed_result_sample  # type: str
        self.is_paged_response = is_paged_response  # type: bool
        self.successful_result_sample = successful_result_sample  # type: str
        self.wizard_connection = wizard_connection  # type: ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardConnection
        self.wizard_error_codes = wizard_error_codes  # type: list[ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardErrorCodes]
        self.wizard_request_parameters = wizard_request_parameters  # type: list[ListDataServicePublishedApisResponseBodyDataApisWizardDetailsWizardRequestParameters]
        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):
        self.api_id = api_id  # type: long
        self.api_mode = api_mode  # type: int
        self.api_name = api_name  # type: str
        self.api_path = api_path  # type: str
        self.created_time = created_time  # type: str
        self.creator_id = creator_id  # type: str
        self.description = description  # type: str
        self.group_id = group_id  # type: str
        self.modified_time = modified_time  # type: str
        self.operator_id = operator_id  # type: str
        self.project_id = project_id  # type: long
        self.protocols = protocols  # type: list[int]
        self.registration_details = registration_details  # type: ListDataServicePublishedApisResponseBodyDataApisRegistrationDetails
        self.request_method = request_method  # type: int
        self.response_content_type = response_content_type  # type: int
        self.script_details = script_details  # type: ListDataServicePublishedApisResponseBodyDataApisScriptDetails
        self.status = status  # type: int
        self.tenant_id = tenant_id  # type: long
        self.timeout = timeout  # type: int
        self.visible_range = visible_range  # type: int
        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):
        self.apis = apis  # type: list[ListDataServicePublishedApisResponseBodyDataApis]
        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.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):
        self.data = data  # type: ListDataServicePublishedApisResponseBodyData
        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(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):
        self.data_source_type = data_source_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(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: int
        self.connect_status = connect_status  # type: int
        self.content = content  # type: str
        self.data_source_type = data_source_type  # 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(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):
        self.data_sources = data_sources  # type: list[ListDataSourcesResponseBodyDataDataSources]
        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.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):
        self.data = data  # type: ListDataSourcesResponseBodyData
        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(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):
        self.creator = creator  # type: str
        self.end_create_time = end_create_time  # type: long
        self.end_execute_time = end_execute_time  # type: long
        self.executor = executor  # type: str
        self.keyword = keyword  # 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
        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):
        self.create_time = create_time  # type: long
        self.creator = creator  # type: str
        self.error_message = error_message  # type: str
        self.execute_time = execute_time  # type: long
        self.executor = executor  # type: str
        self.id = id  # type: long
        self.name = name  # type: str
        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):
        self.deployments = deployments  # type: list[ListDeploymentsResponseBodyDataDeployments]
        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.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):
        self.data = data  # type: ListDeploymentsResponseBodyData
        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):
        self.event_code = event_code  # type: str
        self.file_type = file_type  # type: str
        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):
        self.create_user = create_user  # type: str
        self.extension_code = extension_code  # type: str
        self.extension_desc = extension_desc  # type: str
        self.extension_name = extension_name  # type: str
        self.gmt_create = gmt_create  # type: long
        self.gmt_modified = gmt_modified  # type: long
        self.modify_user = modify_user  # type: str
        self.owner = owner  # type: str
        self.parameter_setting = parameter_setting  # type: str
        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):
        self.extensions = extensions  # type: list[ListEnabledExtensionsForProjectResponseBodyExtensions]
        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 ListExtensionsRequest(TeaModel):
    def __init__(self, page_number=None, page_size=None):
        self.page_number = page_number  # type: int
        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
        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):
        self.bind_event_list = bind_event_list  # type: list[ListExtensionsResponseBodyPagingInfoExtensionsBindEventList]
        self.extension_code = extension_code  # type: str
        self.extension_desc = extension_desc  # type: str
        self.extension_name = extension_name  # type: str
        self.owner = owner  # type: str
        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):
        self.extensions = extensions  # type: list[ListExtensionsResponseBodyPagingInfoExtensions]
        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.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):
        self.paging_info = paging_info  # type: ListExtensionsResponseBodyPagingInfo
        # Id of the request
        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):
        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(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):
        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(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):
        self.node_type_info = node_type_info  # type: list[ListFileTypeResponseBodyNodeTypeInfoListNodeTypeInfo]
        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(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):
        self.node_type_info_list = node_type_info_list  # type: ListFileTypeResponseBodyNodeTypeInfoList
        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):
        self.file_id = file_id  # type: long
        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(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):
        self.change_type = change_type  # type: str
        self.comment = comment  # type: str
        self.commit_time = commit_time  # type: long
        self.commit_user = commit_user  # type: str
        self.file_content = file_content  # type: str
        self.file_name = file_name  # type: str
        self.file_property_content = file_property_content  # type: str
        self.file_version = file_version  # type: int
        self.is_current_prod = is_current_prod  # type: bool
        self.node_content = node_content  # type: str
        self.node_id = node_id  # type: long
        self.status = status  # type: str
        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):
        self.file_versions = file_versions  # type: list[ListFileVersionsResponseBodyDataFileVersions]
        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.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):
        self.data = data  # type: ListFileVersionsResponseBodyData
        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(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, file_folder_path=None, file_types=None, keyword=None, node_id=None, owner=None,
                 page_number=None, page_size=None, project_id=None, project_identifier=None, use_type=None):
        self.file_folder_path = file_folder_path  # type: str
        self.file_types = file_types  # type: str
        self.keyword = keyword  # type: str
        self.node_id = node_id  # type: long
        self.owner = owner  # 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
        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.file_folder_path is not None:
            result['FileFolderPath'] = self.file_folder_path
        if self.file_types is not None:
            result['FileTypes'] = self.file_types
        if self.keyword is not None:
            result['Keyword'] = self.keyword
        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('FileFolderPath') is not None:
            self.file_folder_path = m.get('FileFolderPath')
        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('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, 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.auto_parsing = auto_parsing  # type: bool
        self.biz_id = biz_id  # type: long
        self.business_id = business_id  # type: long
        self.commit_status = commit_status  # type: int
        self.connection_name = connection_name  # type: str
        self.content = content  # type: str
        self.create_time = create_time  # type: long
        self.create_user = create_user  # type: str
        self.current_version = current_version  # type: int
        self.file_description = file_description  # type: str
        self.file_folder_id = file_folder_id  # type: str
        self.file_id = file_id  # type: long
        self.file_name = file_name  # type: str
        self.file_type = file_type  # type: int
        self.is_max_compute = is_max_compute  # type: bool
        self.last_edit_time = last_edit_time  # type: long
        self.last_edit_user = last_edit_user  # type: str
        self.node_id = node_id  # type: long
        self.owner = owner  # type: str
        self.parent_id = parent_id  # type: long
        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.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('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):
        self.files = files  # type: list[ListFilesResponseBodyDataFiles]
        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.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):
        self.data = data  # type: ListFilesResponseBodyData
        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(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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.parent_folder_path = parent_folder_path  # type: str
        self.project_id = project_id  # type: long
        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):
        self.folder_id = folder_id  # type: str
        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):
        self.folders = folders  # type: list[ListFoldersResponseBodyDataFolders]
        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.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):
        self.data = data  # type: ListFoldersResponseBodyData
        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(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):
        self.node_name = node_name  # type: str
        self.outer_node_id = outer_node_id  # type: long
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.program_type = program_type  # type: str
        self.project_env = project_env  # type: str
        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):
        self.baseline_id = baseline_id  # type: long
        self.business_id = business_id  # type: long
        self.connection = connection  # type: str
        self.cron_express = cron_express  # type: str
        self.description = description  # type: str
        self.dqc_description = dqc_description  # type: str
        self.dqc_type = dqc_type  # type: str
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.owner_id = owner_id  # type: str
        self.param_values = param_values  # type: str
        self.priority = priority  # type: int
        self.program_type = program_type  # type: str
        self.project_id = project_id  # type: long
        self.repeat_interval = repeat_interval  # type: long
        self.repeatability = repeatability  # type: bool
        self.res_group_name = res_group_name  # type: str
        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):
        self.nodes = nodes  # type: list[ListInnerNodesResponseBodyPagingNodes]
        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.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):
        self.paging = paging  # type: ListInnerNodesResponseBodyPaging
        self.request_id = request_id  # type: str
        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):
        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(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):
        self.count = count  # type: int
        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):
        self.instance_counts = instance_counts  # type: list[ListInstanceAmountResponseBodyInstanceCounts]
        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):
        self.instance_id = instance_id  # type: long
        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):
        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.bizdate = bizdate  # type: long
        self.create_time = create_time  # type: long
        self.cyc_time = cyc_time  # type: long
        self.dag_id = dag_id  # type: long
        self.dag_type = dag_type  # type: str
        self.error_message = error_message  # type: str
        self.finish_time = finish_time  # type: long
        self.instance_history_id = instance_history_id  # 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.status = status  # type: str
        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):
        self.instances = instances  # type: list[ListInstanceHistoryResponseBodyInstances]
        self.request_id = request_id  # type: str
        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):
        self.begin_bizdate = begin_bizdate  # type: str
        self.biz_name = biz_name  # type: str
        self.bizdate = bizdate  # type: str
        self.dag_id = dag_id  # type: long
        self.end_bizdate = end_bizdate  # type: str
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.owner = owner  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.program_type = program_type  # type: str
        self.project_env = project_env  # type: str
        self.project_id = project_id  # type: long
        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):
        self.baseline_id = baseline_id  # 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.bizdate = bizdate  # type: long
        self.business_id = business_id  # type: long
        self.connection = connection  # type: str
        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.dqc_description = dqc_description  # type: str
        self.dqc_type = dqc_type  # type: int
        self.error_message = error_message  # 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.priority = priority  # type: int
        self.related_flow_id = related_flow_id  # type: long
        self.repeat_interval = repeat_interval  # type: long
        self.repeatability = repeatability  # type: bool
        self.status = status  # type: str
        self.task_rerun_time = task_rerun_time  # type: int
        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):
        self.instances = instances  # type: list[ListInstancesResponseBodyDataInstances]
        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.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):
        self.data = data  # type: ListInstancesResponseBodyData
        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(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 ListManualDagInstancesRequest(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(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):
        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(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):
        self.instances = instances  # type: list[ListManualDagInstancesResponseBodyInstances]
        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):
        self.collection_qualified_name = collection_qualified_name  # type: str
        self.entity_type = entity_type  # 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(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):
        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(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):
        self.data = data  # type: ListMetaCollectionEntitiesResponseBodyData
        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(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):
        self.administrator = administrator  # type: str
        self.collection_type = collection_type  # type: str
        self.creator = creator  # type: str
        self.follower = follower  # type: str
        self.keyword = keyword  # type: str
        self.next_token = next_token  # type: str
        self.order_by = order_by  # type: str
        self.page_size = page_size  # type: int
        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):
        self.collection_list = collection_list  # type: list[Collection]
        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):
        self.data = data  # type: ListMetaCollectionsResponseBodyData
        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(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):
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.page_num = page_num  # 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(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):
        self.create_time_stamp = create_time_stamp  # type: long
        self.location = location  # type: str
        self.modified_time_stamp = modified_time_stamp  # type: long
        self.name = name  # type: str
        self.owner_id = owner_id  # type: str
        self.type = type  # type: str
        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):
        self.db_list = db_list  # type: list[ListMetaDBResponseBodyDatabaseInfoDbList]
        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):
        self.database_info = database_info  # type: ListMetaDBResponseBodyDatabaseInfo
        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):
        self.migration_type = migration_type  # type: str
        self.owner = owner  # 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(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):
        self.create_time = create_time  # type: long
        self.create_user = create_user  # type: str
        self.create_user_name = create_user_name  # type: str
        self.description = description  # type: str
        self.download_url = download_url  # type: str
        self.id = id  # type: long
        self.message = message  # type: str
        self.migration_type = migration_type  # type: str
        self.name = name  # type: str
        self.package_type = package_type  # type: str
        self.project_id = project_id  # type: long
        self.status = status  # type: str
        self.tenant_id = tenant_id  # type: long
        self.update_time = update_time  # type: long
        self.update_user = update_user  # type: str
        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):
        self.migrations = migrations  # type: list[ListMigrationsResponseBodyDataMigrations]
        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.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):
        self.data = data  # type: ListMigrationsResponseBodyData
        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(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):
        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(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):
        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(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):
        self.data = data  # type: list[ListNodeInputOrOutputResponseBodyData]
        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(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):
        self.biz_name = biz_name  # type: str
        self.node_name = node_name  # type: str
        self.owner = owner  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.program_type = program_type  # type: str
        self.project_env = project_env  # type: str
        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, 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):
        self.baseline_id = baseline_id  # type: long
        self.business_id = business_id  # type: long
        self.connection = connection  # type: str
        self.cron_express = cron_express  # type: str
        self.description = description  # type: str
        self.dqc_description = dqc_description  # type: str
        self.dqc_type = dqc_type  # type: int
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.owner_id = owner_id  # type: str
        self.param_values = param_values  # type: str
        self.priority = priority  # type: int
        self.program_type = program_type  # type: str
        self.project_id = project_id  # type: long
        self.related_flow_id = related_flow_id  # type: long
        self.repeat_interval = repeat_interval  # type: long
        self.repeatability = repeatability  # type: bool
        self.res_group_name = res_group_name  # type: str
        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.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('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('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 ListNodesResponseBodyData(TeaModel):
    def __init__(self, nodes=None, page_number=None, page_size=None, total_count=None):
        self.nodes = nodes  # type: list[ListNodesResponseBodyDataNodes]
        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.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):
        self.data = data  # type: ListNodesResponseBodyData
        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(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):
        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
        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(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):
        self.data = data  # type: list[ListNodesByBaselineResponseBodyData]
        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(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):
        self.outputs = outputs  # type: str
        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):
        self.baseline_id = baseline_id  # type: long
        self.connection = connection  # type: str
        self.cron_express = cron_express  # type: str
        self.description = description  # type: str
        self.dqc_description = dqc_description  # type: str
        self.dqc_type = dqc_type  # type: int
        self.file_type = file_type  # type: str
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.owner_id = owner_id  # type: str
        self.param_values = param_values  # type: str
        self.priority = priority  # type: int
        self.program_type = program_type  # type: str
        self.project_id = project_id  # type: long
        self.related_flow_id = related_flow_id  # type: long
        self.repeat_interval = repeat_interval  # type: int
        self.repeatability = repeatability  # type: bool
        self.res_group_name = res_group_name  # type: str
        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):
        self.node_list = node_list  # type: list[ListNodesByOutputResponseBodyDataNodeList]
        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):
        self.data = data  # type: list[ListNodesByOutputResponseBodyData]
        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(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):
        self.end_time = end_time  # type: long
        self.engine_type = engine_type  # type: str
        self.flow_status = flow_status  # type: int
        self.max_compute_project_name = max_compute_project_name  # type: str
        self.order_type = order_type  # type: int
        self.page_num = page_num  # type: int
        self.page_size = page_size  # type: int
        self.query_type = query_type  # type: int
        self.start_time = start_time  # type: long
        self.table_name = table_name  # type: str
        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):
        self.actions = actions  # type: list[str]
        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):
        self.object_meta_list = object_meta_list  # type: list[ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContentProjectMetaObjectMetaList]
        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):
        self.apply_reason = apply_reason  # type: str
        self.order_type = order_type  # type: int
        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):
        self.apply_base_id = apply_base_id  # type: str
        self.apply_timestamp = apply_timestamp  # type: long
        self.approve_content = approve_content  # type: ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrderApproveContent
        self.flow_id = flow_id  # type: str
        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):
        self.apply_order = apply_order  # type: list[ListPermissionApplyOrdersResponseBodyApplyOrdersApplyOrder]
        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.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):
        self.apply_orders = apply_orders  # type: ListPermissionApplyOrdersResponseBodyApplyOrders
        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):
        self.project_env = project_env  # type: str
        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):
        self.count = count  # type: int
        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):
        self.program_type_and_counts = program_type_and_counts  # type: list[ListProgramTypeCountResponseBodyProgramTypeAndCounts]
        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):
        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):
        self.project_ids = project_ids  # type: list[long]
        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):
        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(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
        self.project_role_id = project_role_id  # type: int
        self.project_role_name = project_role_name  # type: str
        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):
        self.nick = nick  # type: str
        self.project_member_id = project_member_id  # type: str
        self.project_member_name = project_member_name  # type: str
        self.project_member_type = project_member_type  # type: str
        self.project_role_list = project_role_list  # type: list[ListProjectMembersResponseBodyDataProjectMemberListProjectRoleList]
        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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_member_list = project_member_list  # type: list[ListProjectMembersResponseBodyDataProjectMemberList]
        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):
        self.data = data  # type: ListProjectMembersResponseBodyData
        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):
        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
        self.project_role_id = project_role_id  # type: int
        self.project_role_name = project_role_name  # type: str
        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):
        self.project_role_list = project_role_list  # type: list[ListProjectRolesResponseBodyProjectRoleList]
        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):
        self.key = key  # type: str
        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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        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):
        self.key = key  # type: str
        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):
        self.disable_development = disable_development  # type: bool
        self.is_default = is_default  # type: int
        self.project_description = project_description  # type: str
        self.project_id = project_id  # type: long
        self.project_identifier = project_identifier  # type: str
        self.project_name = project_name  # type: str
        self.project_owner_base_id = project_owner_base_id  # type: str
        self.project_status = project_status  # type: int
        self.project_status_code = project_status_code  # type: str
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        self.table_privacy_mode = table_privacy_mode  # type: int
        self.tags = tags  # type: list[ListProjectsResponseBodyPageResultProjectListTags]
        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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_list = project_list  # type: list[ListProjectsResponseBodyPageResultProjectList]
        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):
        self.page_result = page_result  # type: ListProjectsResponseBodyPageResult
        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_name=None,
                 start_date=None):
        self.end_date = end_date  # type: str
        self.entity_id = entity_id  # type: int
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_name = project_name  # type: str
        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_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('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):
        self.biz_date = biz_date  # type: str
        self.discrete_property = discrete_property  # type: str
        self.single_check_result = single_check_result  # type: int
        self.threshold = threshold  # type: float
        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):
        self.actual_expression = actual_expression  # type: str
        self.begin_time = begin_time  # type: long
        self.biz_date = biz_date  # type: long
        self.block_type = block_type  # type: int
        self.check_result = check_result  # type: int
        self.check_result_status = check_result_status  # type: int
        self.checker_id = checker_id  # type: int
        self.checker_name = checker_name  # type: str
        self.checker_type = checker_type  # type: int
        self.comment = comment  # type: str
        self.critical_threshold = critical_threshold  # type: float
        self.date_type = date_type  # type: str
        self.discrete_check = discrete_check  # type: bool
        self.end_time = end_time  # type: long
        self.entity_id = entity_id  # type: int
        self.expect_value = expect_value  # type: float
        self.external_id = external_id  # type: str
        self.external_type = external_type  # type: str
        self.fixed_check = fixed_check  # type: bool
        self.id = id  # type: int
        self.is_prediction = is_prediction  # type: bool
        self.lower_value = lower_value  # type: float
        self.match_expression = match_expression  # type: str
        self.method_name = method_name  # type: str
        self.op = op  # type: str
        self.project_name = project_name  # type: str
        self.property = property  # type: str
        self.reference_value = reference_value  # type: list[ListQualityResultsByEntityResponseBodyDataRuleChecksReferenceValue]
        self.result_string = result_string  # type: str
        self.rule_id = rule_id  # type: int
        self.rule_name = rule_name  # type: str
        self.sample_value = sample_value  # type: list[ListQualityResultsByEntityResponseBodyDataRuleChecksSampleValue]
        self.table_name = table_name  # type: str
        self.task_id = task_id  # type: str
        self.template_id = template_id  # type: int
        self.template_name = template_name  # type: str
        self.time_cost = time_cost  # type: str
        self.trend = trend  # type: str
        self.upper_value = upper_value  # type: float
        self.warning_threshold = warning_threshold  # type: float
        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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.rule_checks = rule_checks  # type: list[ListQualityResultsByEntityResponseBodyDataRuleChecks]
        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):
        self.data = data  # type: ListQualityResultsByEntityResponseBodyData
        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(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_name=None, rule_id=None,
                 start_date=None):
        self.end_date = end_date  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_name = project_name  # type: str
        self.rule_id = rule_id  # type: int
        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_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('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):
        self.biz_date = biz_date  # type: str
        self.discrete_property = discrete_property  # type: str
        self.single_check_result = single_check_result  # type: int
        self.threshold = threshold  # type: float
        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):
        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(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, 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):
        self.actual_expression = actual_expression  # type: str
        self.begin_time = begin_time  # type: long
        self.biz_date = biz_date  # type: long
        self.block_type = block_type  # type: int
        self.check_result = check_result  # type: int
        self.check_result_status = check_result_status  # type: int
        self.checker_id = checker_id  # type: int
        self.checker_name = checker_name  # type: str
        self.checker_type = checker_type  # type: int
        self.comment = comment  # type: str
        self.critical_threshold = critical_threshold  # type: float
        self.date_type = date_type  # type: str
        self.discrete_check = discrete_check  # type: bool
        self.end_time = end_time  # type: long
        self.entity_id = entity_id  # type: int
        self.expect_value = expect_value  # type: float
        self.external_id = external_id  # type: str
        self.external_type = external_type  # type: str
        self.fixed_check = fixed_check  # type: bool
        self.id = id  # type: int
        self.is_prediction = is_prediction  # type: bool
        self.lower_value = lower_value  # type: float
        self.match_expression = match_expression  # type: str
        self.method_name = method_name  # type: str
        self.op = op  # type: str
        self.project_name = project_name  # type: str
        self.property = property  # type: str
        self.reference_value = reference_value  # type: list[ListQualityResultsByRuleResponseBodyDataRuleChecksReferenceValue]
        self.result_string = result_string  # type: str
        self.rule_id = rule_id  # type: int
        self.rule_name = rule_name  # type: str
        self.sample_value = sample_value  # type: list[ListQualityResultsByRuleResponseBodyDataRuleChecksSampleValue]
        self.table_name = table_name  # type: str
        self.task_id = task_id  # type: str
        self.template_id = template_id  # type: int
        self.template_name = template_name  # type: str
        self.time_cost = time_cost  # type: str
        self.trend = trend  # type: str
        self.upper_value = upper_value  # type: float
        self.warning_threshold = warning_threshold  # type: float
        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.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 = 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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.rule_checks = rule_checks  # type: list[ListQualityResultsByRuleResponseBodyDataRuleChecks]
        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):
        self.data = data  # type: ListQualityResultsByRuleResponseBodyData
        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(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_name=None):
        self.entity_id = entity_id  # type: long
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        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_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('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):
        self.block_type = block_type  # type: int
        self.checker_id = checker_id  # type: int
        self.comment = comment  # type: str
        self.critical_threshold = critical_threshold  # type: str
        self.entity_id = entity_id  # type: int
        self.expect_value = expect_value  # type: str
        self.fix_check = fix_check  # type: bool
        self.history_critical_threshold = history_critical_threshold  # type: str
        self.history_warning_threshold = history_warning_threshold  # type: str
        self.id = id  # type: int
        self.match_expression = match_expression  # type: str
        self.method_id = method_id  # type: int
        self.method_name = method_name  # type: str
        self.on_duty = on_duty  # type: str
        self.on_duty_account_name = on_duty_account_name  # type: str
        self.project_name = project_name  # type: str
        self.property = property  # type: str
        self.property_key = property_key  # type: str
        self.rule_checker_relation_id = rule_checker_relation_id  # type: int
        self.rule_name = rule_name  # type: str
        self.rule_type = rule_type  # type: int
        self.table_name = table_name  # type: str
        self.template_id = template_id  # type: int
        self.template_name = template_name  # type: str
        self.trend = trend  # type: str
        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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.rules = rules  # type: list[ListQualityRulesResponseBodyDataRules]
        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):
        self.data = data  # type: ListQualityRulesResponseBodyData
        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(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):
        self.datasource_name = datasource_name  # type: str
        self.page_number = page_number  # type: long
        self.page_size = page_size  # type: long
        self.project_id = project_id  # type: long
        self.ref_type = ref_type  # type: str
        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):
        self.di_destination_datasource = di_destination_datasource  # type: str
        self.di_source_datasource = di_source_datasource  # type: str
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        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):
        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):
        self.data = data  # type: ListRefDISyncTasksResponseBodyData
        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(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):
        self.alert_target = alert_target  # type: str
        self.founder = founder  # type: str
        self.node_id = node_id  # type: long
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.remind_types = remind_types  # type: str
        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):
        self.alert_methods = alert_methods  # type: list[str]
        self.alert_targets = alert_targets  # type: list[str]
        self.alert_unit = alert_unit  # type: str
        self.baseline_ids = baseline_ids  # type: list[long]
        self.biz_process_ids = biz_process_ids  # type: list[long]
        self.dnd_end = dnd_end  # type: str
        self.dnd_start = dnd_start  # type: str
        self.founder = founder  # type: str
        self.node_ids = node_ids  # type: list[long]
        self.project_ids = project_ids  # type: list[long]
        self.remind_id = remind_id  # type: long
        self.remind_name = remind_name  # type: str
        self.remind_type = remind_type  # type: str
        self.remind_unit = remind_unit  # type: str
        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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.reminds = reminds  # type: list[ListRemindsResponseBodyDataReminds]
        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):
        self.data = data  # type: ListRemindsResponseBodyData
        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(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):
        self.key = key  # type: str
        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):
        self.biz_ext_key = biz_ext_key  # type: str
        self.keyword = keyword  # type: str
        self.resource_group_type = resource_group_type  # type: int
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        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):
        self.biz_ext_key = biz_ext_key  # type: str
        self.keyword = keyword  # type: str
        self.resource_group_type = resource_group_type  # type: int
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        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):
        self.biz_ext_key = biz_ext_key  # type: str
        self.cluster = cluster  # type: str
        self.create_time = create_time  # type: str
        self.enable_kp = enable_kp  # type: bool
        self.id = id  # type: long
        self.identifier = identifier  # type: str
        self.is_default = is_default  # type: bool
        self.mode = mode  # type: str
        self.name = name  # type: str
        self.resource_group_type = resource_group_type  # type: str
        self.resource_manager_resource_group_id = resource_manager_resource_group_id  # type: str
        self.sequence = sequence  # type: int
        self.specs = specs  # type: dict[str, any]
        self.status = status  # type: int
        self.tags = tags  # type: list[ListResourceGroupsResponseBodyDataTags]
        self.tenant_id = tenant_id  # type: long
        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):
        self.data = data  # type: list[ListResourceGroupsResponseBodyData]
        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(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):
        self.begin_time = begin_time  # type: long
        self.end_time = end_time  # type: long
        self.shift_person_uid = shift_person_uid  # type: str
        self.shift_schedule_identifier = shift_schedule_identifier  # type: str
        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):
        self.begin_time = begin_time  # type: long
        self.end_time = end_time  # type: long
        self.shift_person_name = shift_person_name  # type: str
        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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.shift_persons = shift_persons  # type: list[ListShiftPersonnelsResponseBodyPagingShiftPersons]
        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):
        self.paging = paging  # type: ListShiftPersonnelsResponseBodyPaging
        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):
        self.owner = owner  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        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):
        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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.shift_schedules = shift_schedules  # type: list[ListShiftSchedulesResponseBodyPagingShiftSchedules]
        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):
        self.paging = paging  # type: ListShiftSchedulesResponseBodyPaging
        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):
        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):
        self.count = count  # type: int
        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):
        self.count = count  # type: int
        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):
        self.count = count  # type: int
        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):
        self.avg_trend = avg_trend  # type: list[ListSuccessInstanceAmountResponseBodyInstanceStatusTrendAvgTrend]
        self.today_trend = today_trend  # type: list[ListSuccessInstanceAmountResponseBodyInstanceStatusTrendTodayTrend]
        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):
        self.instance_status_trend = instance_status_trend  # type: ListSuccessInstanceAmountResponseBodyInstanceStatusTrend
        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):
        self.level_type = level_type  # type: int
        self.page_num = page_num  # 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(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):
        self.description = description  # type: str
        self.level_id = level_id  # type: long
        self.level_type = level_type  # type: int
        self.name = name  # type: str
        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):
        self.level_list = level_list  # type: list[ListTableLevelResponseBodyTableLevelInfoLevelList]
        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):
        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
        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):
        self.page_num = page_num  # type: int
        self.page_size = page_size  # type: int
        self.parent_id = parent_id  # type: long
        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):
        self.create_time_stamp = create_time_stamp  # type: long
        self.creator = creator  # type: str
        self.level = level  # type: int
        self.name = name  # type: str
        self.parent_id = parent_id  # type: long
        self.project_id = project_id  # type: long
        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):
        self.theme_list = theme_list  # type: list[ListTableThemeResponseBodyDataThemeList]
        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):
        self.data = data  # type: ListTableThemeResponseBodyData
        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(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):
        self.begin_time = begin_time  # type: str
        self.end_time = end_time  # type: str
        self.instance_id = instance_id  # type: long
        self.node_id = node_id  # type: long
        self.owner = owner  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.topic_statuses = topic_statuses  # type: str
        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):
        self.add_time = add_time  # type: long
        self.fix_time = fix_time  # type: long
        self.happen_time = happen_time  # type: long
        self.instance_id = instance_id  # type: long
        self.node_id = node_id  # type: long
        self.node_name = node_name  # type: str
        self.node_owner = node_owner  # type: str
        self.project_id = project_id  # type: long
        self.topic_id = topic_id  # type: long
        self.topic_name = topic_name  # type: str
        self.topic_status = topic_status  # type: str
        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):
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.topics = topics  # type: list[ListTopicsResponseBodyDataTopics]
        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):
        self.data = data  # type: ListTopicsResponseBodyData
        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(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 OfflineNodeRequest(TeaModel):
    def __init__(self, node_id=None, project_id=None):
        self.node_id = node_id  # type: long
        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):
        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):
        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(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):
        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(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):
        self.async_process_id = async_process_id  # type: long
        self.project_id = project_id  # type: long
        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):
        self.message = message  # type: str
        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):
        self.data = data  # type: QueryDISyncTaskConfigProcessResultResponseBodyData
        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(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 RemoveProjectMemberFromRoleRequest(TeaModel):
    def __init__(self, project_id=None, role_code=None, user_id=None):
        self.project_id = project_id  # type: long
        self.role_code = role_code  # type: str
        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):
        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):
        self.instance_id = instance_id  # type: long
        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):
        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(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):
        self.instance_id = instance_id  # type: long
        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):
        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(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):
        self.columns = columns  # type: str
        self.max_compute_project_name = max_compute_project_name  # type: str
        self.revoke_user_id = revoke_user_id  # type: str
        self.revoke_user_name = revoke_user_name  # type: str
        self.table_name = table_name  # type: str
        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
        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):
        self.actions = actions  # type: str
        self.max_compute_project_name = max_compute_project_name  # type: str
        self.revoke_user_id = revoke_user_id  # type: str
        self.revoke_user_name = revoke_user_name  # type: str
        self.table_name = table_name  # type: str
        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):
        self.request_id = request_id  # type: str
        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):
        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
        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):
        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(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, exclude_node_ids=None, flow_name=None,
                 include_node_ids=None, node_parameters=None, project_env=None, project_id=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_id = project_id  # type: long
        self.project_name = project_name  # 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.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
        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('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 RunManualDagNodesResponseBody(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(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):
        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(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):
        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(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):
        self.app_id = app_id  # type: long
        self.biz_date = biz_date  # type: long
        self.cycle_time = cycle_time  # type: long
        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):
        self.request_id = request_id  # type: str
        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 ScanSensitiveDataRequest(TeaModel):
    def __init__(self, data=None):
        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):
        self.request_id = request_id  # type: str
        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):
        self.app_guid = app_guid  # type: str
        self.cluster_id = cluster_id  # type: str
        self.data_source_type = data_source_type  # type: str
        self.entity_type = entity_type  # type: int
        self.keyword = keyword  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        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):
        self.cluster_id = cluster_id  # type: str
        self.database_name = database_name  # type: str
        self.entity_type = entity_type  # type: int
        self.env_type = env_type  # type: int
        self.owner_id = owner_id  # type: str
        self.project_id = project_id  # type: long
        self.project_name = project_name  # type: str
        self.schema = schema  # type: str
        self.table_guid = table_guid  # type: str
        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):
        self.data_entity_list = data_entity_list  # type: list[SearchMetaTablesResponseBodyDataDataEntityList]
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        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):
        self.data = data  # type: SearchMetaTablesResponseBodyData
        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(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):
        self.datasource_name = datasource_name  # type: str
        self.env_type = env_type  # type: str
        self.project_id = project_id  # type: long
        self.project_permissions = project_permissions  # type: str
        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):
        self.message = message  # type: str
        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):
        self.data = data  # type: SetDataSourceShareResponseBodyData
        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(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 SetSuccessInstanceRequest(TeaModel):
    def __init__(self, instance_id=None, project_env=None):
        self.instance_id = instance_id  # type: long
        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):
        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(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 StartDISyncInstanceRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, start_param=None, task_type=None):
        self.file_id = file_id  # type: long
        self.project_id = project_id  # type: long
        self.start_param = start_param  # type: str
        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
        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):
        self.data = data  # type: StartDISyncInstanceResponseBodyData
        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(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):
        self.migration_id = migration_id  # type: long
        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):
        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(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 StopDISyncInstanceRequest(TeaModel):
    def __init__(self, file_id=None, project_id=None, task_type=None):
        self.file_id = file_id  # type: long
        self.project_id = project_id  # type: long
        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
        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):
        self.data = data  # type: StopDISyncInstanceResponseBodyData
        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(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):
        self.instance_id = instance_id  # type: long
        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):
        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(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 SubmitFileRequest(TeaModel):
    def __init__(self, comment=None, file_id=None, project_id=None, project_identifier=None,
                 skip_all_deploy_file_extensions=None):
        self.comment = comment  # type: str
        self.file_id = file_id  # type: long
        self.project_id = project_id  # type: long
        self.project_identifier = project_identifier  # type: str
        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):
        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(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):
        self.instance_id = instance_id  # type: long
        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):
        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(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):
        self.file_id = file_id  # type: long
        self.project_id = project_id  # type: long
        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
        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):
        self.data = data  # type: TerminateDISyncInstanceResponseBodyData
        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(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):
        self.param_key = param_key  # type: str
        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):
        self.param_key = param_key  # type: str
        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):
        self.param_key = param_key  # type: str
        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):
        self.param_key = param_key  # type: str
        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):
        # API Id
        self.api_id = api_id  # type: long
        self.body_content = body_content  # type: str
        self.body_params = body_params  # type: list[TestDataServiceApiRequestBodyParams]
        self.head_params = head_params  # type: list[TestDataServiceApiRequestHeadParams]
        self.path_params = path_params  # type: list[TestDataServiceApiRequestPathParams]
        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):
        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):
        self.data = data  # type: TestDataServiceApiResponseBodyData
        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):
        self.datasource_name = datasource_name  # type: str
        self.env_type = env_type  # type: str
        self.project_id = project_id  # type: long
        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):
        self.connect_message = connect_message  # type: str
        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):
        self.request_id = request_id  # type: str
        self.success = success  # type: bool
        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):
        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):
        self.business_date = business_date  # 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.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):
        self.consume_time_rank = consume_time_rank  # type: list[TopTenElapsedTimeInstanceResponseBodyInstanceConsumeTimeRankConsumeTimeRank]
        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):
        self.instance_consume_time_rank = instance_consume_time_rank  # type: TopTenElapsedTimeInstanceResponseBodyInstanceConsumeTimeRank
        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):
        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):
        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.program_type = program_type  # type: int
        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):
        self.error_rank = error_rank  # type: list[TopTenErrorTimesInstanceResponseBodyInstanceErrorRankErrorRank]
        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):
        self.instance_error_rank = instance_error_rank  # type: TopTenErrorTimesInstanceResponseBodyInstanceErrorRank
        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 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, overtime_settings=None, owner=None, priority=None,
                 project_id=None, remove_task_ids=None, task_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.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_task_ids = remove_task_ids  # type: str
        self.task_ids = task_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
        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_task_ids is not None:
            result['RemoveTaskIds'] = self.remove_task_ids
        if self.task_ids is not None:
            result['TaskIds'] = self.task_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')
        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('RemoveTaskIds') is not None:
            self.remove_task_ids = m.get('RemoveTaskIds')
        if m.get('TaskIds') is not None:
            self.task_ids = m.get('TaskIds')
        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, overtime_settings_shrink=None,
                 owner=None, priority=None, project_id=None, remove_task_ids=None, task_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.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_task_ids = remove_task_ids  # type: str
        self.task_ids = task_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.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_task_ids is not None:
            result['RemoveTaskIds'] = self.remove_task_ids
        if self.task_ids is not None:
            result['TaskIds'] = self.task_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('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('RemoveTaskIds') is not None:
            self.remove_task_ids = m.get('RemoveTaskIds')
        if m.get('TaskIds') is not None:
            self.task_ids = m.get('TaskIds')
        return self


class UpdateBaselineResponseBody(TeaModel):
    def __init__(self, data=None, dynamic_error_code=None, dynamic_error_message=None, error_code=None,
                 error_message=None, http_status_code=None, request_id=None, success=None):
        self.data = data  # type: bool
        self.dynamic_error_code = dynamic_error_code  # type: str
        self.dynamic_error_message = dynamic_error_message  # type: str
        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.dynamic_error_code is not None:
            result['DynamicErrorCode'] = self.dynamic_error_code
        if self.dynamic_error_message is not None:
            result['DynamicErrorMessage'] = self.dynamic_error_message
        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('DynamicErrorCode') is not None:
            self.dynamic_error_code = m.get('DynamicErrorCode')
        if m.get('DynamicErrorMessage') is not None:
            self.dynamic_error_message = m.get('DynamicErrorMessage')
        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):
        self.business_id = business_id  # type: long
        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

    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):
        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(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):
        self.connection_id = connection_id  # type: long
        self.content = content  # type: str
        self.description = description  # type: str
        self.env_type = env_type  # type: int
        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):
        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(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 UpdateDIProjectConfigRequest(TeaModel):
    def __init__(self, destination_type=None, project_config=None, project_id=None, source_type=None):
        self.destination_type = destination_type  # type: str
        self.project_config = project_config  # type: str
        self.project_id = project_id  # type: long
        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):
        self.data = data  # type: UpdateDIProjectConfigResponseBodyData
        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(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):
        self.file_id = file_id  # type: long
        self.project_id = project_id  # type: long
        self.task_content = task_content  # 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(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):
        self.message = message  # type: str
        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):
        self.data = data  # type: UpdateDISyncTaskResponseBodyData
        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(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, response_content_type=None, script_details=None, tenant_id=None,
                 timeout=None, visible_range=None, wizard_details=None):
        self.api_description = api_description  # type: str
        self.api_id = api_id  # type: long
        self.api_path = api_path  # type: str
        self.project_id = project_id  # type: long
        self.protocols = protocols  # type: str
        self.registration_details = registration_details  # type: str
        self.request_method = request_method  # type: int
        self.response_content_type = response_content_type  # type: int
        self.script_details = script_details  # type: str
        self.tenant_id = tenant_id  # type: long
        self.timeout = timeout  # type: int
        self.visible_range = visible_range  # type: int
        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.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('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):
        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(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):
        self.content = content  # type: str
        self.data_source_id = data_source_id  # type: long
        self.description = description  # type: str
        self.env_type = env_type  # type: int
        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):
        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(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, 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):
        self.advanced_settings = advanced_settings  # type: str
        self.auto_parsing = auto_parsing  # type: bool
        self.auto_rerun_interval_millis = auto_rerun_interval_millis  # type: int
        self.auto_rerun_times = auto_rerun_times  # type: int
        self.connection_name = connection_name  # type: str
        self.content = content  # type: str
        self.cron_express = cron_express  # type: str
        self.cycle_type = cycle_type  # type: str
        self.dependent_node_id_list = dependent_node_id_list  # type: str
        self.dependent_type = dependent_type  # type: str
        self.end_effect_date = end_effect_date  # type: long
        self.file_description = file_description  # type: str
        self.file_folder_path = file_folder_path  # type: str
        self.file_id = file_id  # type: long
        self.file_name = file_name  # type: str
        self.input_list = input_list  # type: str
        self.input_parameters = input_parameters  # type: str
        self.output_list = output_list  # type: str
        self.output_parameters = output_parameters  # type: str
        self.owner = owner  # type: str
        self.para_value = para_value  # type: str
        self.project_id = project_id  # type: long
        self.project_identifier = project_identifier  # type: str
        self.rerun_mode = rerun_mode  # type: str
        self.resource_group_identifier = resource_group_identifier  # type: str
        self.scheduler_type = scheduler_type  # type: str
        self.start_effect_date = start_effect_date  # type: long
        self.start_immediately = start_immediately  # type: bool
        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.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('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):
        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(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):
        self.folder_id = folder_id  # type: str
        self.folder_name = folder_name  # type: str
        self.project_id = project_id  # type: long
        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):
        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(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):
        self.check_result = check_result  # type: str
        self.check_result_tip = check_result_tip  # type: str
        self.extension_code = extension_code  # type: str
        # 扩展点消息UUID
        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):
        self.category_id = category_id  # type: long
        self.comment = comment  # type: str
        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):
        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(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):
        self.comment = comment  # type: str
        self.name = name  # type: str
        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):
        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(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):
        self.added_labels = added_labels  # type: str
        self.caption = caption  # type: str
        self.category_id = category_id  # type: long
        self.env_type = env_type  # type: int
        self.new_owner_id = new_owner_id  # type: str
        self.project_id = project_id  # type: long
        self.removed_labels = removed_labels  # type: str
        self.schema = schema  # type: str
        self.table_guid = table_guid  # type: str
        self.table_name = table_name  # type: str
        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):
        self.request_id = request_id  # type: str
        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):
        self.content = content  # type: str
        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):
        self.request_id = request_id  # type: str
        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):
        self.node_id = node_id  # type: long
        self.project_env = project_env  # type: str
        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):
        self.request_id = request_id  # type: str
        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):
        self.node_id = node_id  # type: long
        self.project_env = project_env  # type: str
        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):
        self.request_id = request_id  # type: str
        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_name=None):
        self.alarm_mode = alarm_mode  # type: int
        self.follower = follower  # type: str
        self.follower_id = follower_id  # type: long
        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_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('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):
        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(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_name=None, property=None, property_type=None, rule_name=None, rule_type=None, template_id=None,
                 trend=None, warning_threshold=None, where_condition=None):
        self.block_type = block_type  # type: int
        self.checker = checker  # type: int
        self.comment = comment  # type: str
        self.critical_threshold = critical_threshold  # type: str
        self.entity_id = entity_id  # type: long
        self.expect_value = expect_value  # type: str
        self.id = id  # type: long
        self.method_name = method_name  # type: str
        self.open_switch = open_switch  # type: bool
        self.operator = operator  # type: str
        self.predict_type = predict_type  # type: int
        self.project_name = project_name  # type: str
        self.property = property  # type: str
        self.property_type = property_type  # type: str
        self.rule_name = rule_name  # type: str
        self.rule_type = rule_type  # type: int
        self.template_id = template_id  # type: int
        self.trend = trend  # type: str
        self.warning_threshold = warning_threshold  # type: str
        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_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('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):
        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(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):
        self.alert_interval = alert_interval  # type: int
        self.alert_methods = alert_methods  # type: str
        self.alert_targets = alert_targets  # type: str
        self.alert_unit = alert_unit  # type: str
        self.baseline_ids = baseline_ids  # type: str
        self.biz_process_ids = biz_process_ids  # type: str
        self.detail = detail  # type: str
        self.dnd_end = dnd_end  # type: str
        self.max_alert_times = max_alert_times  # type: int
        self.node_ids = node_ids  # type: str
        self.project_id = project_id  # type: long
        self.remind_id = remind_id  # type: long
        self.remind_name = remind_name  # type: str
        self.remind_type = remind_type  # type: str
        self.remind_unit = remind_unit  # type: str
        self.robot_urls = robot_urls  # type: str
        self.use_flag = use_flag  # type: bool
        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):
        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(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):
        self.column_name = column_name  # type: str
        self.column_name_cn = column_name_cn  # type: str
        self.column_type = column_type  # type: str
        self.comment = comment  # type: str
        self.is_partition_col = is_partition_col  # type: bool
        self.length = length  # type: int
        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):
        self.theme_id = theme_id  # type: long
        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):
        self.app_guid = app_guid  # type: str
        self.category_id = category_id  # type: long
        self.columns = columns  # type: list[UpdateTableRequestColumns]
        self.comment = comment  # type: str
        self.create_if_not_exists = create_if_not_exists  # type: bool
        self.endpoint = endpoint  # type: str
        self.env_type = env_type  # type: int
        self.external_table_type = external_table_type  # type: str
        self.has_part = has_part  # type: int
        self.is_view = is_view  # type: int
        self.life_cycle = life_cycle  # type: int
        self.location = location  # type: str
        self.logical_level_id = logical_level_id  # type: long
        self.owner_id = owner_id  # type: str
        self.physics_level_id = physics_level_id  # type: long
        self.project_id = project_id  # type: long
        self.schema = schema  # type: str
        self.table_name = table_name  # type: str
        self.themes = themes  # type: list[UpdateTableRequestThemes]
        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
        self.next_task_id = next_task_id  # type: str
        self.status = status  # type: str
        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):
        self.request_id = request_id  # type: str
        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):
        self.column_name = column_name  # type: str
        self.column_name_cn = column_name_cn  # type: str
        self.column_type = column_type  # type: str
        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]
        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):
        self.content = content  # type: str
        self.next_task_id = next_task_id  # type: str
        self.status = status  # type: str
        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):
        self.request_id = request_id  # type: str
        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):
        self.description = description  # type: str
        self.level_id = level_id  # type: long
        self.level_type = level_type  # type: int
        self.name = name  # type: str
        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):
        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
        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):
        self.first_level_theme_id = first_level_theme_id  # type: long
        self.level_id = level_id  # type: long
        self.level_type = level_type  # type: int
        self.second_level_theme_id = second_level_theme_id  # type: long
        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):
        self.request_id = request_id  # type: str
        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):
        self.name = name  # type: str
        self.project_id = project_id  # type: long
        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):
        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
        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):
        self.class_name = class_name  # type: str
        self.cmd_description = cmd_description  # type: str
        self.example = example  # type: str
        self.file_folder_path = file_folder_path  # type: str
        self.file_id = file_id  # type: str
        self.function_type = function_type  # type: str
        self.parameter_description = parameter_description  # type: str
        self.project_id = project_id  # type: long
        self.project_identifier = project_identifier  # type: str
        self.resources = resources  # type: str
        self.return_value = return_value  # type: str
        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):
        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(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):
        self.check_result = check_result  # type: str
        self.check_result_tip = check_result_tip  # 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(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):
        # Id of the request
        self.request_id = request_id  # type: str
        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


