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


class FeatureViewConfigValue(TeaModel):
    def __init__(self, partitions=None, event_time=None, equal=None):
        self.partitions = partitions  # type: dict[str, FeatureViewConfigValuePartitionsValue]
        self.event_time = event_time  # type: str
        self.equal = equal  # type: bool

    def validate(self):
        if self.partitions:
            for v in self.partitions.values():
                if v:
                    v.validate()

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

        result = dict()
        result['Partitions'] = {}
        if self.partitions is not None:
            for k, v in self.partitions.items():
                result['Partitions'][k] = v.to_map()
        if self.event_time is not None:
            result['EventTime'] = self.event_time
        if self.equal is not None:
            result['Equal'] = self.equal
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.partitions = {}
        if m.get('Partitions') is not None:
            for k, v in m.get('Partitions').items():
                temp_model = FeatureViewConfigValuePartitionsValue()
                self.partitions[k] = temp_model.from_map(v)
        if m.get('EventTime') is not None:
            self.event_time = m.get('EventTime')
        if m.get('Equal') is not None:
            self.equal = m.get('Equal')
        return self


class FeatureViewConfigValuePartitionsValue(TeaModel):
    def __init__(self, value=None, values=None, start_value=None, end_value=None):
        self.value = value  # type: str
        self.values = values  # type: list[str]
        self.start_value = start_value  # type: str
        self.end_value = end_value  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.value is not None:
            result['Value'] = self.value
        if self.values is not None:
            result['Values'] = self.values
        if self.start_value is not None:
            result['StartValue'] = self.start_value
        if self.end_value is not None:
            result['EndValue'] = self.end_value
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Value') is not None:
            self.value = m.get('Value')
        if m.get('Values') is not None:
            self.values = m.get('Values')
        if m.get('StartValue') is not None:
            self.start_value = m.get('StartValue')
        if m.get('EndValue') is not None:
            self.end_value = m.get('EndValue')
        return self


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

    def validate(self):
        pass

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

        result = dict()
        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('Version') is not None:
            self.version = m.get('Version')
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(ChangeProjectFeatureEntityHotIdVersionResponseBody, 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 ChangeProjectFeatureEntityHotIdVersionResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: ChangeProjectFeatureEntityHotIdVersionResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ChangeProjectFeatureEntityHotIdVersionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CheckInstanceDatasourceRequest(TeaModel):
    def __init__(self, config=None, type=None, uri=None):
        self.config = config  # type: str
        self.type = type  # type: str
        self.uri = uri  # type: str

    def validate(self):
        pass

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

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

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


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(CheckInstanceDatasourceResponseBody, 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 is not None:
            result['Status'] = self.status
        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('Status') is not None:
            self.status = m.get('Status')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = CheckInstanceDatasourceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateDatasourceRequest(TeaModel):
    def __init__(self, config=None, name=None, type=None, uri=None, workspace_id=None):
        self.config = config  # type: str
        self.name = name  # type: str
        self.type = type  # type: str
        self.uri = uri  # type: str
        self.workspace_id = workspace_id  # 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.config is not None:
            result['Config'] = self.config
        if self.name is not None:
            result['Name'] = self.name
        if self.type is not None:
            result['Type'] = self.type
        if self.uri is not None:
            result['Uri'] = self.uri
        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('Config') is not None:
            self.config = m.get('Config')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        if m.get('Uri') is not None:
            self.uri = m.get('Uri')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


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

    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.datasource_id is not None:
            result['DatasourceId'] = self.datasource_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('DatasourceId') is not None:
            self.datasource_id = m.get('DatasourceId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        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):
        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 CreateFeatureEntityRequest(TeaModel):
    def __init__(self, join_id=None, name=None, project_id=None):
        self.join_id = join_id  # type: str
        self.name = name  # type: str
        self.project_id = project_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.join_id is not None:
            result['JoinId'] = self.join_id
        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('JoinId') is not None:
            self.join_id = m.get('JoinId')
        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 CreateFeatureEntityResponseBody(TeaModel):
    def __init__(self, feature_entity_id=None, request_id=None):
        self.feature_entity_id = feature_entity_id  # type: str
        self.request_id = request_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.feature_entity_id is not None:
            result['FeatureEntityId'] = self.feature_entity_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('FeatureEntityId') is not None:
            self.feature_entity_id = m.get('FeatureEntityId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = CreateFeatureEntityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateFeatureViewRequestFields(TeaModel):
    def __init__(self, attributes=None, name=None, type=None):
        self.attributes = attributes  # type: list[str]
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.attributes is not None:
            result['Attributes'] = self.attributes
        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('Attributes') is not None:
            self.attributes = m.get('Attributes')
        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 CreateFeatureViewRequest(TeaModel):
    def __init__(self, config=None, feature_entity_id=None, fields=None, name=None, project_id=None,
                 register_datasource_id=None, register_table=None, sync_online_table=None, ttl=None, tags=None, type=None,
                 write_method=None, write_to_feature_db=None):
        self.config = config  # type: str
        self.feature_entity_id = feature_entity_id  # type: str
        self.fields = fields  # type: list[CreateFeatureViewRequestFields]
        self.name = name  # type: str
        self.project_id = project_id  # type: str
        self.register_datasource_id = register_datasource_id  # type: str
        self.register_table = register_table  # type: str
        self.sync_online_table = sync_online_table  # type: bool
        self.ttl = ttl  # type: int
        self.tags = tags  # type: list[str]
        self.type = type  # type: str
        self.write_method = write_method  # type: str
        self.write_to_feature_db = write_to_feature_db  # type: bool

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

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

        result = dict()
        if self.config is not None:
            result['Config'] = self.config
        if self.feature_entity_id is not None:
            result['FeatureEntityId'] = self.feature_entity_id
        result['Fields'] = []
        if self.fields is not None:
            for k in self.fields:
                result['Fields'].append(k.to_map() if k else None)
        if self.name is not None:
            result['Name'] = self.name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.register_datasource_id is not None:
            result['RegisterDatasourceId'] = self.register_datasource_id
        if self.register_table is not None:
            result['RegisterTable'] = self.register_table
        if self.sync_online_table is not None:
            result['SyncOnlineTable'] = self.sync_online_table
        if self.ttl is not None:
            result['TTL'] = self.ttl
        if self.tags is not None:
            result['Tags'] = self.tags
        if self.type is not None:
            result['Type'] = self.type
        if self.write_method is not None:
            result['WriteMethod'] = self.write_method
        if self.write_to_feature_db is not None:
            result['WriteToFeatureDB'] = self.write_to_feature_db
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Config') is not None:
            self.config = m.get('Config')
        if m.get('FeatureEntityId') is not None:
            self.feature_entity_id = m.get('FeatureEntityId')
        self.fields = []
        if m.get('Fields') is not None:
            for k in m.get('Fields'):
                temp_model = CreateFeatureViewRequestFields()
                self.fields.append(temp_model.from_map(k))
        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('RegisterDatasourceId') is not None:
            self.register_datasource_id = m.get('RegisterDatasourceId')
        if m.get('RegisterTable') is not None:
            self.register_table = m.get('RegisterTable')
        if m.get('SyncOnlineTable') is not None:
            self.sync_online_table = m.get('SyncOnlineTable')
        if m.get('TTL') is not None:
            self.ttl = m.get('TTL')
        if m.get('Tags') is not None:
            self.tags = m.get('Tags')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        if m.get('WriteMethod') is not None:
            self.write_method = m.get('WriteMethod')
        if m.get('WriteToFeatureDB') is not None:
            self.write_to_feature_db = m.get('WriteToFeatureDB')
        return self


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

    def validate(self):
        pass

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

        result = dict()
        if self.feature_view_id is not None:
            result['FeatureViewId'] = self.feature_view_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('FeatureViewId') is not None:
            self.feature_view_id = m.get('FeatureViewId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = CreateFeatureViewResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

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

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

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


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

    def validate(self):
        pass

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

        result = dict()
        if self.code is not None:
            result['Code'] = self.code
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_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('Code') is not None:
            self.code = m.get('Code')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = CreateInstanceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateLabelTableRequestFields(TeaModel):
    def __init__(self, attributes=None, name=None, type=None):
        self.attributes = attributes  # type: list[str]
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.attributes is not None:
            result['Attributes'] = self.attributes
        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('Attributes') is not None:
            self.attributes = m.get('Attributes')
        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 CreateLabelTableRequest(TeaModel):
    def __init__(self, datasource_id=None, fields=None, name=None, project_id=None):
        self.datasource_id = datasource_id  # type: str
        self.fields = fields  # type: list[CreateLabelTableRequestFields]
        self.name = name  # type: str
        self.project_id = project_id  # type: str

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

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

        result = dict()
        if self.datasource_id is not None:
            result['DatasourceId'] = self.datasource_id
        result['Fields'] = []
        if self.fields is not None:
            for k in self.fields:
                result['Fields'].append(k.to_map() if k else None)
        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('DatasourceId') is not None:
            self.datasource_id = m.get('DatasourceId')
        self.fields = []
        if m.get('Fields') is not None:
            for k in m.get('Fields'):
                temp_model = CreateLabelTableRequestFields()
                self.fields.append(temp_model.from_map(k))
        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 CreateLabelTableResponseBody(TeaModel):
    def __init__(self, label_table_id=None, request_id=None):
        self.label_table_id = label_table_id  # type: str
        self.request_id = request_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.label_table_id is not None:
            result['LabelTableId'] = self.label_table_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('LabelTableId') is not None:
            self.label_table_id = m.get('LabelTableId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = CreateLabelTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateModelFeatureRequestFeatures(TeaModel):
    def __init__(self, alias_name=None, feature_view_id=None, name=None, type=None):
        self.alias_name = alias_name  # type: str
        self.feature_view_id = feature_view_id  # type: str
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.alias_name is not None:
            result['AliasName'] = self.alias_name
        if self.feature_view_id is not None:
            result['FeatureViewId'] = self.feature_view_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('AliasName') is not None:
            self.alias_name = m.get('AliasName')
        if m.get('FeatureViewId') is not None:
            self.feature_view_id = m.get('FeatureViewId')
        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 CreateModelFeatureRequest(TeaModel):
    def __init__(self, features=None, label_table_id=None, name=None, project_id=None,
                 sequence_feature_view_ids=None):
        self.features = features  # type: list[CreateModelFeatureRequestFeatures]
        self.label_table_id = label_table_id  # type: str
        self.name = name  # type: str
        self.project_id = project_id  # type: str
        self.sequence_feature_view_ids = sequence_feature_view_ids  # type: list[str]

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

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

        result = dict()
        result['Features'] = []
        if self.features is not None:
            for k in self.features:
                result['Features'].append(k.to_map() if k else None)
        if self.label_table_id is not None:
            result['LabelTableId'] = self.label_table_id
        if self.name is not None:
            result['Name'] = self.name
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.sequence_feature_view_ids is not None:
            result['SequenceFeatureViewIds'] = self.sequence_feature_view_ids
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.features = []
        if m.get('Features') is not None:
            for k in m.get('Features'):
                temp_model = CreateModelFeatureRequestFeatures()
                self.features.append(temp_model.from_map(k))
        if m.get('LabelTableId') is not None:
            self.label_table_id = m.get('LabelTableId')
        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('SequenceFeatureViewIds') is not None:
            self.sequence_feature_view_ids = m.get('SequenceFeatureViewIds')
        return self


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

    def validate(self):
        pass

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

        result = dict()
        if self.model_feature_id is not None:
            result['ModelFeatureId'] = self.model_feature_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('ModelFeatureId') is not None:
            self.model_feature_id = m.get('ModelFeatureId')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = CreateModelFeatureResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

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

        result = dict()
        if self.training_set_fgtable_name is not None:
            result['TrainingSetFGTableName'] = self.training_set_fgtable_name
        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('TrainingSetFGTableName') is not None:
            self.training_set_fgtable_name = m.get('TrainingSetFGTableName')
        if m.get('requestId') is not None:
            self.request_id = m.get('requestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = CreateModelFeatureTrainingSetFGTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateProjectRequest(TeaModel):
    def __init__(self, description=None, name=None, offline_datasource_id=None, offline_life_cycle=None,
                 online_datasource_id=None, workspace_id=None):
        self.description = description  # type: str
        self.name = name  # type: str
        self.offline_datasource_id = offline_datasource_id  # type: str
        self.offline_life_cycle = offline_life_cycle  # type: int
        self.online_datasource_id = online_datasource_id  # type: str
        self.workspace_id = workspace_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        if self.name is not None:
            result['Name'] = self.name
        if self.offline_datasource_id is not None:
            result['OfflineDatasourceId'] = self.offline_datasource_id
        if self.offline_life_cycle is not None:
            result['OfflineLifeCycle'] = self.offline_life_cycle
        if self.online_datasource_id is not None:
            result['OnlineDatasourceId'] = self.online_datasource_id
        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('Description') is not None:
            self.description = m.get('Description')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('OfflineDatasourceId') is not None:
            self.offline_datasource_id = m.get('OfflineDatasourceId')
        if m.get('OfflineLifeCycle') is not None:
            self.offline_life_cycle = m.get('OfflineLifeCycle')
        if m.get('OnlineDatasourceId') is not None:
            self.online_datasource_id = m.get('OnlineDatasourceId')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


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

    def validate(self):
        pass

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


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = CreateProjectResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

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

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

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


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

    def validate(self):
        pass

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

        result = dict()
        if self.code is not None:
            result['Code'] = self.code
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.role_name is not None:
            result['RoleName'] = self.role_name
        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('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('RoleName') is not None:
            self.role_name = m.get('RoleName')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = CreateServiceIdentityRoleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    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.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 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):
        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 DeleteFeatureEntityResponseBody(TeaModel):
    def __init__(self, request_id=None):
        self.request_id = request_id  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteFeatureEntityResponseBody, 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 DeleteFeatureEntityResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteFeatureEntityResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = DeleteFeatureEntityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteFeatureViewResponseBody, 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 DeleteFeatureViewResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteFeatureViewResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = DeleteFeatureViewResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteLabelTableResponseBody, 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 DeleteLabelTableResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteLabelTableResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = DeleteLabelTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteModelFeatureResponseBody, 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 DeleteModelFeatureResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteModelFeatureResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = DeleteModelFeatureResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(DeleteProjectResponseBody, 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 DeleteProjectResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: DeleteProjectResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = DeleteProjectResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ExportModelFeatureTrainingSetFGTableRequestTrainingSetFgConfig(TeaModel):
    def __init__(self, fg_json_name=None, jar_name=None, partitions=None):
        self.fg_json_name = fg_json_name  # type: str
        self.jar_name = jar_name  # type: str
        self.partitions = partitions  # type: dict[str, dict]

    def validate(self):
        pass

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

        result = dict()
        if self.fg_json_name is not None:
            result['FgJsonName'] = self.fg_json_name
        if self.jar_name is not None:
            result['JarName'] = self.jar_name
        if self.partitions is not None:
            result['Partitions'] = self.partitions
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FgJsonName') is not None:
            self.fg_json_name = m.get('FgJsonName')
        if m.get('JarName') is not None:
            self.jar_name = m.get('JarName')
        if m.get('Partitions') is not None:
            self.partitions = m.get('Partitions')
        return self


class ExportModelFeatureTrainingSetFGTableRequest(TeaModel):
    def __init__(self, training_set_fg_config=None):
        self.training_set_fg_config = training_set_fg_config  # type: ExportModelFeatureTrainingSetFGTableRequestTrainingSetFgConfig

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

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

        result = dict()
        if self.training_set_fg_config is not None:
            result['TrainingSetFgConfig'] = self.training_set_fg_config.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('TrainingSetFgConfig') is not None:
            temp_model = ExportModelFeatureTrainingSetFGTableRequestTrainingSetFgConfig()
            self.training_set_fg_config = temp_model.from_map(m['TrainingSetFgConfig'])
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(ExportModelFeatureTrainingSetFGTableResponseBody, 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.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('TaskId') is not None:
            self.task_id = m.get('TaskId')
        if m.get('requestId') is not None:
            self.request_id = m.get('requestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ExportModelFeatureTrainingSetFGTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ExportModelFeatureTrainingSetTableRequestLabelInputConfig(TeaModel):
    def __init__(self, event_time=None, partitions=None):
        self.event_time = event_time  # type: str
        self.partitions = partitions  # type: dict[str, dict]

    def validate(self):
        pass

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

        result = dict()
        if self.event_time is not None:
            result['EventTime'] = self.event_time
        if self.partitions is not None:
            result['Partitions'] = self.partitions
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('EventTime') is not None:
            self.event_time = m.get('EventTime')
        if m.get('Partitions') is not None:
            self.partitions = m.get('Partitions')
        return self


class ExportModelFeatureTrainingSetTableRequestTrainingSetConfig(TeaModel):
    def __init__(self, partitions=None):
        self.partitions = partitions  # type: dict[str, dict]

    def validate(self):
        pass

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

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

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


class ExportModelFeatureTrainingSetTableRequest(TeaModel):
    def __init__(self, feature_view_config=None, label_input_config=None, training_set_config=None):
        self.feature_view_config = feature_view_config  # type: dict[str, FeatureViewConfigValue]
        self.label_input_config = label_input_config  # type: ExportModelFeatureTrainingSetTableRequestLabelInputConfig
        self.training_set_config = training_set_config  # type: ExportModelFeatureTrainingSetTableRequestTrainingSetConfig

    def validate(self):
        if self.feature_view_config:
            for v in self.feature_view_config.values():
                if v:
                    v.validate()
        if self.label_input_config:
            self.label_input_config.validate()
        if self.training_set_config:
            self.training_set_config.validate()

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

        result = dict()
        result['FeatureViewConfig'] = {}
        if self.feature_view_config is not None:
            for k, v in self.feature_view_config.items():
                result['FeatureViewConfig'][k] = v.to_map()
        if self.label_input_config is not None:
            result['LabelInputConfig'] = self.label_input_config.to_map()
        if self.training_set_config is not None:
            result['TrainingSetConfig'] = self.training_set_config.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.feature_view_config = {}
        if m.get('FeatureViewConfig') is not None:
            for k, v in m.get('FeatureViewConfig').items():
                temp_model = FeatureViewConfigValue()
                self.feature_view_config[k] = temp_model.from_map(v)
        if m.get('LabelInputConfig') is not None:
            temp_model = ExportModelFeatureTrainingSetTableRequestLabelInputConfig()
            self.label_input_config = temp_model.from_map(m['LabelInputConfig'])
        if m.get('TrainingSetConfig') is not None:
            temp_model = ExportModelFeatureTrainingSetTableRequestTrainingSetConfig()
            self.training_set_config = temp_model.from_map(m['TrainingSetConfig'])
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(ExportModelFeatureTrainingSetTableResponseBody, 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_id is not None:
            result['TaskId'] = self.task_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')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ExportModelFeatureTrainingSetTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDatasourceResponseBody(TeaModel):
    def __init__(self, config=None, datasource_id=None, gmt_create_time=None, gmt_modified_time=None, name=None,
                 request_id=None, type=None, uri=None, workspace_id=None):
        self.config = config  # type: str
        self.datasource_id = datasource_id  # type: str
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.name = name  # type: str
        self.request_id = request_id  # type: str
        self.type = type  # type: str
        self.uri = uri  # type: str
        self.workspace_id = workspace_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.config is not None:
            result['Config'] = self.config
        if self.datasource_id is not None:
            result['DatasourceId'] = self.datasource_id
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.name is not None:
            result['Name'] = self.name
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.type is not None:
            result['Type'] = self.type
        if self.uri is not None:
            result['Uri'] = self.uri
        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('Config') is not None:
            self.config = m.get('Config')
        if m.get('DatasourceId') is not None:
            self.datasource_id = m.get('DatasourceId')
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        if m.get('Uri') is not None:
            self.uri = m.get('Uri')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetDatasourceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDatasourceTableResponseBodyFields(TeaModel):
    def __init__(self, attributes=None, name=None, type=None):
        self.attributes = attributes  # type: list[str]
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.attributes is not None:
            result['Attributes'] = self.attributes
        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('Attributes') is not None:
            self.attributes = m.get('Attributes')
        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 GetDatasourceTableResponseBody(TeaModel):
    def __init__(self, fields=None, request_id=None, table_name=None):
        self.fields = fields  # type: list[GetDatasourceTableResponseBodyFields]
        self.request_id = request_id  # type: str
        self.table_name = table_name  # type: str

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

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

        result = dict()
        result['Fields'] = []
        if self.fields is not None:
            for k in self.fields:
                result['Fields'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_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()
        self.fields = []
        if m.get('Fields') is not None:
            for k in m.get('Fields'):
                temp_model = GetDatasourceTableResponseBodyFields()
                self.fields.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetDatasourceTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetFeatureEntityResponseBody(TeaModel):
    def __init__(self, gmt_create_time=None, join_id=None, name=None, owner=None, project_id=None, project_name=None,
                 request_id=None):
        self.gmt_create_time = gmt_create_time  # type: str
        self.join_id = join_id  # type: str
        self.name = name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str
        self.request_id = request_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.join_id is not None:
            result['JoinId'] = self.join_id
        if self.name is not None:
            result['Name'] = self.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.project_name is not None:
            result['ProjectName'] = self.project_name
        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('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('JoinId') is not None:
            self.join_id = m.get('JoinId')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        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('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetFeatureEntityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetFeatureViewResponseBodyFields(TeaModel):
    def __init__(self, attributes=None, name=None, type=None):
        self.attributes = attributes  # type: list[str]
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.attributes is not None:
            result['Attributes'] = self.attributes
        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('Attributes') is not None:
            self.attributes = m.get('Attributes')
        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 GetFeatureViewResponseBody(TeaModel):
    def __init__(self, config=None, feature_entity_id=None, feature_entity_name=None, fields=None,
                 gmt_create_time=None, gmt_modified_time=None, gmt_sync_time=None, join_id=None, last_sync_config=None, name=None,
                 owner=None, project_id=None, project_name=None, publish_table_script=None, register_datasource_id=None,
                 register_datasource_name=None, register_table=None, request_id=None, sync_online_table=None, ttl=None, tags=None, type=None,
                 write_method=None, write_to_feature_db=None):
        self.config = config  # type: str
        self.feature_entity_id = feature_entity_id  # type: str
        self.feature_entity_name = feature_entity_name  # type: str
        self.fields = fields  # type: list[GetFeatureViewResponseBodyFields]
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.gmt_sync_time = gmt_sync_time  # type: str
        self.join_id = join_id  # type: str
        self.last_sync_config = last_sync_config  # type: str
        self.name = name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str
        self.publish_table_script = publish_table_script  # type: str
        self.register_datasource_id = register_datasource_id  # type: str
        self.register_datasource_name = register_datasource_name  # type: str
        self.register_table = register_table  # type: str
        self.request_id = request_id  # type: str
        self.sync_online_table = sync_online_table  # type: bool
        self.ttl = ttl  # type: int
        self.tags = tags  # type: list[str]
        self.type = type  # type: str
        self.write_method = write_method  # type: str
        self.write_to_feature_db = write_to_feature_db  # type: bool

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

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

        result = dict()
        if self.config is not None:
            result['Config'] = self.config
        if self.feature_entity_id is not None:
            result['FeatureEntityId'] = self.feature_entity_id
        if self.feature_entity_name is not None:
            result['FeatureEntityName'] = self.feature_entity_name
        result['Fields'] = []
        if self.fields is not None:
            for k in self.fields:
                result['Fields'].append(k.to_map() if k else None)
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.gmt_sync_time is not None:
            result['GmtSyncTime'] = self.gmt_sync_time
        if self.join_id is not None:
            result['JoinId'] = self.join_id
        if self.last_sync_config is not None:
            result['LastSyncConfig'] = self.last_sync_config
        if self.name is not None:
            result['Name'] = self.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.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.publish_table_script is not None:
            result['PublishTableScript'] = self.publish_table_script
        if self.register_datasource_id is not None:
            result['RegisterDatasourceId'] = self.register_datasource_id
        if self.register_datasource_name is not None:
            result['RegisterDatasourceName'] = self.register_datasource_name
        if self.register_table is not None:
            result['RegisterTable'] = self.register_table
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.sync_online_table is not None:
            result['SyncOnlineTable'] = self.sync_online_table
        if self.ttl is not None:
            result['TTL'] = self.ttl
        if self.tags is not None:
            result['Tags'] = self.tags
        if self.type is not None:
            result['Type'] = self.type
        if self.write_method is not None:
            result['WriteMethod'] = self.write_method
        if self.write_to_feature_db is not None:
            result['WriteToFeatureDB'] = self.write_to_feature_db
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Config') is not None:
            self.config = m.get('Config')
        if m.get('FeatureEntityId') is not None:
            self.feature_entity_id = m.get('FeatureEntityId')
        if m.get('FeatureEntityName') is not None:
            self.feature_entity_name = m.get('FeatureEntityName')
        self.fields = []
        if m.get('Fields') is not None:
            for k in m.get('Fields'):
                temp_model = GetFeatureViewResponseBodyFields()
                self.fields.append(temp_model.from_map(k))
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('GmtSyncTime') is not None:
            self.gmt_sync_time = m.get('GmtSyncTime')
        if m.get('JoinId') is not None:
            self.join_id = m.get('JoinId')
        if m.get('LastSyncConfig') is not None:
            self.last_sync_config = m.get('LastSyncConfig')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        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('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('PublishTableScript') is not None:
            self.publish_table_script = m.get('PublishTableScript')
        if m.get('RegisterDatasourceId') is not None:
            self.register_datasource_id = m.get('RegisterDatasourceId')
        if m.get('RegisterDatasourceName') is not None:
            self.register_datasource_name = m.get('RegisterDatasourceName')
        if m.get('RegisterTable') is not None:
            self.register_table = m.get('RegisterTable')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('SyncOnlineTable') is not None:
            self.sync_online_table = m.get('SyncOnlineTable')
        if m.get('TTL') is not None:
            self.ttl = m.get('TTL')
        if m.get('Tags') is not None:
            self.tags = m.get('Tags')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        if m.get('WriteMethod') is not None:
            self.write_method = m.get('WriteMethod')
        if m.get('WriteToFeatureDB') is not None:
            self.write_to_feature_db = m.get('WriteToFeatureDB')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetFeatureViewResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetInstanceResponseBody(TeaModel):
    def __init__(self, gmt_create_time=None, gmt_modified_time=None, message=None, progress=None, region_id=None,
                 request_id=None, status=None, type=None):
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.message = message  # type: str
        self.progress = progress  # type: float
        self.region_id = region_id  # type: str
        self.request_id = request_id  # type: str
        self.status = status  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.message is not None:
            result['Message'] = self.message
        if self.progress is not None:
            result['Progress'] = self.progress
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        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('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('Message') is not None:
            self.message = m.get('Message')
        if m.get('Progress') is not None:
            self.progress = m.get('Progress')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        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('Type') is not None:
            self.type = m.get('Type')
        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):
        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 GetLabelTableResponseBodyFields(TeaModel):
    def __init__(self, attributes=None, name=None, type=None):
        self.attributes = attributes  # type: list[str]
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.attributes is not None:
            result['Attributes'] = self.attributes
        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('Attributes') is not None:
            self.attributes = m.get('Attributes')
        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 GetLabelTableResponseBody(TeaModel):
    def __init__(self, datasource_id=None, datasource_name=None, fields=None, gmt_create_time=None,
                 gmt_modified_time=None, name=None, owner=None, project_id=None, project_name=None, related_model_features=None,
                 request_id=None):
        self.datasource_id = datasource_id  # type: str
        self.datasource_name = datasource_name  # type: str
        self.fields = fields  # type: list[GetLabelTableResponseBodyFields]
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.name = name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str
        self.related_model_features = related_model_features  # type: list[str]
        self.request_id = request_id  # type: str

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

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

        result = dict()
        if self.datasource_id is not None:
            result['DatasourceId'] = self.datasource_id
        if self.datasource_name is not None:
            result['DatasourceName'] = self.datasource_name
        result['Fields'] = []
        if self.fields is not None:
            for k in self.fields:
                result['Fields'].append(k.to_map() if k else None)
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.name is not None:
            result['Name'] = self.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.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.related_model_features is not None:
            result['RelatedModelFeatures'] = self.related_model_features
        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('DatasourceId') is not None:
            self.datasource_id = m.get('DatasourceId')
        if m.get('DatasourceName') is not None:
            self.datasource_name = m.get('DatasourceName')
        self.fields = []
        if m.get('Fields') is not None:
            for k in m.get('Fields'):
                temp_model = GetLabelTableResponseBodyFields()
                self.fields.append(temp_model.from_map(k))
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        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('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('RelatedModelFeatures') is not None:
            self.related_model_features = m.get('RelatedModelFeatures')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetLabelTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetModelFeatureResponseBodyFeatures(TeaModel):
    def __init__(self, alias_name=None, feature_view_id=None, feature_view_name=None, name=None, type=None):
        self.alias_name = alias_name  # type: str
        self.feature_view_id = feature_view_id  # type: str
        self.feature_view_name = feature_view_name  # type: str
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.alias_name is not None:
            result['AliasName'] = self.alias_name
        if self.feature_view_id is not None:
            result['FeatureViewId'] = self.feature_view_id
        if self.feature_view_name is not None:
            result['FeatureViewName'] = self.feature_view_name
        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('AliasName') is not None:
            self.alias_name = m.get('AliasName')
        if m.get('FeatureViewId') is not None:
            self.feature_view_id = m.get('FeatureViewId')
        if m.get('FeatureViewName') is not None:
            self.feature_view_name = m.get('FeatureViewName')
        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 GetModelFeatureResponseBodyRelationsDomains(TeaModel):
    def __init__(self, domain_type=None, id=None, name=None):
        self.domain_type = domain_type  # type: str
        # Domain ID。
        self.id = id  # type: str
        self.name = name  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.domain_type is not None:
            result['DomainType'] = self.domain_type
        if self.id is not None:
            result['Id'] = self.id
        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('DomainType') is not None:
            self.domain_type = m.get('DomainType')
        if m.get('Id') is not None:
            self.id = m.get('Id')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        return self


class GetModelFeatureResponseBodyRelationsLinks(TeaModel):
    def __init__(self, from_=None, link=None, to=None):
        self.from_ = from_  # type: str
        self.link = link  # type: str
        self.to = to  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.from_ is not None:
            result['From'] = self.from_
        if self.link is not None:
            result['Link'] = self.link
        if self.to is not None:
            result['To'] = self.to
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('From') is not None:
            self.from_ = m.get('From')
        if m.get('Link') is not None:
            self.link = m.get('Link')
        if m.get('To') is not None:
            self.to = m.get('To')
        return self


class GetModelFeatureResponseBodyRelations(TeaModel):
    def __init__(self, domains=None, links=None):
        self.domains = domains  # type: list[GetModelFeatureResponseBodyRelationsDomains]
        self.links = links  # type: list[GetModelFeatureResponseBodyRelationsLinks]

    def validate(self):
        if self.domains:
            for k in self.domains:
                if k:
                    k.validate()
        if self.links:
            for k in self.links:
                if k:
                    k.validate()

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

        result = dict()
        result['Domains'] = []
        if self.domains is not None:
            for k in self.domains:
                result['Domains'].append(k.to_map() if k else None)
        result['Links'] = []
        if self.links is not None:
            for k in self.links:
                result['Links'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.domains = []
        if m.get('Domains') is not None:
            for k in m.get('Domains'):
                temp_model = GetModelFeatureResponseBodyRelationsDomains()
                self.domains.append(temp_model.from_map(k))
        self.links = []
        if m.get('Links') is not None:
            for k in m.get('Links'):
                temp_model = GetModelFeatureResponseBodyRelationsLinks()
                self.links.append(temp_model.from_map(k))
        return self


class GetModelFeatureResponseBody(TeaModel):
    def __init__(self, export_training_set_table_script=None, features=None, gmt_create_time=None,
                 gmt_modified_time=None, label_table_id=None, label_table_name=None, name=None, owner=None, project_id=None,
                 project_name=None, relations=None, request_id=None, training_set_fgtable=None, training_set_table=None):
        self.export_training_set_table_script = export_training_set_table_script  # type: str
        self.features = features  # type: list[GetModelFeatureResponseBodyFeatures]
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.label_table_id = label_table_id  # type: str
        self.label_table_name = label_table_name  # type: str
        self.name = name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str
        self.relations = relations  # type: GetModelFeatureResponseBodyRelations
        self.request_id = request_id  # type: str
        self.training_set_fgtable = training_set_fgtable  # type: str
        self.training_set_table = training_set_table  # type: str

    def validate(self):
        if self.features:
            for k in self.features:
                if k:
                    k.validate()
        if self.relations:
            self.relations.validate()

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

        result = dict()
        if self.export_training_set_table_script is not None:
            result['ExportTrainingSetTableScript'] = self.export_training_set_table_script
        result['Features'] = []
        if self.features is not None:
            for k in self.features:
                result['Features'].append(k.to_map() if k else None)
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.label_table_id is not None:
            result['LabelTableId'] = self.label_table_id
        if self.label_table_name is not None:
            result['LabelTableName'] = self.label_table_name
        if self.name is not None:
            result['Name'] = self.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.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.relations is not None:
            result['Relations'] = self.relations.to_map()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.training_set_fgtable is not None:
            result['TrainingSetFGTable'] = self.training_set_fgtable
        if self.training_set_table is not None:
            result['TrainingSetTable'] = self.training_set_table
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ExportTrainingSetTableScript') is not None:
            self.export_training_set_table_script = m.get('ExportTrainingSetTableScript')
        self.features = []
        if m.get('Features') is not None:
            for k in m.get('Features'):
                temp_model = GetModelFeatureResponseBodyFeatures()
                self.features.append(temp_model.from_map(k))
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('LabelTableId') is not None:
            self.label_table_id = m.get('LabelTableId')
        if m.get('LabelTableName') is not None:
            self.label_table_name = m.get('LabelTableName')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        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('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('Relations') is not None:
            temp_model = GetModelFeatureResponseBodyRelations()
            self.relations = temp_model.from_map(m['Relations'])
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TrainingSetFGTable') is not None:
            self.training_set_fgtable = m.get('TrainingSetFGTable')
        if m.get('TrainingSetTable') is not None:
            self.training_set_table = m.get('TrainingSetTable')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetModelFeatureResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetModelFeatureFGFeatureResponseBodyLookupFeatures(TeaModel):
    def __init__(self, default_value=None, feature_name=None, key_feature_domain=None, key_feature_name=None,
                 map_feature_domain=None, map_feature_name=None, value_type=None):
        self.default_value = default_value  # type: str
        self.feature_name = feature_name  # type: str
        self.key_feature_domain = key_feature_domain  # type: str
        self.key_feature_name = key_feature_name  # type: str
        self.map_feature_domain = map_feature_domain  # type: str
        self.map_feature_name = map_feature_name  # type: str
        self.value_type = value_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetModelFeatureFGFeatureResponseBodyLookupFeatures, 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.feature_name is not None:
            result['FeatureName'] = self.feature_name
        if self.key_feature_domain is not None:
            result['KeyFeatureDomain'] = self.key_feature_domain
        if self.key_feature_name is not None:
            result['KeyFeatureName'] = self.key_feature_name
        if self.map_feature_domain is not None:
            result['MapFeatureDomain'] = self.map_feature_domain
        if self.map_feature_name is not None:
            result['MapFeatureName'] = self.map_feature_name
        if self.value_type is not None:
            result['ValueType'] = self.value_type
        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('FeatureName') is not None:
            self.feature_name = m.get('FeatureName')
        if m.get('KeyFeatureDomain') is not None:
            self.key_feature_domain = m.get('KeyFeatureDomain')
        if m.get('KeyFeatureName') is not None:
            self.key_feature_name = m.get('KeyFeatureName')
        if m.get('MapFeatureDomain') is not None:
            self.map_feature_domain = m.get('MapFeatureDomain')
        if m.get('MapFeatureName') is not None:
            self.map_feature_name = m.get('MapFeatureName')
        if m.get('ValueType') is not None:
            self.value_type = m.get('ValueType')
        return self


class GetModelFeatureFGFeatureResponseBodyRawFeatures(TeaModel):
    def __init__(self, default_value=None, feature_domain=None, feature_name=None, feature_type=None,
                 input_feature_name=None, value_type=None):
        self.default_value = default_value  # type: str
        self.feature_domain = feature_domain  # type: str
        self.feature_name = feature_name  # type: str
        self.feature_type = feature_type  # type: str
        self.input_feature_name = input_feature_name  # type: str
        self.value_type = value_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetModelFeatureFGFeatureResponseBodyRawFeatures, 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.feature_domain is not None:
            result['FeatureDomain'] = self.feature_domain
        if self.feature_name is not None:
            result['FeatureName'] = self.feature_name
        if self.feature_type is not None:
            result['FeatureType'] = self.feature_type
        if self.input_feature_name is not None:
            result['InputFeatureName'] = self.input_feature_name
        if self.value_type is not None:
            result['ValueType'] = self.value_type
        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('FeatureDomain') is not None:
            self.feature_domain = m.get('FeatureDomain')
        if m.get('FeatureName') is not None:
            self.feature_name = m.get('FeatureName')
        if m.get('FeatureType') is not None:
            self.feature_type = m.get('FeatureType')
        if m.get('InputFeatureName') is not None:
            self.input_feature_name = m.get('InputFeatureName')
        if m.get('ValueType') is not None:
            self.value_type = m.get('ValueType')
        return self


class GetModelFeatureFGFeatureResponseBodySequenceFeaturesSubFeatures(TeaModel):
    def __init__(self, default_value=None, feature_domain=None, feature_name=None, feature_type=None,
                 input_feature_name=None, value_type=None):
        self.default_value = default_value  # type: str
        self.feature_domain = feature_domain  # type: str
        self.feature_name = feature_name  # type: str
        self.feature_type = feature_type  # type: str
        self.input_feature_name = input_feature_name  # type: str
        self.value_type = value_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(GetModelFeatureFGFeatureResponseBodySequenceFeaturesSubFeatures, 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.feature_domain is not None:
            result['FeatureDomain'] = self.feature_domain
        if self.feature_name is not None:
            result['FeatureName'] = self.feature_name
        if self.feature_type is not None:
            result['FeatureType'] = self.feature_type
        if self.input_feature_name is not None:
            result['InputFeatureName'] = self.input_feature_name
        if self.value_type is not None:
            result['ValueType'] = self.value_type
        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('FeatureDomain') is not None:
            self.feature_domain = m.get('FeatureDomain')
        if m.get('FeatureName') is not None:
            self.feature_name = m.get('FeatureName')
        if m.get('FeatureType') is not None:
            self.feature_type = m.get('FeatureType')
        if m.get('InputFeatureName') is not None:
            self.input_feature_name = m.get('InputFeatureName')
        if m.get('ValueType') is not None:
            self.value_type = m.get('ValueType')
        return self


class GetModelFeatureFGFeatureResponseBodySequenceFeatures(TeaModel):
    def __init__(self, attribute_delim=None, feature_name=None, sequence_delim=None, sequence_length=None,
                 sub_features=None):
        self.attribute_delim = attribute_delim  # type: str
        self.feature_name = feature_name  # type: str
        self.sequence_delim = sequence_delim  # type: str
        self.sequence_length = sequence_length  # type: long
        self.sub_features = sub_features  # type: list[GetModelFeatureFGFeatureResponseBodySequenceFeaturesSubFeatures]

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

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

        result = dict()
        if self.attribute_delim is not None:
            result['AttributeDelim'] = self.attribute_delim
        if self.feature_name is not None:
            result['FeatureName'] = self.feature_name
        if self.sequence_delim is not None:
            result['SequenceDelim'] = self.sequence_delim
        if self.sequence_length is not None:
            result['SequenceLength'] = self.sequence_length
        result['SubFeatures'] = []
        if self.sub_features is not None:
            for k in self.sub_features:
                result['SubFeatures'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AttributeDelim') is not None:
            self.attribute_delim = m.get('AttributeDelim')
        if m.get('FeatureName') is not None:
            self.feature_name = m.get('FeatureName')
        if m.get('SequenceDelim') is not None:
            self.sequence_delim = m.get('SequenceDelim')
        if m.get('SequenceLength') is not None:
            self.sequence_length = m.get('SequenceLength')
        self.sub_features = []
        if m.get('SubFeatures') is not None:
            for k in m.get('SubFeatures'):
                temp_model = GetModelFeatureFGFeatureResponseBodySequenceFeaturesSubFeatures()
                self.sub_features.append(temp_model.from_map(k))
        return self


class GetModelFeatureFGFeatureResponseBody(TeaModel):
    def __init__(self, lookup_features=None, raw_features=None, request_id=None, reserves=None,
                 sequence_features=None):
        self.lookup_features = lookup_features  # type: list[GetModelFeatureFGFeatureResponseBodyLookupFeatures]
        self.raw_features = raw_features  # type: list[GetModelFeatureFGFeatureResponseBodyRawFeatures]
        self.request_id = request_id  # type: str
        self.reserves = reserves  # type: list[str]
        self.sequence_features = sequence_features  # type: list[GetModelFeatureFGFeatureResponseBodySequenceFeatures]

    def validate(self):
        if self.lookup_features:
            for k in self.lookup_features:
                if k:
                    k.validate()
        if self.raw_features:
            for k in self.raw_features:
                if k:
                    k.validate()
        if self.sequence_features:
            for k in self.sequence_features:
                if k:
                    k.validate()

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

        result = dict()
        result['LookupFeatures'] = []
        if self.lookup_features is not None:
            for k in self.lookup_features:
                result['LookupFeatures'].append(k.to_map() if k else None)
        result['RawFeatures'] = []
        if self.raw_features is not None:
            for k in self.raw_features:
                result['RawFeatures'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.reserves is not None:
            result['Reserves'] = self.reserves
        result['SequenceFeatures'] = []
        if self.sequence_features is not None:
            for k in self.sequence_features:
                result['SequenceFeatures'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.lookup_features = []
        if m.get('LookupFeatures') is not None:
            for k in m.get('LookupFeatures'):
                temp_model = GetModelFeatureFGFeatureResponseBodyLookupFeatures()
                self.lookup_features.append(temp_model.from_map(k))
        self.raw_features = []
        if m.get('RawFeatures') is not None:
            for k in m.get('RawFeatures'):
                temp_model = GetModelFeatureFGFeatureResponseBodyRawFeatures()
                self.raw_features.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Reserves') is not None:
            self.reserves = m.get('Reserves')
        self.sequence_features = []
        if m.get('SequenceFeatures') is not None:
            for k in m.get('SequenceFeatures'):
                temp_model = GetModelFeatureFGFeatureResponseBodySequenceFeatures()
                self.sequence_features.append(temp_model.from_map(k))
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetModelFeatureFGFeatureResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

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

        result = dict()
        if self.content is not None:
            result['Content'] = self.content
        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('Content') is not None:
            self.content = m.get('Content')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetModelFeatureFGInfoResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetProjectResponseBody(TeaModel):
    def __init__(self, description=None, feature_entity_count=None, feature_view_count=None, gmt_create_time=None,
                 gmt_modified_time=None, model_count=None, name=None, offline_datasource_id=None, offline_datasource_name=None,
                 offline_datasource_type=None, offline_lifecycle=None, online_datasource_id=None, online_datasource_name=None,
                 online_datasource_type=None, owner=None, request_id=None):
        self.description = description  # type: str
        self.feature_entity_count = feature_entity_count  # type: int
        self.feature_view_count = feature_view_count  # type: int
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.model_count = model_count  # type: int
        self.name = name  # type: str
        self.offline_datasource_id = offline_datasource_id  # type: str
        self.offline_datasource_name = offline_datasource_name  # type: str
        self.offline_datasource_type = offline_datasource_type  # type: str
        self.offline_lifecycle = offline_lifecycle  # type: int
        self.online_datasource_id = online_datasource_id  # type: str
        self.online_datasource_name = online_datasource_name  # type: str
        self.online_datasource_type = online_datasource_type  # type: str
        self.owner = owner  # type: str
        self.request_id = request_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        if self.feature_entity_count is not None:
            result['FeatureEntityCount'] = self.feature_entity_count
        if self.feature_view_count is not None:
            result['FeatureViewCount'] = self.feature_view_count
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.model_count is not None:
            result['ModelCount'] = self.model_count
        if self.name is not None:
            result['Name'] = self.name
        if self.offline_datasource_id is not None:
            result['OfflineDatasourceId'] = self.offline_datasource_id
        if self.offline_datasource_name is not None:
            result['OfflineDatasourceName'] = self.offline_datasource_name
        if self.offline_datasource_type is not None:
            result['OfflineDatasourceType'] = self.offline_datasource_type
        if self.offline_lifecycle is not None:
            result['OfflineLifecycle'] = self.offline_lifecycle
        if self.online_datasource_id is not None:
            result['OnlineDatasourceId'] = self.online_datasource_id
        if self.online_datasource_name is not None:
            result['OnlineDatasourceName'] = self.online_datasource_name
        if self.online_datasource_type is not None:
            result['OnlineDatasourceType'] = self.online_datasource_type
        if self.owner is not None:
            result['Owner'] = self.owner
        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('Description') is not None:
            self.description = m.get('Description')
        if m.get('FeatureEntityCount') is not None:
            self.feature_entity_count = m.get('FeatureEntityCount')
        if m.get('FeatureViewCount') is not None:
            self.feature_view_count = m.get('FeatureViewCount')
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('ModelCount') is not None:
            self.model_count = m.get('ModelCount')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('OfflineDatasourceId') is not None:
            self.offline_datasource_id = m.get('OfflineDatasourceId')
        if m.get('OfflineDatasourceName') is not None:
            self.offline_datasource_name = m.get('OfflineDatasourceName')
        if m.get('OfflineDatasourceType') is not None:
            self.offline_datasource_type = m.get('OfflineDatasourceType')
        if m.get('OfflineLifecycle') is not None:
            self.offline_lifecycle = m.get('OfflineLifecycle')
        if m.get('OnlineDatasourceId') is not None:
            self.online_datasource_id = m.get('OnlineDatasourceId')
        if m.get('OnlineDatasourceName') is not None:
            self.online_datasource_name = m.get('OnlineDatasourceName')
        if m.get('OnlineDatasourceType') is not None:
            self.online_datasource_type = m.get('OnlineDatasourceType')
        if m.get('Owner') is not None:
            self.owner = m.get('Owner')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        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):
        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 GetProjectFeatureEntityResponseBody(TeaModel):
    def __init__(self, feature_entity_id=None, join_id=None, name=None, project_name=None, request_id=None,
                 workspace_id=None):
        self.feature_entity_id = feature_entity_id  # type: str
        self.join_id = join_id  # type: str
        self.name = name  # type: str
        self.project_name = project_name  # type: str
        self.request_id = request_id  # type: str
        self.workspace_id = workspace_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.feature_entity_id is not None:
            result['FeatureEntityId'] = self.feature_entity_id
        if self.join_id is not None:
            result['JoinId'] = self.join_id
        if self.name is not None:
            result['Name'] = self.name
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        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('FeatureEntityId') is not None:
            self.feature_entity_id = m.get('FeatureEntityId')
        if m.get('JoinId') is not None:
            self.join_id = m.get('JoinId')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetProjectFeatureEntityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetProjectFeatureEntityHotIdsResponseBody(TeaModel):
    def __init__(self, count=None, hot_ids=None, next_seq_number=None, request_id=None):
        self.count = count  # type: int
        self.hot_ids = hot_ids  # type: str
        self.next_seq_number = next_seq_number  # type: str
        self.request_id = request_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.count is not None:
            result['Count'] = self.count
        if self.hot_ids is not None:
            result['HotIds'] = self.hot_ids
        if self.next_seq_number is not None:
            result['NextSeqNumber'] = self.next_seq_number
        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('Count') is not None:
            self.count = m.get('Count')
        if m.get('HotIds') is not None:
            self.hot_ids = m.get('HotIds')
        if m.get('NextSeqNumber') is not None:
            self.next_seq_number = m.get('NextSeqNumber')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetProjectFeatureEntityHotIdsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetProjectFeatureViewResponseBodyFields(TeaModel):
    def __init__(self, attributes=None, name=None, type=None):
        self.attributes = attributes  # type: list[str]
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.attributes is not None:
            result['Attributes'] = self.attributes
        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('Attributes') is not None:
            self.attributes = m.get('Attributes')
        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 GetProjectFeatureViewResponseBody(TeaModel):
    def __init__(self, config=None, feature_entity_id=None, feature_entity_name=None, feature_view_id=None,
                 fields=None, gmt_sync_time=None, join_id=None, last_sync_config=None, name=None, owner=None,
                 project_id=None, project_name=None, register_datasource_id=None, register_table=None, request_id=None,
                 sync_online_table=None, ttl=None, tags=None, type=None, write_method=None):
        self.config = config  # type: str
        self.feature_entity_id = feature_entity_id  # type: str
        self.feature_entity_name = feature_entity_name  # type: str
        self.feature_view_id = feature_view_id  # type: str
        self.fields = fields  # type: list[GetProjectFeatureViewResponseBodyFields]
        self.gmt_sync_time = gmt_sync_time  # type: str
        self.join_id = join_id  # type: str
        self.last_sync_config = last_sync_config  # type: str
        self.name = name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str
        self.register_datasource_id = register_datasource_id  # type: str
        self.register_table = register_table  # type: str
        self.request_id = request_id  # type: str
        self.sync_online_table = sync_online_table  # type: bool
        self.ttl = ttl  # type: int
        self.tags = tags  # type: list[str]
        self.type = type  # type: str
        self.write_method = write_method  # type: str

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

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

        result = dict()
        if self.config is not None:
            result['Config'] = self.config
        if self.feature_entity_id is not None:
            result['FeatureEntityId'] = self.feature_entity_id
        if self.feature_entity_name is not None:
            result['FeatureEntityName'] = self.feature_entity_name
        if self.feature_view_id is not None:
            result['FeatureViewId'] = self.feature_view_id
        result['Fields'] = []
        if self.fields is not None:
            for k in self.fields:
                result['Fields'].append(k.to_map() if k else None)
        if self.gmt_sync_time is not None:
            result['GmtSyncTime'] = self.gmt_sync_time
        if self.join_id is not None:
            result['JoinId'] = self.join_id
        if self.last_sync_config is not None:
            result['LastSyncConfig'] = self.last_sync_config
        if self.name is not None:
            result['Name'] = self.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.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.register_datasource_id is not None:
            result['RegisterDatasourceId'] = self.register_datasource_id
        if self.register_table is not None:
            result['RegisterTable'] = self.register_table
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.sync_online_table is not None:
            result['SyncOnlineTable'] = self.sync_online_table
        if self.ttl is not None:
            result['TTL'] = self.ttl
        if self.tags is not None:
            result['Tags'] = self.tags
        if self.type is not None:
            result['Type'] = self.type
        if self.write_method is not None:
            result['WriteMethod'] = self.write_method
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Config') is not None:
            self.config = m.get('Config')
        if m.get('FeatureEntityId') is not None:
            self.feature_entity_id = m.get('FeatureEntityId')
        if m.get('FeatureEntityName') is not None:
            self.feature_entity_name = m.get('FeatureEntityName')
        if m.get('FeatureViewId') is not None:
            self.feature_view_id = m.get('FeatureViewId')
        self.fields = []
        if m.get('Fields') is not None:
            for k in m.get('Fields'):
                temp_model = GetProjectFeatureViewResponseBodyFields()
                self.fields.append(temp_model.from_map(k))
        if m.get('GmtSyncTime') is not None:
            self.gmt_sync_time = m.get('GmtSyncTime')
        if m.get('JoinId') is not None:
            self.join_id = m.get('JoinId')
        if m.get('LastSyncConfig') is not None:
            self.last_sync_config = m.get('LastSyncConfig')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        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('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('RegisterDatasourceId') is not None:
            self.register_datasource_id = m.get('RegisterDatasourceId')
        if m.get('RegisterTable') is not None:
            self.register_table = m.get('RegisterTable')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('SyncOnlineTable') is not None:
            self.sync_online_table = m.get('SyncOnlineTable')
        if m.get('TTL') is not None:
            self.ttl = m.get('TTL')
        if m.get('Tags') is not None:
            self.tags = m.get('Tags')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        if m.get('WriteMethod') is not None:
            self.write_method = m.get('WriteMethod')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetProjectFeatureViewResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetProjectModelFeatureResponseBodyFeatures(TeaModel):
    def __init__(self, alias_name=None, feature_view_id=None, feature_view_name=None, name=None, type=None):
        self.alias_name = alias_name  # type: str
        self.feature_view_id = feature_view_id  # type: str
        self.feature_view_name = feature_view_name  # type: str
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.alias_name is not None:
            result['AliasName'] = self.alias_name
        if self.feature_view_id is not None:
            result['FeatureViewId'] = self.feature_view_id
        if self.feature_view_name is not None:
            result['FeatureViewName'] = self.feature_view_name
        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('AliasName') is not None:
            self.alias_name = m.get('AliasName')
        if m.get('FeatureViewId') is not None:
            self.feature_view_id = m.get('FeatureViewId')
        if m.get('FeatureViewName') is not None:
            self.feature_view_name = m.get('FeatureViewName')
        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 GetProjectModelFeatureResponseBody(TeaModel):
    def __init__(self, features=None, gmt_create_time=None, gmt_modified_time=None, label_datasource_id=None,
                 label_datasource_table=None, label_event_time=None, label_table_id=None, model_feature_id=None, name=None, owner=None,
                 project_id=None, project_name=None, request_id=None, training_set_fgtable=None, training_set_table=None):
        self.features = features  # type: list[GetProjectModelFeatureResponseBodyFeatures]
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.label_datasource_id = label_datasource_id  # type: str
        self.label_datasource_table = label_datasource_table  # type: str
        self.label_event_time = label_event_time  # type: str
        self.label_table_id = label_table_id  # type: str
        self.model_feature_id = model_feature_id  # type: str
        self.name = name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str
        self.request_id = request_id  # type: str
        self.training_set_fgtable = training_set_fgtable  # type: str
        self.training_set_table = training_set_table  # type: str

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

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

        result = dict()
        result['Features'] = []
        if self.features is not None:
            for k in self.features:
                result['Features'].append(k.to_map() if k else None)
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.label_datasource_id is not None:
            result['LabelDatasourceId'] = self.label_datasource_id
        if self.label_datasource_table is not None:
            result['LabelDatasourceTable'] = self.label_datasource_table
        if self.label_event_time is not None:
            result['LabelEventTime'] = self.label_event_time
        if self.label_table_id is not None:
            result['LabelTableId'] = self.label_table_id
        if self.model_feature_id is not None:
            result['ModelFeatureId'] = self.model_feature_id
        if self.name is not None:
            result['Name'] = self.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.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.training_set_fgtable is not None:
            result['TrainingSetFGTable'] = self.training_set_fgtable
        if self.training_set_table is not None:
            result['TrainingSetTable'] = self.training_set_table
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.features = []
        if m.get('Features') is not None:
            for k in m.get('Features'):
                temp_model = GetProjectModelFeatureResponseBodyFeatures()
                self.features.append(temp_model.from_map(k))
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('LabelDatasourceId') is not None:
            self.label_datasource_id = m.get('LabelDatasourceId')
        if m.get('LabelDatasourceTable') is not None:
            self.label_datasource_table = m.get('LabelDatasourceTable')
        if m.get('LabelEventTime') is not None:
            self.label_event_time = m.get('LabelEventTime')
        if m.get('LabelTableId') is not None:
            self.label_table_id = m.get('LabelTableId')
        if m.get('ModelFeatureId') is not None:
            self.model_feature_id = m.get('ModelFeatureId')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        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('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TrainingSetFGTable') is not None:
            self.training_set_fgtable = m.get('TrainingSetFGTable')
        if m.get('TrainingSetTable') is not None:
            self.training_set_table = m.get('TrainingSetTable')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetProjectModelFeatureResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

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

        result = dict()
        if self.policy is not None:
            result['Policy'] = self.policy
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.role_name is not None:
            result['RoleName'] = self.role_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Policy') is not None:
            self.policy = m.get('Policy')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('RoleName') is not None:
            self.role_name = m.get('RoleName')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetServiceIdentityRoleResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetTaskResponseBody(TeaModel):
    def __init__(self, config=None, gmt_create_time=None, gmt_executed_time=None, gmt_finished_time=None,
                 gmt_modified_time=None, object_id=None, object_type=None, project_id=None, project_name=None, request_id=None,
                 running_config=None, status=None, type=None):
        self.config = config  # type: str
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_executed_time = gmt_executed_time  # type: str
        self.gmt_finished_time = gmt_finished_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.object_id = object_id  # type: str
        self.object_type = object_type  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str
        self.request_id = request_id  # type: str
        self.running_config = running_config  # type: str
        self.status = status  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.config is not None:
            result['Config'] = self.config
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_executed_time is not None:
            result['GmtExecutedTime'] = self.gmt_executed_time
        if self.gmt_finished_time is not None:
            result['GmtFinishedTime'] = self.gmt_finished_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.object_id is not None:
            result['ObjectId'] = self.object_id
        if self.object_type is not None:
            result['ObjectType'] = self.object_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        if self.running_config is not None:
            result['RunningConfig'] = self.running_config
        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('Config') is not None:
            self.config = m.get('Config')
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtExecutedTime') is not None:
            self.gmt_executed_time = m.get('GmtExecutedTime')
        if m.get('GmtFinishedTime') is not None:
            self.gmt_finished_time = m.get('GmtFinishedTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('ObjectId') is not None:
            self.object_id = m.get('ObjectId')
        if m.get('ObjectType') is not None:
            self.object_type = m.get('ObjectType')
        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('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('RunningConfig') is not None:
            self.running_config = m.get('RunningConfig')
        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 GetTaskResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: GetTaskResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = GetTaskResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

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

        result = dict()
        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('TableName') is not None:
            self.table_name = m.get('TableName')
        return self


class ListDatasourceTablesResponseBody(TeaModel):
    def __init__(self, request_id=None, tables=None, total_count=None):
        self.request_id = request_id  # type: str
        self.tables = tables  # type: list[str]
        self.total_count = total_count  # type: long

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListDatasourceTablesResponseBody, 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.tables is not None:
            result['Tables'] = self.tables
        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('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('Tables') is not None:
            self.tables = m.get('Tables')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListDatasourceTablesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListDatasourcesRequest(TeaModel):
    def __init__(self, name=None, order=None, page_number=None, page_size=None, sort_by=None, type=None,
                 workspace_id=None):
        self.name = name  # type: str
        self.order = order  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.sort_by = sort_by  # type: str
        self.type = type  # type: str
        self.workspace_id = workspace_id  # 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.name is not None:
            result['Name'] = self.name
        if self.order is not None:
            result['Order'] = self.order
        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_by is not None:
            result['SortBy'] = self.sort_by
        if self.type is not None:
            result['Type'] = self.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()
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Order') is not None:
            self.order = m.get('Order')
        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('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


class ListDatasourcesResponseBodyDatasources(TeaModel):
    def __init__(self, config=None, datasource_id=None, gmt_create_time=None, gmt_modified_time=None, name=None,
                 type=None, uri=None, workspace_id=None):
        self.config = config  # type: str
        self.datasource_id = datasource_id  # type: str
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.name = name  # type: str
        self.type = type  # type: str
        self.uri = uri  # type: str
        self.workspace_id = workspace_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.config is not None:
            result['Config'] = self.config
        if self.datasource_id is not None:
            result['DatasourceId'] = self.datasource_id
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.name is not None:
            result['Name'] = self.name
        if self.type is not None:
            result['Type'] = self.type
        if self.uri is not None:
            result['Uri'] = self.uri
        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('Config') is not None:
            self.config = m.get('Config')
        if m.get('DatasourceId') is not None:
            self.datasource_id = m.get('DatasourceId')
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        if m.get('Uri') is not None:
            self.uri = m.get('Uri')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


class ListDatasourcesResponseBody(TeaModel):
    def __init__(self, datasources=None, request_id=None, total_count=None):
        self.datasources = datasources  # type: list[ListDatasourcesResponseBodyDatasources]
        self.request_id = request_id  # type: str
        self.total_count = total_count  # type: long

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

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

        result = dict()
        result['Datasources'] = []
        if self.datasources is not None:
            for k in self.datasources:
                result['Datasources'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        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.datasources = []
        if m.get('Datasources') is not None:
            for k in m.get('Datasources'):
                temp_model = ListDatasourcesResponseBodyDatasources()
                self.datasources.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        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):
        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 ListFeatureEntitiesRequest(TeaModel):
    def __init__(self, feature_entity_ids=None, name=None, order=None, owner=None, page_number=None, page_size=None,
                 project_id=None, sort_by=None):
        self.feature_entity_ids = feature_entity_ids  # type: list[str]
        self.name = name  # type: str
        self.order = order  # 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: str
        self.sort_by = sort_by  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.feature_entity_ids is not None:
            result['FeatureEntityIds'] = self.feature_entity_ids
        if self.name is not None:
            result['Name'] = self.name
        if self.order is not None:
            result['Order'] = self.order
        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.sort_by is not None:
            result['SortBy'] = self.sort_by
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FeatureEntityIds') is not None:
            self.feature_entity_ids = m.get('FeatureEntityIds')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Order') is not None:
            self.order = m.get('Order')
        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('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        return self


class ListFeatureEntitiesShrinkRequest(TeaModel):
    def __init__(self, feature_entity_ids_shrink=None, name=None, order=None, owner=None, page_number=None,
                 page_size=None, project_id=None, sort_by=None):
        self.feature_entity_ids_shrink = feature_entity_ids_shrink  # type: str
        self.name = name  # type: str
        self.order = order  # 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: str
        self.sort_by = sort_by  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.feature_entity_ids_shrink is not None:
            result['FeatureEntityIds'] = self.feature_entity_ids_shrink
        if self.name is not None:
            result['Name'] = self.name
        if self.order is not None:
            result['Order'] = self.order
        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.sort_by is not None:
            result['SortBy'] = self.sort_by
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FeatureEntityIds') is not None:
            self.feature_entity_ids_shrink = m.get('FeatureEntityIds')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Order') is not None:
            self.order = m.get('Order')
        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('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        return self


class ListFeatureEntitiesResponseBodyFeatureEntities(TeaModel):
    def __init__(self, feature_entity_id=None, gmt_create_time=None, join_id=None, name=None, owner=None,
                 project_id=None, project_name=None):
        self.feature_entity_id = feature_entity_id  # type: str
        self.gmt_create_time = gmt_create_time  # type: str
        self.join_id = join_id  # type: str
        self.name = name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.feature_entity_id is not None:
            result['FeatureEntityId'] = self.feature_entity_id
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.join_id is not None:
            result['JoinId'] = self.join_id
        if self.name is not None:
            result['Name'] = self.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.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('FeatureEntityId') is not None:
            self.feature_entity_id = m.get('FeatureEntityId')
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('JoinId') is not None:
            self.join_id = m.get('JoinId')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        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('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class ListFeatureEntitiesResponseBody(TeaModel):
    def __init__(self, feature_entities=None, request_id=None, total_count=None):
        self.feature_entities = feature_entities  # type: list[ListFeatureEntitiesResponseBodyFeatureEntities]
        self.request_id = request_id  # type: str
        self.total_count = total_count  # type: int

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

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

        result = dict()
        result['FeatureEntities'] = []
        if self.feature_entities is not None:
            for k in self.feature_entities:
                result['FeatureEntities'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        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.feature_entities = []
        if m.get('FeatureEntities') is not None:
            for k in m.get('FeatureEntities'):
                temp_model = ListFeatureEntitiesResponseBodyFeatureEntities()
                self.feature_entities.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListFeatureEntitiesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListFeatureViewFieldRelationshipsResponseBodyRelationshipsModels(TeaModel):
    def __init__(self, model_id=None, model_name=None):
        self.model_id = model_id  # type: str
        self.model_name = model_name  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.model_id is not None:
            result['ModelId'] = self.model_id
        if self.model_name is not None:
            result['ModelName'] = self.model_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ModelId') is not None:
            self.model_id = m.get('ModelId')
        if m.get('ModelName') is not None:
            self.model_name = m.get('ModelName')
        return self


class ListFeatureViewFieldRelationshipsResponseBodyRelationships(TeaModel):
    def __init__(self, feature_name=None, models=None, offline_table_name=None, online_table_name=None):
        self.feature_name = feature_name  # type: str
        self.models = models  # type: list[ListFeatureViewFieldRelationshipsResponseBodyRelationshipsModels]
        self.offline_table_name = offline_table_name  # type: str
        self.online_table_name = online_table_name  # type: str

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

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

        result = dict()
        if self.feature_name is not None:
            result['FeatureName'] = self.feature_name
        result['Models'] = []
        if self.models is not None:
            for k in self.models:
                result['Models'].append(k.to_map() if k else None)
        if self.offline_table_name is not None:
            result['OfflineTableName'] = self.offline_table_name
        if self.online_table_name is not None:
            result['OnlineTableName'] = self.online_table_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FeatureName') is not None:
            self.feature_name = m.get('FeatureName')
        self.models = []
        if m.get('Models') is not None:
            for k in m.get('Models'):
                temp_model = ListFeatureViewFieldRelationshipsResponseBodyRelationshipsModels()
                self.models.append(temp_model.from_map(k))
        if m.get('OfflineTableName') is not None:
            self.offline_table_name = m.get('OfflineTableName')
        if m.get('OnlineTableName') is not None:
            self.online_table_name = m.get('OnlineTableName')
        return self


class ListFeatureViewFieldRelationshipsResponseBody(TeaModel):
    def __init__(self, relationships=None, request_id=None):
        self.relationships = relationships  # type: list[ListFeatureViewFieldRelationshipsResponseBodyRelationships]
        self.request_id = request_id  # type: str

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

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

        result = dict()
        result['Relationships'] = []
        if self.relationships is not None:
            for k in self.relationships:
                result['Relationships'].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.relationships = []
        if m.get('Relationships') is not None:
            for k in m.get('Relationships'):
                temp_model = ListFeatureViewFieldRelationshipsResponseBodyRelationships()
                self.relationships.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListFeatureViewFieldRelationshipsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListFeatureViewRelationshipsResponseBodyRelationshipsModels(TeaModel):
    def __init__(self, model_id=None, model_name=None):
        self.model_id = model_id  # type: str
        self.model_name = model_name  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.model_id is not None:
            result['ModelId'] = self.model_id
        if self.model_name is not None:
            result['ModelName'] = self.model_name
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ModelId') is not None:
            self.model_id = m.get('ModelId')
        if m.get('ModelName') is not None:
            self.model_name = m.get('ModelName')
        return self


class ListFeatureViewRelationshipsResponseBodyRelationships(TeaModel):
    def __init__(self, feature_view_name=None, models=None, project_name=None):
        self.feature_view_name = feature_view_name  # type: str
        self.models = models  # type: list[ListFeatureViewRelationshipsResponseBodyRelationshipsModels]
        self.project_name = project_name  # type: str

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

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

        result = dict()
        if self.feature_view_name is not None:
            result['FeatureViewName'] = self.feature_view_name
        result['Models'] = []
        if self.models is not None:
            for k in self.models:
                result['Models'].append(k.to_map() if k else None)
        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('FeatureViewName') is not None:
            self.feature_view_name = m.get('FeatureViewName')
        self.models = []
        if m.get('Models') is not None:
            for k in m.get('Models'):
                temp_model = ListFeatureViewRelationshipsResponseBodyRelationshipsModels()
                self.models.append(temp_model.from_map(k))
        if m.get('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class ListFeatureViewRelationshipsResponseBody(TeaModel):
    def __init__(self, relationships=None, request_id=None):
        self.relationships = relationships  # type: list[ListFeatureViewRelationshipsResponseBodyRelationships]
        self.request_id = request_id  # type: str

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

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

        result = dict()
        result['Relationships'] = []
        if self.relationships is not None:
            for k in self.relationships:
                result['Relationships'].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.relationships = []
        if m.get('Relationships') is not None:
            for k in m.get('Relationships'):
                temp_model = ListFeatureViewRelationshipsResponseBodyRelationships()
                self.relationships.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListFeatureViewRelationshipsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListFeatureViewsRequest(TeaModel):
    def __init__(self, feature_name=None, feature_view_ids=None, name=None, order=None, owner=None, page_number=None,
                 page_size=None, project_id=None, sort_by=None, tag=None, type=None):
        self.feature_name = feature_name  # type: str
        self.feature_view_ids = feature_view_ids  # type: list[str]
        self.name = name  # type: str
        self.order = order  # 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: str
        self.sort_by = sort_by  # type: str
        self.tag = tag  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.feature_name is not None:
            result['FeatureName'] = self.feature_name
        if self.feature_view_ids is not None:
            result['FeatureViewIds'] = self.feature_view_ids
        if self.name is not None:
            result['Name'] = self.name
        if self.order is not None:
            result['Order'] = self.order
        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.sort_by is not None:
            result['SortBy'] = self.sort_by
        if self.tag is not None:
            result['Tag'] = self.tag
        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('FeatureName') is not None:
            self.feature_name = m.get('FeatureName')
        if m.get('FeatureViewIds') is not None:
            self.feature_view_ids = m.get('FeatureViewIds')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Order') is not None:
            self.order = m.get('Order')
        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('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        if m.get('Tag') is not None:
            self.tag = m.get('Tag')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class ListFeatureViewsShrinkRequest(TeaModel):
    def __init__(self, feature_name=None, feature_view_ids_shrink=None, name=None, order=None, owner=None,
                 page_number=None, page_size=None, project_id=None, sort_by=None, tag=None, type=None):
        self.feature_name = feature_name  # type: str
        self.feature_view_ids_shrink = feature_view_ids_shrink  # type: str
        self.name = name  # type: str
        self.order = order  # 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: str
        self.sort_by = sort_by  # type: str
        self.tag = tag  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.feature_name is not None:
            result['FeatureName'] = self.feature_name
        if self.feature_view_ids_shrink is not None:
            result['FeatureViewIds'] = self.feature_view_ids_shrink
        if self.name is not None:
            result['Name'] = self.name
        if self.order is not None:
            result['Order'] = self.order
        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.sort_by is not None:
            result['SortBy'] = self.sort_by
        if self.tag is not None:
            result['Tag'] = self.tag
        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('FeatureName') is not None:
            self.feature_name = m.get('FeatureName')
        if m.get('FeatureViewIds') is not None:
            self.feature_view_ids_shrink = m.get('FeatureViewIds')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Order') is not None:
            self.order = m.get('Order')
        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('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        if m.get('Tag') is not None:
            self.tag = m.get('Tag')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class ListFeatureViewsResponseBodyFeatureViews(TeaModel):
    def __init__(self, feature_entity_name=None, feature_view_id=None, gmt_create_time=None,
                 gmt_modified_time=None, name=None, owner=None, project_id=None, project_name=None, register_datasource_id=None,
                 register_datasource_name=None, register_table=None, ttl=None, type=None, write_to_feature_db=None):
        self.feature_entity_name = feature_entity_name  # type: str
        self.feature_view_id = feature_view_id  # type: str
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.name = name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str
        self.register_datasource_id = register_datasource_id  # type: str
        self.register_datasource_name = register_datasource_name  # type: str
        self.register_table = register_table  # type: str
        self.ttl = ttl  # type: int
        self.type = type  # type: str
        self.write_to_feature_db = write_to_feature_db  # type: bool

    def validate(self):
        pass

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

        result = dict()
        if self.feature_entity_name is not None:
            result['FeatureEntityName'] = self.feature_entity_name
        if self.feature_view_id is not None:
            result['FeatureViewId'] = self.feature_view_id
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.name is not None:
            result['Name'] = self.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.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.register_datasource_id is not None:
            result['RegisterDatasourceId'] = self.register_datasource_id
        if self.register_datasource_name is not None:
            result['RegisterDatasourceName'] = self.register_datasource_name
        if self.register_table is not None:
            result['RegisterTable'] = self.register_table
        if self.ttl is not None:
            result['TTL'] = self.ttl
        if self.type is not None:
            result['Type'] = self.type
        if self.write_to_feature_db is not None:
            result['WriteToFeatureDB'] = self.write_to_feature_db
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('FeatureEntityName') is not None:
            self.feature_entity_name = m.get('FeatureEntityName')
        if m.get('FeatureViewId') is not None:
            self.feature_view_id = m.get('FeatureViewId')
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        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('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        if m.get('RegisterDatasourceId') is not None:
            self.register_datasource_id = m.get('RegisterDatasourceId')
        if m.get('RegisterDatasourceName') is not None:
            self.register_datasource_name = m.get('RegisterDatasourceName')
        if m.get('RegisterTable') is not None:
            self.register_table = m.get('RegisterTable')
        if m.get('TTL') is not None:
            self.ttl = m.get('TTL')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        if m.get('WriteToFeatureDB') is not None:
            self.write_to_feature_db = m.get('WriteToFeatureDB')
        return self


class ListFeatureViewsResponseBody(TeaModel):
    def __init__(self, feature_views=None, request_id=None, total_count=None):
        self.feature_views = feature_views  # type: list[ListFeatureViewsResponseBodyFeatureViews]
        self.request_id = request_id  # type: str
        self.total_count = total_count  # type: long

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

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

        result = dict()
        result['FeatureViews'] = []
        if self.feature_views is not None:
            for k in self.feature_views:
                result['FeatureViews'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        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.feature_views = []
        if m.get('FeatureViews') is not None:
            for k in m.get('FeatureViews'):
                temp_model = ListFeatureViewsResponseBodyFeatureViews()
                self.feature_views.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListFeatureViewsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListInstancesRequest(TeaModel):
    def __init__(self, order=None, page_number=None, page_size=None, sort_by=None, status=None):
        self.order = order  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.sort_by = sort_by  # type: str
        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.order is not None:
            result['Order'] = self.order
        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_by is not None:
            result['SortBy'] = self.sort_by
        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('Order') is not None:
            self.order = m.get('Order')
        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('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        if m.get('Status') is not None:
            self.status = m.get('Status')
        return self


class ListInstancesResponseBodyInstances(TeaModel):
    def __init__(self, gmt_create_time=None, gmt_modified_time=None, instance_id=None, region_id=None, status=None,
                 type=None):
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.instance_id = instance_id  # type: str
        self.region_id = region_id  # type: str
        self.status = status  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.instance_id is not None:
            result['InstanceId'] = self.instance_id
        if self.region_id is not None:
            result['RegionId'] = self.region_id
        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('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('InstanceId') is not None:
            self.instance_id = m.get('InstanceId')
        if m.get('RegionId') is not None:
            self.region_id = m.get('RegionId')
        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 ListInstancesResponseBody(TeaModel):
    def __init__(self, instances=None, request_id=None, total_count=None):
        self.instances = instances  # type: list[ListInstancesResponseBodyInstances]
        self.request_id = request_id  # type: str
        self.total_count = total_count  # type: long

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

    def to_map(self):
        _map = super(ListInstancesResponseBody, 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.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 = ListInstancesResponseBodyInstances()
                self.instances.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        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):
        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 ListLabelTablesRequest(TeaModel):
    def __init__(self, label_table_ids=None, name=None, order=None, owner=None, page_number=None, page_size=None,
                 project_id=None, sort_by=None):
        self.label_table_ids = label_table_ids  # type: list[str]
        self.name = name  # type: str
        self.order = order  # type: str
        self.owner = owner  # type: str
        self.page_number = page_number  # type: long
        self.page_size = page_size  # type: long
        self.project_id = project_id  # type: str
        self.sort_by = sort_by  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.label_table_ids is not None:
            result['LabelTableIds'] = self.label_table_ids
        if self.name is not None:
            result['Name'] = self.name
        if self.order is not None:
            result['Order'] = self.order
        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.sort_by is not None:
            result['SortBy'] = self.sort_by
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('LabelTableIds') is not None:
            self.label_table_ids = m.get('LabelTableIds')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Order') is not None:
            self.order = m.get('Order')
        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('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        return self


class ListLabelTablesShrinkRequest(TeaModel):
    def __init__(self, label_table_ids_shrink=None, name=None, order=None, owner=None, page_number=None,
                 page_size=None, project_id=None, sort_by=None):
        self.label_table_ids_shrink = label_table_ids_shrink  # type: str
        self.name = name  # type: str
        self.order = order  # type: str
        self.owner = owner  # type: str
        self.page_number = page_number  # type: long
        self.page_size = page_size  # type: long
        self.project_id = project_id  # type: str
        self.sort_by = sort_by  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.label_table_ids_shrink is not None:
            result['LabelTableIds'] = self.label_table_ids_shrink
        if self.name is not None:
            result['Name'] = self.name
        if self.order is not None:
            result['Order'] = self.order
        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.sort_by is not None:
            result['SortBy'] = self.sort_by
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('LabelTableIds') is not None:
            self.label_table_ids_shrink = m.get('LabelTableIds')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Order') is not None:
            self.order = m.get('Order')
        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('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        return self


class ListLabelTablesResponseBodyLabelTables(TeaModel):
    def __init__(self, datasource_id=None, datasource_name=None, gmt_create_time=None, gmt_modified_time=None,
                 label_table_id=None, name=None, owner=None, project_id=None, project_name=None):
        self.datasource_id = datasource_id  # type: str
        self.datasource_name = datasource_name  # type: str
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.label_table_id = label_table_id  # type: str
        self.name = name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.datasource_id is not None:
            result['DatasourceId'] = self.datasource_id
        if self.datasource_name is not None:
            result['DatasourceName'] = self.datasource_name
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.label_table_id is not None:
            result['LabelTableId'] = self.label_table_id
        if self.name is not None:
            result['Name'] = self.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.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('DatasourceId') is not None:
            self.datasource_id = m.get('DatasourceId')
        if m.get('DatasourceName') is not None:
            self.datasource_name = m.get('DatasourceName')
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('LabelTableId') is not None:
            self.label_table_id = m.get('LabelTableId')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        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('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class ListLabelTablesResponseBody(TeaModel):
    def __init__(self, label_tables=None, request_id=None, total_count=None):
        self.label_tables = label_tables  # type: list[ListLabelTablesResponseBodyLabelTables]
        self.request_id = request_id  # type: str
        self.total_count = total_count  # type: long

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

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

        result = dict()
        result['LabelTables'] = []
        if self.label_tables is not None:
            for k in self.label_tables:
                result['LabelTables'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        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.label_tables = []
        if m.get('LabelTables') is not None:
            for k in m.get('LabelTables'):
                temp_model = ListLabelTablesResponseBodyLabelTables()
                self.label_tables.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListLabelTablesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

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

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

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


class ListModelFeatureAvailableFeaturesResponseBodyAvaliableFeatures(TeaModel):
    def __init__(self, name=None, source_name=None, source_type=None, type=None):
        self.name = name  # type: str
        self.source_name = source_name  # type: str
        self.source_type = source_type  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.name is not None:
            result['Name'] = self.name
        if self.source_name is not None:
            result['SourceName'] = self.source_name
        if self.source_type is not None:
            result['SourceType'] = self.source_type
        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('Name') is not None:
            self.name = m.get('Name')
        if m.get('SourceName') is not None:
            self.source_name = m.get('SourceName')
        if m.get('SourceType') is not None:
            self.source_type = m.get('SourceType')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class ListModelFeatureAvailableFeaturesResponseBody(TeaModel):
    def __init__(self, avaliable_features=None, total_count=None, request_id=None):
        self.avaliable_features = avaliable_features  # type: list[ListModelFeatureAvailableFeaturesResponseBodyAvaliableFeatures]
        self.total_count = total_count  # type: long
        self.request_id = request_id  # type: str

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

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

        result = dict()
        result['AvaliableFeatures'] = []
        if self.avaliable_features is not None:
            for k in self.avaliable_features:
                result['AvaliableFeatures'].append(k.to_map() if k else None)
        if self.total_count is not None:
            result['TotalCount'] = self.total_count
        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.avaliable_features = []
        if m.get('AvaliableFeatures') is not None:
            for k in m.get('AvaliableFeatures'):
                temp_model = ListModelFeatureAvailableFeaturesResponseBodyAvaliableFeatures()
                self.avaliable_features.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        if m.get('requestId') is not None:
            self.request_id = m.get('requestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListModelFeatureAvailableFeaturesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListModelFeaturesRequest(TeaModel):
    def __init__(self, model_feature_ids=None, name=None, order=None, owner=None, page_number=None, page_size=None,
                 project_id=None, sort_by=None):
        self.model_feature_ids = model_feature_ids  # type: list[str]
        self.name = name  # type: str
        self.order = order  # 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: str
        self.sort_by = sort_by  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.model_feature_ids is not None:
            result['ModelFeatureIds'] = self.model_feature_ids
        if self.name is not None:
            result['Name'] = self.name
        if self.order is not None:
            result['Order'] = self.order
        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.sort_by is not None:
            result['SortBy'] = self.sort_by
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ModelFeatureIds') is not None:
            self.model_feature_ids = m.get('ModelFeatureIds')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Order') is not None:
            self.order = m.get('Order')
        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('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        return self


class ListModelFeaturesShrinkRequest(TeaModel):
    def __init__(self, model_feature_ids_shrink=None, name=None, order=None, owner=None, page_number=None,
                 page_size=None, project_id=None, sort_by=None):
        self.model_feature_ids_shrink = model_feature_ids_shrink  # type: str
        self.name = name  # type: str
        self.order = order  # 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: str
        self.sort_by = sort_by  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.model_feature_ids_shrink is not None:
            result['ModelFeatureIds'] = self.model_feature_ids_shrink
        if self.name is not None:
            result['Name'] = self.name
        if self.order is not None:
            result['Order'] = self.order
        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.sort_by is not None:
            result['SortBy'] = self.sort_by
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('ModelFeatureIds') is not None:
            self.model_feature_ids_shrink = m.get('ModelFeatureIds')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('Order') is not None:
            self.order = m.get('Order')
        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('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        return self


class ListModelFeaturesResponseBodyModelFeatures(TeaModel):
    def __init__(self, gmt_create_time=None, gmt_modified_time=None, label_table_name=None, model_feature_id=None,
                 name=None, owner=None, project_id=None, project_name=None):
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.label_table_name = label_table_name  # type: str
        self.model_feature_id = model_feature_id  # type: str
        self.name = name  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.label_table_name is not None:
            result['LabelTableName'] = self.label_table_name
        if self.model_feature_id is not None:
            result['ModelFeatureId'] = self.model_feature_id
        if self.name is not None:
            result['Name'] = self.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.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('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('LabelTableName') is not None:
            self.label_table_name = m.get('LabelTableName')
        if m.get('ModelFeatureId') is not None:
            self.model_feature_id = m.get('ModelFeatureId')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        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('ProjectName') is not None:
            self.project_name = m.get('ProjectName')
        return self


class ListModelFeaturesResponseBody(TeaModel):
    def __init__(self, model_features=None, request_id=None, total_count=None):
        self.model_features = model_features  # type: list[ListModelFeaturesResponseBodyModelFeatures]
        self.request_id = request_id  # type: str
        self.total_count = total_count  # type: long

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

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

        result = dict()
        result['ModelFeatures'] = []
        if self.model_features is not None:
            for k in self.model_features:
                result['ModelFeatures'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        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.model_features = []
        if m.get('ModelFeatures') is not None:
            for k in m.get('ModelFeatures'):
                temp_model = ListModelFeaturesResponseBodyModelFeatures()
                self.model_features.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListModelFeaturesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListProjectFeatureViewOwnersResponseBody(TeaModel):
    def __init__(self, owners=None, request_id=None):
        self.owners = owners  # type: list[str]
        self.request_id = request_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.owners is not None:
            result['Owners'] = self.owners
        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('Owners') is not None:
            self.owners = m.get('Owners')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListProjectFeatureViewOwnersResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListProjectFeatureViewTagsResponseBody(TeaModel):
    def __init__(self, request_id=None, tags=None):
        self.request_id = request_id  # type: str
        self.tags = tags  # type: list[str]

    def validate(self):
        pass

    def to_map(self):
        _map = super(ListProjectFeatureViewTagsResponseBody, 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.tags is not None:
            result['Tags'] = self.tags
        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('Tags') is not None:
            self.tags = m.get('Tags')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListProjectFeatureViewTagsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListProjectFeatureViewsResponseBodyFeatureViewsFeatures(TeaModel):
    def __init__(self, attributes=None, name=None, type=None):
        self.attributes = attributes  # type: list[str]
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.attributes is not None:
            result['Attributes'] = self.attributes
        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('Attributes') is not None:
            self.attributes = m.get('Attributes')
        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 ListProjectFeatureViewsResponseBodyFeatureViews(TeaModel):
    def __init__(self, feature_view_id=None, features=None, name=None, type=None):
        self.feature_view_id = feature_view_id  # type: str
        self.features = features  # type: list[ListProjectFeatureViewsResponseBodyFeatureViewsFeatures]
        self.name = name  # type: str
        self.type = type  # type: str

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

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

        result = dict()
        if self.feature_view_id is not None:
            result['FeatureViewId'] = self.feature_view_id
        result['Features'] = []
        if self.features is not None:
            for k in self.features:
                result['Features'].append(k.to_map() if k else None)
        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('FeatureViewId') is not None:
            self.feature_view_id = m.get('FeatureViewId')
        self.features = []
        if m.get('Features') is not None:
            for k in m.get('Features'):
                temp_model = ListProjectFeatureViewsResponseBodyFeatureViewsFeatures()
                self.features.append(temp_model.from_map(k))
        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 ListProjectFeatureViewsResponseBody(TeaModel):
    def __init__(self, feature_views=None, request_id=None, total_count=None):
        self.feature_views = feature_views  # type: list[ListProjectFeatureViewsResponseBodyFeatureViews]
        self.request_id = request_id  # type: str
        self.total_count = total_count  # type: long

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

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

        result = dict()
        result['FeatureViews'] = []
        if self.feature_views is not None:
            for k in self.feature_views:
                result['FeatureViews'].append(k.to_map() if k else None)
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        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.feature_views = []
        if m.get('FeatureViews') is not None:
            for k in m.get('FeatureViews'):
                temp_model = ListProjectFeatureViewsResponseBodyFeatureViews()
                self.feature_views.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListProjectFeatureViewsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListProjectsRequest(TeaModel):
    def __init__(self, name=None, order=None, owner=None, page_number=None, page_size=None, project_ids=None,
                 sort_by=None, workspace_id=None):
        self.name = name  # type: str
        self.order = order  # type: str
        self.owner = owner  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_ids = project_ids  # type: list[str]
        self.sort_by = sort_by  # type: str
        self.workspace_id = workspace_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.name is not None:
            result['Name'] = self.name
        if self.order is not None:
            result['Order'] = self.order
        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_ids is not None:
            result['ProjectIds'] = self.project_ids
        if self.sort_by is not None:
            result['SortBy'] = self.sort_by
        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('Name') is not None:
            self.name = m.get('Name')
        if m.get('Order') is not None:
            self.order = m.get('Order')
        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('ProjectIds') is not None:
            self.project_ids = m.get('ProjectIds')
        if m.get('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


class ListProjectsShrinkRequest(TeaModel):
    def __init__(self, name=None, order=None, owner=None, page_number=None, page_size=None, project_ids_shrink=None,
                 sort_by=None, workspace_id=None):
        self.name = name  # type: str
        self.order = order  # type: str
        self.owner = owner  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_ids_shrink = project_ids_shrink  # type: str
        self.sort_by = sort_by  # type: str
        self.workspace_id = workspace_id  # 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.name is not None:
            result['Name'] = self.name
        if self.order is not None:
            result['Order'] = self.order
        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_ids_shrink is not None:
            result['ProjectIds'] = self.project_ids_shrink
        if self.sort_by is not None:
            result['SortBy'] = self.sort_by
        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('Name') is not None:
            self.name = m.get('Name')
        if m.get('Order') is not None:
            self.order = m.get('Order')
        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('ProjectIds') is not None:
            self.project_ids_shrink = m.get('ProjectIds')
        if m.get('SortBy') is not None:
            self.sort_by = m.get('SortBy')
        if m.get('WorkspaceId') is not None:
            self.workspace_id = m.get('WorkspaceId')
        return self


class ListProjectsResponseBodyProjects(TeaModel):
    def __init__(self, description=None, feature_entity_count=None, feature_view_count=None, gmt_create_time=None,
                 gmt_modified_time=None, model_count=None, name=None, offline_datasource_id=None, offline_datasource_name=None,
                 offline_datasource_type=None, offline_lifecycle=None, online_datasource_id=None, online_datasource_name=None,
                 online_datasource_type=None, owner=None, project_id=None):
        self.description = description  # type: str
        self.feature_entity_count = feature_entity_count  # type: int
        self.feature_view_count = feature_view_count  # type: int
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_modified_time = gmt_modified_time  # type: str
        self.model_count = model_count  # type: int
        self.name = name  # type: str
        self.offline_datasource_id = offline_datasource_id  # type: str
        self.offline_datasource_name = offline_datasource_name  # type: str
        self.offline_datasource_type = offline_datasource_type  # type: str
        self.offline_lifecycle = offline_lifecycle  # type: int
        self.online_datasource_id = online_datasource_id  # type: str
        self.online_datasource_name = online_datasource_name  # type: str
        self.online_datasource_type = online_datasource_type  # type: str
        self.owner = owner  # type: str
        self.project_id = project_id  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        if self.feature_entity_count is not None:
            result['FeatureEntityCount'] = self.feature_entity_count
        if self.feature_view_count is not None:
            result['FeatureViewCount'] = self.feature_view_count
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_modified_time is not None:
            result['GmtModifiedTime'] = self.gmt_modified_time
        if self.model_count is not None:
            result['ModelCount'] = self.model_count
        if self.name is not None:
            result['Name'] = self.name
        if self.offline_datasource_id is not None:
            result['OfflineDatasourceId'] = self.offline_datasource_id
        if self.offline_datasource_name is not None:
            result['OfflineDatasourceName'] = self.offline_datasource_name
        if self.offline_datasource_type is not None:
            result['OfflineDatasourceType'] = self.offline_datasource_type
        if self.offline_lifecycle is not None:
            result['OfflineLifecycle'] = self.offline_lifecycle
        if self.online_datasource_id is not None:
            result['OnlineDatasourceId'] = self.online_datasource_id
        if self.online_datasource_name is not None:
            result['OnlineDatasourceName'] = self.online_datasource_name
        if self.online_datasource_type is not None:
            result['OnlineDatasourceType'] = self.online_datasource_type
        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('Description') is not None:
            self.description = m.get('Description')
        if m.get('FeatureEntityCount') is not None:
            self.feature_entity_count = m.get('FeatureEntityCount')
        if m.get('FeatureViewCount') is not None:
            self.feature_view_count = m.get('FeatureViewCount')
        if m.get('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtModifiedTime') is not None:
            self.gmt_modified_time = m.get('GmtModifiedTime')
        if m.get('ModelCount') is not None:
            self.model_count = m.get('ModelCount')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        if m.get('OfflineDatasourceId') is not None:
            self.offline_datasource_id = m.get('OfflineDatasourceId')
        if m.get('OfflineDatasourceName') is not None:
            self.offline_datasource_name = m.get('OfflineDatasourceName')
        if m.get('OfflineDatasourceType') is not None:
            self.offline_datasource_type = m.get('OfflineDatasourceType')
        if m.get('OfflineLifecycle') is not None:
            self.offline_lifecycle = m.get('OfflineLifecycle')
        if m.get('OnlineDatasourceId') is not None:
            self.online_datasource_id = m.get('OnlineDatasourceId')
        if m.get('OnlineDatasourceName') is not None:
            self.online_datasource_name = m.get('OnlineDatasourceName')
        if m.get('OnlineDatasourceType') is not None:
            self.online_datasource_type = m.get('OnlineDatasourceType')
        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 ListProjectsResponseBody(TeaModel):
    def __init__(self, projects=None, request_id=None, total_count=None):
        self.projects = projects  # type: list[ListProjectsResponseBodyProjects]
        self.request_id = request_id  # type: str
        self.total_count = total_count  # type: long

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

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

        result = dict()
        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.request_id is not None:
            result['RequestId'] = self.request_id
        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.projects = []
        if m.get('Projects') is not None:
            for k in m.get('Projects'):
                temp_model = ListProjectsResponseBodyProjects()
                self.projects.append(temp_model.from_map(k))
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        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):
        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 ListTaskLogsRequest(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(ListTaskLogsRequest, 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 ListTaskLogsResponseBody(TeaModel):
    def __init__(self, logs=None, request_id=None, total_count=None):
        self.logs = logs  # type: list[str]
        self.request_id = request_id  # type: str
        self.total_count = total_count  # type: int

    def validate(self):
        pass

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

        result = dict()
        if self.logs is not None:
            result['Logs'] = self.logs
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        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('Logs') is not None:
            self.logs = m.get('Logs')
        if m.get('RequestId') is not None:
            self.request_id = m.get('RequestId')
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListTaskLogsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ListTasksRequest(TeaModel):
    def __init__(self, object_id=None, object_type=None, page_number=None, page_size=None, project_id=None,
                 status=None, task_ids=None, type=None):
        self.object_id = object_id  # type: str
        self.object_type = object_type  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: str
        self.status = status  # type: str
        self.task_ids = task_ids  # type: list[str]
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.object_id is not None:
            result['ObjectId'] = self.object_id
        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.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        if self.task_ids is not None:
            result['TaskIds'] = self.task_ids
        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('ObjectId') is not None:
            self.object_id = m.get('ObjectId')
        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('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('TaskIds') is not None:
            self.task_ids = m.get('TaskIds')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class ListTasksShrinkRequest(TeaModel):
    def __init__(self, object_id=None, object_type=None, page_number=None, page_size=None, project_id=None,
                 status=None, task_ids_shrink=None, type=None):
        self.object_id = object_id  # type: str
        self.object_type = object_type  # type: str
        self.page_number = page_number  # type: int
        self.page_size = page_size  # type: int
        self.project_id = project_id  # type: str
        self.status = status  # type: str
        self.task_ids_shrink = task_ids_shrink  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.object_id is not None:
            result['ObjectId'] = self.object_id
        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.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.status is not None:
            result['Status'] = self.status
        if self.task_ids_shrink is not None:
            result['TaskIds'] = self.task_ids_shrink
        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('ObjectId') is not None:
            self.object_id = m.get('ObjectId')
        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('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('TaskIds') is not None:
            self.task_ids_shrink = m.get('TaskIds')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class ListTasksResponseBodyTasks(TeaModel):
    def __init__(self, gmt_create_time=None, gmt_executed_time=None, gmt_finished_time=None, object_id=None,
                 object_type=None, project_id=None, project_name=None, status=None, task_id=None, type=None):
        self.gmt_create_time = gmt_create_time  # type: str
        self.gmt_executed_time = gmt_executed_time  # type: str
        self.gmt_finished_time = gmt_finished_time  # type: str
        self.object_id = object_id  # type: str
        self.object_type = object_type  # type: str
        self.project_id = project_id  # type: str
        self.project_name = project_name  # type: str
        self.status = status  # type: str
        self.task_id = task_id  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.gmt_create_time is not None:
            result['GmtCreateTime'] = self.gmt_create_time
        if self.gmt_executed_time is not None:
            result['GmtExecutedTime'] = self.gmt_executed_time
        if self.gmt_finished_time is not None:
            result['GmtFinishedTime'] = self.gmt_finished_time
        if self.object_id is not None:
            result['ObjectId'] = self.object_id
        if self.object_type is not None:
            result['ObjectType'] = self.object_type
        if self.project_id is not None:
            result['ProjectId'] = self.project_id
        if self.project_name is not None:
            result['ProjectName'] = self.project_name
        if self.status is not None:
            result['Status'] = self.status
        if self.task_id is not None:
            result['TaskId'] = self.task_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('GmtCreateTime') is not None:
            self.gmt_create_time = m.get('GmtCreateTime')
        if m.get('GmtExecutedTime') is not None:
            self.gmt_executed_time = m.get('GmtExecutedTime')
        if m.get('GmtFinishedTime') is not None:
            self.gmt_finished_time = m.get('GmtFinishedTime')
        if m.get('ObjectId') is not None:
            self.object_id = m.get('ObjectId')
        if m.get('ObjectType') is not None:
            self.object_type = m.get('ObjectType')
        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('Status') is not None:
            self.status = m.get('Status')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        if m.get('Type') is not None:
            self.type = m.get('Type')
        return self


class ListTasksResponseBody(TeaModel):
    def __init__(self, request_id=None, tasks=None, total_count=None):
        self.request_id = request_id  # type: str
        self.tasks = tasks  # type: list[ListTasksResponseBodyTasks]
        self.total_count = total_count  # type: int

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

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

        result = dict()
        if self.request_id is not None:
            result['RequestId'] = self.request_id
        result['Tasks'] = []
        if self.tasks is not None:
            for k in self.tasks:
                result['Tasks'].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('RequestId') is not None:
            self.request_id = m.get('RequestId')
        self.tasks = []
        if m.get('Tasks') is not None:
            for k in m.get('Tasks'):
                temp_model = ListTasksResponseBodyTasks()
                self.tasks.append(temp_model.from_map(k))
        if m.get('TotalCount') is not None:
            self.total_count = m.get('TotalCount')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = ListTasksResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class PublishFeatureViewTableRequest(TeaModel):
    def __init__(self, config=None, event_time=None, mode=None, offline_to_online=None, partitions=None):
        self.config = config  # type: str
        self.event_time = event_time  # type: str
        self.mode = mode  # type: str
        self.offline_to_online = offline_to_online  # type: bool
        self.partitions = partitions  # type: dict[str, dict]

    def validate(self):
        pass

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

        result = dict()
        if self.config is not None:
            result['Config'] = self.config
        if self.event_time is not None:
            result['EventTime'] = self.event_time
        if self.mode is not None:
            result['Mode'] = self.mode
        if self.offline_to_online is not None:
            result['OfflineToOnline'] = self.offline_to_online
        if self.partitions is not None:
            result['Partitions'] = self.partitions
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Config') is not None:
            self.config = m.get('Config')
        if m.get('EventTime') is not None:
            self.event_time = m.get('EventTime')
        if m.get('Mode') is not None:
            self.mode = m.get('Mode')
        if m.get('OfflineToOnline') is not None:
            self.offline_to_online = m.get('OfflineToOnline')
        if m.get('Partitions') is not None:
            self.partitions = m.get('Partitions')
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(PublishFeatureViewTableResponseBody, 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_id is not None:
            result['TaskId'] = self.task_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')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = PublishFeatureViewTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateDatasourceRequest(TeaModel):
    def __init__(self, config=None, name=None, uri=None):
        self.config = config  # type: str
        self.name = name  # type: str
        self.uri = uri  # 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.config is not None:
            result['Config'] = self.config
        if self.name is not None:
            result['Name'] = self.name
        if self.uri is not None:
            result['Uri'] = self.uri
        return result

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


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

    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.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 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):
        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 UpdateLabelTableRequestFields(TeaModel):
    def __init__(self, attributes=None, name=None, type=None):
        self.attributes = attributes  # type: list[str]
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.attributes is not None:
            result['Attributes'] = self.attributes
        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('Attributes') is not None:
            self.attributes = m.get('Attributes')
        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 UpdateLabelTableRequest(TeaModel):
    def __init__(self, datasource_id=None, fields=None, name=None):
        self.datasource_id = datasource_id  # type: str
        self.fields = fields  # type: list[UpdateLabelTableRequestFields]
        self.name = name  # type: str

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

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

        result = dict()
        if self.datasource_id is not None:
            result['DatasourceId'] = self.datasource_id
        result['Fields'] = []
        if self.fields is not None:
            for k in self.fields:
                result['Fields'].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('DatasourceId') is not None:
            self.datasource_id = m.get('DatasourceId')
        self.fields = []
        if m.get('Fields') is not None:
            for k in m.get('Fields'):
                temp_model = UpdateLabelTableRequestFields()
                self.fields.append(temp_model.from_map(k))
        if m.get('Name') is not None:
            self.name = m.get('Name')
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateLabelTableResponseBody, 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 UpdateLabelTableResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateLabelTableResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = UpdateLabelTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateModelFeatureRequestFeatures(TeaModel):
    def __init__(self, alias_name=None, feature_view_id=None, name=None, type=None):
        self.alias_name = alias_name  # type: str
        self.feature_view_id = feature_view_id  # type: str
        self.name = name  # type: str
        self.type = type  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.alias_name is not None:
            result['AliasName'] = self.alias_name
        if self.feature_view_id is not None:
            result['FeatureViewId'] = self.feature_view_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('AliasName') is not None:
            self.alias_name = m.get('AliasName')
        if m.get('FeatureViewId') is not None:
            self.feature_view_id = m.get('FeatureViewId')
        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 UpdateModelFeatureRequest(TeaModel):
    def __init__(self, features=None, label_table_id=None, sequence_feature_view_ids=None):
        self.features = features  # type: list[UpdateModelFeatureRequestFeatures]
        self.label_table_id = label_table_id  # type: str
        self.sequence_feature_view_ids = sequence_feature_view_ids  # type: list[str]

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

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

        result = dict()
        result['Features'] = []
        if self.features is not None:
            for k in self.features:
                result['Features'].append(k.to_map() if k else None)
        if self.label_table_id is not None:
            result['LabelTableId'] = self.label_table_id
        if self.sequence_feature_view_ids is not None:
            result['SequenceFeatureViewIds'] = self.sequence_feature_view_ids
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.features = []
        if m.get('Features') is not None:
            for k in m.get('Features'):
                temp_model = UpdateModelFeatureRequestFeatures()
                self.features.append(temp_model.from_map(k))
        if m.get('LabelTableId') is not None:
            self.label_table_id = m.get('LabelTableId')
        if m.get('SequenceFeatureViewIds') is not None:
            self.sequence_feature_view_ids = m.get('SequenceFeatureViewIds')
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateModelFeatureResponseBody, 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 UpdateModelFeatureResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateModelFeatureResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = UpdateModelFeatureResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateModelFeatureFGFeatureRequestLookupFeatures(TeaModel):
    def __init__(self, default_value=None, feature_name=None, key_feature_domain=None, key_feature_name=None,
                 map_feature_domain=None, map_feature_name=None, value_type=None):
        self.default_value = default_value  # type: str
        self.feature_name = feature_name  # type: str
        self.key_feature_domain = key_feature_domain  # type: str
        self.key_feature_name = key_feature_name  # type: str
        self.map_feature_domain = map_feature_domain  # type: str
        self.map_feature_name = map_feature_name  # type: str
        self.value_type = value_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateModelFeatureFGFeatureRequestLookupFeatures, 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.feature_name is not None:
            result['FeatureName'] = self.feature_name
        if self.key_feature_domain is not None:
            result['KeyFeatureDomain'] = self.key_feature_domain
        if self.key_feature_name is not None:
            result['KeyFeatureName'] = self.key_feature_name
        if self.map_feature_domain is not None:
            result['MapFeatureDomain'] = self.map_feature_domain
        if self.map_feature_name is not None:
            result['MapFeatureName'] = self.map_feature_name
        if self.value_type is not None:
            result['ValueType'] = self.value_type
        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('FeatureName') is not None:
            self.feature_name = m.get('FeatureName')
        if m.get('KeyFeatureDomain') is not None:
            self.key_feature_domain = m.get('KeyFeatureDomain')
        if m.get('KeyFeatureName') is not None:
            self.key_feature_name = m.get('KeyFeatureName')
        if m.get('MapFeatureDomain') is not None:
            self.map_feature_domain = m.get('MapFeatureDomain')
        if m.get('MapFeatureName') is not None:
            self.map_feature_name = m.get('MapFeatureName')
        if m.get('ValueType') is not None:
            self.value_type = m.get('ValueType')
        return self


class UpdateModelFeatureFGFeatureRequestRawFeatures(TeaModel):
    def __init__(self, default_value=None, feature_domain=None, feature_name=None, feature_type=None,
                 input_feature_name=None, value_type=None):
        self.default_value = default_value  # type: str
        self.feature_domain = feature_domain  # type: str
        self.feature_name = feature_name  # type: str
        self.feature_type = feature_type  # type: str
        self.input_feature_name = input_feature_name  # type: str
        self.value_type = value_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateModelFeatureFGFeatureRequestRawFeatures, 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.feature_domain is not None:
            result['FeatureDomain'] = self.feature_domain
        if self.feature_name is not None:
            result['FeatureName'] = self.feature_name
        if self.feature_type is not None:
            result['FeatureType'] = self.feature_type
        if self.input_feature_name is not None:
            result['InputFeatureName'] = self.input_feature_name
        if self.value_type is not None:
            result['ValueType'] = self.value_type
        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('FeatureDomain') is not None:
            self.feature_domain = m.get('FeatureDomain')
        if m.get('FeatureName') is not None:
            self.feature_name = m.get('FeatureName')
        if m.get('FeatureType') is not None:
            self.feature_type = m.get('FeatureType')
        if m.get('InputFeatureName') is not None:
            self.input_feature_name = m.get('InputFeatureName')
        if m.get('ValueType') is not None:
            self.value_type = m.get('ValueType')
        return self


class UpdateModelFeatureFGFeatureRequestSequenceFeaturesSubFeatures(TeaModel):
    def __init__(self, default_value=None, feature_domain=None, feature_name=None, feature_type=None,
                 input_feature_name=None, value_type=None):
        self.default_value = default_value  # type: str
        self.feature_domain = feature_domain  # type: str
        self.feature_name = feature_name  # type: str
        self.feature_type = feature_type  # type: str
        self.input_feature_name = input_feature_name  # type: str
        self.value_type = value_type  # type: str

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateModelFeatureFGFeatureRequestSequenceFeaturesSubFeatures, 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.feature_domain is not None:
            result['FeatureDomain'] = self.feature_domain
        if self.feature_name is not None:
            result['FeatureName'] = self.feature_name
        if self.feature_type is not None:
            result['FeatureType'] = self.feature_type
        if self.input_feature_name is not None:
            result['InputFeatureName'] = self.input_feature_name
        if self.value_type is not None:
            result['ValueType'] = self.value_type
        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('FeatureDomain') is not None:
            self.feature_domain = m.get('FeatureDomain')
        if m.get('FeatureName') is not None:
            self.feature_name = m.get('FeatureName')
        if m.get('FeatureType') is not None:
            self.feature_type = m.get('FeatureType')
        if m.get('InputFeatureName') is not None:
            self.input_feature_name = m.get('InputFeatureName')
        if m.get('ValueType') is not None:
            self.value_type = m.get('ValueType')
        return self


class UpdateModelFeatureFGFeatureRequestSequenceFeatures(TeaModel):
    def __init__(self, attribute_delim=None, feature_name=None, sequence_delim=None, sequence_length=None,
                 sub_features=None):
        self.attribute_delim = attribute_delim  # type: str
        self.feature_name = feature_name  # type: str
        self.sequence_delim = sequence_delim  # type: str
        self.sequence_length = sequence_length  # type: long
        self.sub_features = sub_features  # type: list[UpdateModelFeatureFGFeatureRequestSequenceFeaturesSubFeatures]

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

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

        result = dict()
        if self.attribute_delim is not None:
            result['AttributeDelim'] = self.attribute_delim
        if self.feature_name is not None:
            result['FeatureName'] = self.feature_name
        if self.sequence_delim is not None:
            result['SequenceDelim'] = self.sequence_delim
        if self.sequence_length is not None:
            result['SequenceLength'] = self.sequence_length
        result['SubFeatures'] = []
        if self.sub_features is not None:
            for k in self.sub_features:
                result['SubFeatures'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('AttributeDelim') is not None:
            self.attribute_delim = m.get('AttributeDelim')
        if m.get('FeatureName') is not None:
            self.feature_name = m.get('FeatureName')
        if m.get('SequenceDelim') is not None:
            self.sequence_delim = m.get('SequenceDelim')
        if m.get('SequenceLength') is not None:
            self.sequence_length = m.get('SequenceLength')
        self.sub_features = []
        if m.get('SubFeatures') is not None:
            for k in m.get('SubFeatures'):
                temp_model = UpdateModelFeatureFGFeatureRequestSequenceFeaturesSubFeatures()
                self.sub_features.append(temp_model.from_map(k))
        return self


class UpdateModelFeatureFGFeatureRequest(TeaModel):
    def __init__(self, lookup_features=None, raw_features=None, reserves=None, sequence_features=None):
        self.lookup_features = lookup_features  # type: list[UpdateModelFeatureFGFeatureRequestLookupFeatures]
        self.raw_features = raw_features  # type: list[UpdateModelFeatureFGFeatureRequestRawFeatures]
        self.reserves = reserves  # type: list[str]
        self.sequence_features = sequence_features  # type: list[UpdateModelFeatureFGFeatureRequestSequenceFeatures]

    def validate(self):
        if self.lookup_features:
            for k in self.lookup_features:
                if k:
                    k.validate()
        if self.raw_features:
            for k in self.raw_features:
                if k:
                    k.validate()
        if self.sequence_features:
            for k in self.sequence_features:
                if k:
                    k.validate()

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

        result = dict()
        result['LookupFeatures'] = []
        if self.lookup_features is not None:
            for k in self.lookup_features:
                result['LookupFeatures'].append(k.to_map() if k else None)
        result['RawFeatures'] = []
        if self.raw_features is not None:
            for k in self.raw_features:
                result['RawFeatures'].append(k.to_map() if k else None)
        if self.reserves is not None:
            result['Reserves'] = self.reserves
        result['SequenceFeatures'] = []
        if self.sequence_features is not None:
            for k in self.sequence_features:
                result['SequenceFeatures'].append(k.to_map() if k else None)
        return result

    def from_map(self, m=None):
        m = m or dict()
        self.lookup_features = []
        if m.get('LookupFeatures') is not None:
            for k in m.get('LookupFeatures'):
                temp_model = UpdateModelFeatureFGFeatureRequestLookupFeatures()
                self.lookup_features.append(temp_model.from_map(k))
        self.raw_features = []
        if m.get('RawFeatures') is not None:
            for k in m.get('RawFeatures'):
                temp_model = UpdateModelFeatureFGFeatureRequestRawFeatures()
                self.raw_features.append(temp_model.from_map(k))
        if m.get('Reserves') is not None:
            self.reserves = m.get('Reserves')
        self.sequence_features = []
        if m.get('SequenceFeatures') is not None:
            for k in m.get('SequenceFeatures'):
                temp_model = UpdateModelFeatureFGFeatureRequestSequenceFeatures()
                self.sequence_features.append(temp_model.from_map(k))
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateModelFeatureFGFeatureResponseBody, 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 UpdateModelFeatureFGFeatureResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateModelFeatureFGFeatureResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = UpdateModelFeatureFGFeatureResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

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

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

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


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateModelFeatureFGInfoResponseBody, 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 UpdateModelFeatureFGInfoResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateModelFeatureFGInfoResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = UpdateModelFeatureFGInfoResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


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

    def validate(self):
        pass

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

        result = dict()
        if self.description is not None:
            result['Description'] = self.description
        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('Description') is not None:
            self.description = m.get('Description')
        if m.get('Name') is not None:
            self.name = m.get('Name')
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(UpdateProjectResponseBody, 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 UpdateProjectResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: UpdateProjectResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = UpdateProjectResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class WriteFeatureViewTableRequestUrlDatasource(TeaModel):
    def __init__(self, delimiter=None, omit_header=None, path=None):
        self.delimiter = delimiter  # type: str
        self.omit_header = omit_header  # type: bool
        self.path = path  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.delimiter is not None:
            result['Delimiter'] = self.delimiter
        if self.omit_header is not None:
            result['OmitHeader'] = self.omit_header
        if self.path is not None:
            result['Path'] = self.path
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Delimiter') is not None:
            self.delimiter = m.get('Delimiter')
        if m.get('OmitHeader') is not None:
            self.omit_header = m.get('OmitHeader')
        if m.get('Path') is not None:
            self.path = m.get('Path')
        return self


class WriteFeatureViewTableRequest(TeaModel):
    def __init__(self, mode=None, partitions=None, url_datasource=None):
        self.mode = mode  # type: str
        self.partitions = partitions  # type: dict[str, dict]
        self.url_datasource = url_datasource  # type: WriteFeatureViewTableRequestUrlDatasource

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

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

        result = dict()
        if self.mode is not None:
            result['Mode'] = self.mode
        if self.partitions is not None:
            result['Partitions'] = self.partitions
        if self.url_datasource is not None:
            result['UrlDatasource'] = self.url_datasource.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('Mode') is not None:
            self.mode = m.get('Mode')
        if m.get('Partitions') is not None:
            self.partitions = m.get('Partitions')
        if m.get('UrlDatasource') is not None:
            temp_model = WriteFeatureViewTableRequestUrlDatasource()
            self.url_datasource = temp_model.from_map(m['UrlDatasource'])
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(WriteFeatureViewTableResponseBody, 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_id is not None:
            result['TaskId'] = self.task_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')
        if m.get('TaskId') is not None:
            self.task_id = m.get('TaskId')
        return self


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

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = WriteFeatureViewTableResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class WriteProjectFeatureEntityHotIdsRequest(TeaModel):
    def __init__(self, hot_ids=None, version=None):
        self.hot_ids = hot_ids  # type: str
        self.version = version  # type: str

    def validate(self):
        pass

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

        result = dict()
        if self.hot_ids is not None:
            result['HotIds'] = self.hot_ids
        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('HotIds') is not None:
            self.hot_ids = m.get('HotIds')
        if m.get('Version') is not None:
            self.version = m.get('Version')
        return self


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

    def validate(self):
        pass

    def to_map(self):
        _map = super(WriteProjectFeatureEntityHotIdsResponseBody, 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 WriteProjectFeatureEntityHotIdsResponse(TeaModel):
    def __init__(self, headers=None, status_code=None, body=None):
        self.headers = headers  # type: dict[str, str]
        self.status_code = status_code  # type: int
        self.body = body  # type: WriteProjectFeatureEntityHotIdsResponseBody

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

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

        result = dict()
        if self.headers is not None:
            result['headers'] = self.headers
        if self.status_code is not None:
            result['statusCode'] = self.status_code
        if self.body is not None:
            result['body'] = self.body.to_map()
        return result

    def from_map(self, m=None):
        m = m or dict()
        if m.get('headers') is not None:
            self.headers = m.get('headers')
        if m.get('statusCode') is not None:
            self.status_code = m.get('statusCode')
        if m.get('body') is not None:
            temp_model = WriteProjectFeatureEntityHotIdsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self