export declare type DatamodelStep = CreateModelStep | CreateFieldStep;
export interface CreateModelStep {
    stepType: 'CreateModel';
    name: string;
    embedded: boolean;
}
export interface CreateFieldStep {
    stepType: 'CreateField';
    model: string;
    name: string;
    type: FieldType;
    arity: FieldArity;
    isUnique: boolean;
}
export declare enum PrimitiveType {
    String = "String",
    Int = "Int",
    Float = "Float",
    Boolean = "Boolean"
}
export declare enum FieldArity {
    required = "required",
    list = "list",
    optional = "optional"
}
export declare type FieldType = BaseFieldType | RelationFieldType;
export interface BaseFieldType {
    Base: PrimitiveType;
}
export interface RelationFieldType {
    Relation: {
        to: string;
        to_field: string | null;
        name: string | null;
        on_delete: string;
    };
}
export declare namespace EngineArgs {
    /**
     * These RPCs need a sourceConfig, therefore a db connection to function
     */
    interface ApplyMigration {
        migrationId: string;
        steps: DatamodelStep[];
        force: boolean;
        sourceConfig: string;
    }
    interface InferMigrationSteps {
        migrationId: string;
        datamodel: string;
        assumeToBeApplied: DatamodelStep[];
        sourceConfig: string;
    }
    interface MigrationProgress {
        migrationId: string;
        sourceConfig: string;
    }
    interface CalculateDatabaseSteps {
        assumeToBeApplied: DatamodelStep[];
        stepsToApply: DatamodelStep[];
        sourceConfig: string;
    }
    /**
     * These don't
     */
    interface CalculateDatamodel {
        steps: DatamodelStep[];
    }
    interface UnapplyMigration {
        sourceConfig: string;
    }
    interface ListMigrations {
        sourceConfig: string;
    }
}
export declare namespace EngineResults {
    interface InferMigrationSteps {
        datamodelSteps: DatamodelStep[];
        databaseSteps: any[];
        warnings: any[];
        errors: any[];
        generalErrors: any[];
    }
    enum MigrationStatus {
        MigrationSuccess = "MigrationSuccess",
        MigrationInProgress = "MigrationInProgress",
        MigrationFailure = "MigrationFailure",
        Pending = "Pending",
        RollingBack = "RollingBack",
        RollbackSuccess = "RollbackSuccess",
        RollbackFailure = "RollbackFailure"
    }
    interface MigrationProgress {
        status: MigrationStatus;
        steps: number;
        applied: number;
        rolledBack: number;
        errors: any[];
        startedAt: string;
        finishedAt: string;
    }
    interface ApplyMigration {
        datamodelSteps: DatamodelStep[];
        databaseSteps: DatabaseStep[];
        warnings: Warning[];
        errors: any[];
        generalErrors: any[];
    }
    interface Warning {
        description: string;
    }
    interface UnapplyMigration {
        rolledBack: DatamodelStep[];
        active: DatamodelStep[];
        errors: any[];
    }
    interface StoredMigration {
        id: string;
        datamodelSteps: DatamodelStep[];
        databaseSteps: DatabaseStep[];
        status: MigrationStatus;
        datamodel: string;
    }
    interface CalculateDatamodel {
        datamodel: string;
    }
    type ListMigrations = StoredMigration[];
}
export declare type ConnectorType = 'mysql' | 'mongo' | 'sqlite' | 'postgresql';
export interface GeneratorConfig {
    name: string;
    output: string | null;
    provider: string;
    config: Dictionary<string>;
}
export interface FileMap {
    [fileName: string]: string;
}
export interface LockFile {
    localMigrations: string[];
    remoteMigrations: string[];
    localBranch?: string;
    remoteBranch?: string;
}
export interface Dictionary<T> {
    [key: string]: T;
}
export interface LocalMigration extends Migration {
    afterFilePath?: string;
    beforeFilePath?: string;
}
export interface Migration {
    id: string;
    datamodelSteps: DatamodelStep[];
    databaseSteps?: DatabaseStep[];
    datamodel: string;
}
export interface LocalMigrationWithDatabaseSteps extends LocalMigration {
    databaseSteps: DatabaseStep[];
    warnings: EngineResults.Warning[];
}
export interface RawSqlStep {
    RawSql: string;
    raw: string;
}
export interface DropTableStep {
    raw: string;
    DropTable: {
        name: string;
    };
}
export interface RenameTableStep {
    raw: string;
    RenameTable: {
        name: string;
        new_name: string;
    };
}
export interface CreateTableStep {
    raw: string;
    CreateTable: {
        name: string;
        columns: CreateColumn[];
        primary_columns: string[];
    };
}
export interface CreateColumn {
    raw: string;
    name: string;
    tpe: string;
    required: boolean;
    foreign_key: null | {
        table: string;
        column: string;
    };
}
export declare type DatabaseStep = RawSqlStep | DropTableStep | RenameTableStep | CreateTableStep;