export declare const actions: unique symbol;
export declare const base: unique symbol;
export declare const loaded: unique symbol;
export declare const size: unique symbol;
export declare const transaction: unique symbol;
export type TxAction = {
    action: "remove";
    records: number;
} | {
    action: "save";
    records: number | false;
};
export declare class EntryBase {
    constructor(from?: Partial<EntryBase>);
    construct(): void;
    postCommit(actions: TxAction[]): void;
    postLoad(): void;
    postRemove(deletedRecords: number): void;
    postSave(savedRecords: number | false): void;
    preCommit(actions: TxAction[]): void;
    preLoad(): void;
    preRemove(): void;
    preSave(): void;
    remove(): Promise<boolean>;
    save(): Promise<number | false>;
}
export type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";
export interface ForeignKeyOptions {
    onDelete?: ForeignKeyActions;
    onUpdate?: ForeignKeyActions;
}
export interface Type<T, N extends boolean, E> {
    [base]: unknown;
    entry?: E;
    native?: T;
    notNull?: N;
    [size]?: number;
    type: string;
    foreignKey?: {
        attributeName: string;
        fieldName: string;
        options?: ForeignKeyOptions;
        tableName: string;
    };
}
export declare class Type<T, N extends boolean, E> {
    constructor(from: Type<T, N, E>);
}
export interface Attribute<T, N extends boolean, E> extends Type<T, N, E> {
    attributeName: string;
    defaultValue?: unknown;
    fieldName: string;
    modelName: string;
    notNull: N;
    tableName: string;
    unique?: boolean;
}
export declare class Attribute<T, N extends boolean, E> extends Type<T, N, E> {
    constructor(from: Attribute<T, N, E>);
}
export interface Constraint {
    attribute: Attribute<unknown, boolean, unknown>;
    constraintName: string;
    type: "f" | "u";
}
export interface Index {
    fields: string[];
    indexName: string;
    type: "btree" | "hash";
    unique: boolean;
}
interface ITable {
    attributes: Attribute<unknown, boolean, unknown>[];
    autoIncrement: boolean;
    constraints: Constraint[];
    indexes: Index[];
    model: {
        load: (where: any, order?: any, tx?: Transaction) => Promise<EntryBase[]>;
    };
    parent?: Attribute<unknown, boolean, unknown>;
    pk: Attribute<unknown, boolean, unknown>;
    sync: boolean;
    tableName: string;
}
declare const Table_base: new (defaults?: ITable | undefined) => ITable;
export declare class Table extends Table_base {
    autoIncrementOwn?: boolean;
    oid?: number;
    findAttribute(name: string): Attribute<unknown, boolean, unknown>;
    findField(name: string): Attribute<unknown, boolean, unknown>;
}
export declare abstract class DB<T extends Transaction> {
    tables: Table[];
    protected log: (message: string) => void;
    protected sync: boolean;
    abstract connect(): Promise<void>;
    abstract end(): Promise<void>;
    constructor(log: (message: string) => void);
    findTable(name: string): Table;
    protected indexesEq(a: Index, b: Index): boolean;
    syncDataBase(): Promise<void>;
    protected syncLog(message: string): void;
    abstract begin(): Promise<T>;
    abstract cancel(tableName: string): (where: string, tx?: Transaction) => Promise<number>;
    abstract escape(value: unknown): string;
    abstract load(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, boolean, unknown>, model: new () => EntryBase, table: Table): (where: string, order?: string | string[], limit?: number, tx?: Transaction, lock?: boolean) => Promise<EntryBase[]>;
    abstract remove(tableName: string, pk: Attribute<unknown, boolean, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<number>;
    abstract save(tableName: string, attr2field: Record<string, string>, pk: Attribute<unknown, boolean, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<number | false>;
    abstract dropConstraints(table: Table): Promise<number[]>;
    abstract dropFields(table: Table): Promise<void>;
    abstract dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
    abstract syncConstraints(table: Table): Promise<void>;
    abstract syncFields(table: Table): Promise<void>;
    abstract syncIndexes(table: Table): Promise<void>;
    abstract syncSequence(table: Table): Promise<void>;
    abstract syncTable(table: Table): Promise<void>;
}
export declare class Transaction {
    private entries;
    private closed;
    protected log: (message: string) => void;
    constructor(log: (message: string) => void);
    addEntry(entry: EntryBase): void;
    clean(): void;
    commit(): Promise<void>;
    protected preCommit(): void;
    rollback(): Promise<void>;
}
export declare function deepCopy(o: unknown): any;
export declare function deepDiff(a: unknown, b: unknown): boolean;
export {};