import { ConnectionInfo } from './engine';
import { FlushOptions } from './flush';
import { Record } from './record';
import { RecordConfig } from './loader';
import { Schema, Model, Field, SimpleField, ForeignKeyField, RelatedField } from './schema';
import { Schema as SchemaConfig } from './config';
import { Column as ColumnInfo, Constraint, Document, DocumentValue, MutationOptions, SelectFields, TableCreate, TableFilter, TableInsert, TableRow, TableUpdate, Value } from './types';
import { Connection, ConnectionPool, Row } from './engine';
export type Filter = Document | Document[];
import { FieldMap, JsonFilterOptions, OperatorMap, QueryBuilder } from './filter';
import { FieldOptions } from './select';
import { ViewOptions } from './view';
export declare class ClosureTable {
    table: Table;
    ancestor: ForeignKeyField;
    descendant: ForeignKeyField;
    depth?: SimpleField | undefined;
    constructor(table: Table, ancestor: ForeignKeyField, descendant: ForeignKeyField, depth?: SimpleField | undefined);
}
export declare class Database<TTables = any> {
    name: string;
    schema: Schema;
    operatorMap: OperatorMap;
    jsonFilterOptions?: JsonFilterOptions;
    pool: ConnectionPool;
    tableMap: {
        [key: string]: Table<any>;
    };
    tableList: Table<any>[];
    constructor(connection: ConnectionPool | ConnectionInfo, schema?: Schema, operatorMap?: OperatorMap, jsonFilterOptions?: JsonFilterOptions);
    getModels(bulk?: boolean): {
        [key: string]: any;
    };
    buildSchema(config?: SchemaConfig): Promise<Schema>;
    clone(): Database<TTables>;
    private setSchema;
    table<Name extends keyof TTables & string>(name: Name): Table<TTables[Name]>;
    table(name: string | Field | Model): Table;
    model(name: string): Model;
    append<Name extends keyof TTables & string>(name: Name, data: TableCreate<TTables[Name]>): Record;
    append(name: string, data: {
        [key: string]: any;
    }): any;
    getDirtyCount(): number;
    flush(flushOptions?: FlushOptions): Promise<{
        connection: Connection;
        complete: boolean;
    }>;
    end(): Promise<void>;
    clear(): this;
    json(): {
        [key: string]: Document[];
    };
    query<T = Document[]>(fmt: string, ...args: unknown[]): Promise<T>;
    select<T extends object = Document>(options: DatabaseSelectOptions, connection?: Connection): Promise<T[]>;
    cleanup(): Promise<void>;
    zap(excludes?: string[]): Promise<void>;
}
export type OrderBy = string | string[];
export interface SelectOptions<TFilter = Filter> {
    where?: TFilter;
    offset?: number;
    limit?: number;
    orderBy?: OrderBy;
    groupBy?: string[];
    having?: Filter;
    raw?: boolean;
}
export declare const SelectOptionKeys: (keyof SelectOptions)[];
export interface DatabaseSelectOptions<TFilter = Filter> extends SelectOptions<TFilter> {
    fields: string | string[];
    from: string | ViewOptions;
}
export declare class Table<TSpec = any> {
    db: Database<any>;
    name: string;
    model: Model;
    closureTable?: ClosureTable;
    recordList: Record[];
    recordMap: {
        [key: string]: {
            [key: string]: Record;
        };
    };
    noInsert: boolean;
    selectOnly?: Document;
    constructor(db: Database<any>, model: Model);
    column(name: string): ColumnInfo;
    keyColumn(): ColumnInfo;
    getParentField(model?: Model): ForeignKeyField;
    getAncestors(row: Value | Document, filter?: TableFilter<TSpec> | Filter): Promise<Document[]>;
    getDescendants(row: Value | Document, filter?: TableFilter<TSpec> | Filter): Promise<Document[]>;
    select<T extends object = TableRow<TSpec>>(fields: SelectFields<any> | string | Document | string[], options?: SelectOptions<TableFilter<TSpec> | Filter>, filterThunk?: (builder: QueryBuilder) => string, connection?: Connection): Promise<T[]>;
    first<T extends object = TableRow<TSpec>>(fields: SelectFields<any> | string | Document | string[], filter?: TableFilter<TSpec> | Filter, orderBy?: OrderBy): Promise<T>;
    _resolveRelatedFields(connection: Connection, result: Document[], fields: string | Document): Promise<Document[]>;
    get<T extends object = TableRow<TSpec>>(key: Value | TableFilter<TSpec> | Filter): Promise<T>;
    insert<T = number>(data: TableInsert<TSpec>): Promise<T>;
    create<T extends object = TableRow<TSpec>>(data: TableCreate<TSpec>, options?: MutationOptions<T>): Promise<T>;
    update<T = any>(data: TableUpdate<TSpec>, filter?: TableFilter<TSpec>): Promise<T>;
    upsert<T extends object = TableRow<TSpec>>(data: TableCreate<TSpec>, update?: TableUpdate<TSpec>, options?: MutationOptions<T>): Promise<T>;
    modify<T extends object = TableRow<TSpec>>(data: TableUpdate<TSpec>, filter: TableFilter<TSpec>, options?: MutationOptions<T>): Promise<T>;
    private _call;
    delete<T extends Document = Document>(filter?: Filter): Promise<T>;
    replace(data: Document): Promise<Record>;
    count(filter?: Filter, expr?: string): Promise<number>;
    existing(data: Document): Promise<Array<{
        row: Document;
        constraint: Constraint;
    }>>;
    private _name;
    private _where;
    private _pair;
    private _select;
    _update(connection: Connection, fields: Document, filter: Filter): Promise<any>;
    _insert(connection: Connection, data: Row): Promise<any>;
    _delete(connection: Connection, filter?: Filter): Promise<any>;
    /**
     * Deletes rows matching `filter` one level at a time, leaves first, following a
     * self-referential foreign key. This avoids relying on the database's ON DELETE
     * CASCADE for the self-reference, whose cascade depth MySQL caps (error 6575:
     * "Foreign key cascade delete/update exceeds max tables limit"). It assumes the
     * matched set is closed under descendants, which holds for replaceRecordsIn (a
     * kept record's parent is always kept too).
     */
    _deleteLeaves(connection: Connection, filter: Filter, selfField: ForeignKeyField): Promise<void>;
    escapeName(name: SimpleField | string | number): string;
    escapeValue(field: SimpleField | string, value: Value): string;
    _get(connection: Connection, key: Value | Filter): Promise<Document>;
    _resolveParentFields(connection: Connection, input: Document, filter?: Filter): Promise<Row>;
    private _returning;
    _create(connection: Connection, data: Document, options?: MutationOptions): Promise<Document>;
    private _upsert;
    private _modify;
    private _updateChildFields;
    private _updateChildField;
    _disconnectUnique(connection: Connection, field: SimpleField, id: Value): Promise<any>;
    _connectThrough(connection: Connection, related: RelatedField, value: Value, args: Document[]): Promise<any>;
    private _createThrough;
    private _upsertThrough;
    private _updateThrough;
    _deleteThrough(connection: Connection, related: RelatedField, value: Value, args: Document[]): Promise<any>;
    _disconnectThrough(connection: Connection, related: RelatedField, value: Value, args: Document[]): Promise<any>;
    claim(filter: Filter, data: Document, orderBy?: string[]): Promise<Document>;
    append(data?: {
        [key: string]: any;
    } | any[]): Record;
    connect(data?: {
        [key: string]: any;
    } | any[]): Record;
    clear(): void;
    getDirtyCount(): number;
    json(): Document[];
    _mapGet(record: Record): Record | undefined;
    _mapPut(record: Record): void;
    _initMap(): void;
    _selectRelated(connection: Connection, field: RelatedField, values: Value[], fields: string | Document, selectOptions: SelectOptions): Promise<(Document | Document[] | DocumentValue[])[]> | Promise<(string | number | boolean | Date | import("./types").JsonValue[] | Document | import("./types").ScalarValue[] | Document[] | null | undefined)[] | DocumentValue[][]>;
    xappend(data: Document | Document[], fields: RecordConfig, defaults?: Document, keys?: string[]): Promise<string>;
    xselect(fields: RecordConfig, options?: SelectOptions, keys?: string[]): Promise<{
        [key: string]: any;
    }[]>;
    _xselect(config: RecordConfig, options?: SelectOptions): Promise<Document[]>;
    selectTree(filter: Filter, options?: FieldOptions): Promise<Document[] | null>;
    mock(data?: Document, save?: boolean): Promise<Record>;
    mockMany(data: Document[], save?: boolean): Promise<Record[]>;
}
export declare function _toCamel(value: Value | any, field: SimpleField): Value | any;
export declare function toDocument(row: Row, model: Model, fieldMap?: FieldMap): Document;
export declare function isEmpty(value: Value | Record | any): boolean;
export declare function shouldSelectSeparately(model: Model, fields: string | Document): boolean;
export declare function getUniqueFields(model: Model, row: Document): Row | undefined;