import { Database, DatabaseCRUD, DatabaseTools, Result, Where, SelectOptions } from '../db';
import { Query } from './query';
import { Constants, Packet } from './parser';
import { EventNoticer } from '../event';
import { Options } from './opts';
export * from './opts';
export declare class ErrorPacket extends Packet {
    error: Error;
    type: Constants;
    constructor(err: Error);
    toJSON(): Error;
}
interface Callback {
    (err: Error | null, data?: Result[]): void;
}
export declare class Mysql implements Database {
    private _queue;
    private _connection;
    private _connecting;
    private _transaction;
    private _close;
    private _handlError;
    private _handlePacket;
    private _after;
    private _connect;
    private _write;
    private _exec;
    private _enqueue;
    private _dequeue;
    /**
        * is connection
        */
    get connected(): boolean;
    readonly options: Options;
    readonly onError: EventNoticer<Error>;
    /**
    * constructor function
    */
    constructor(options?: Options);
    statistics(): Promise<Result>;
    query(sql: string, cb?: Callback): Query;
    close(): void;
    transaction(): Promise<void>;
    commit(): Promise<void>;
    rollback(): Promise<void>;
    /**
     * exec query database
     */
    exec(sql: string): Promise<Result[]>;
}
export declare class MysqlTools implements DatabaseTools {
    private _name;
    private _load;
    private _db_struct;
    readonly options: Options;
    constructor(options?: Options);
    has(table: string): boolean;
    exec(sql: string): Promise<Result[]>;
    insert(table: string, row: Dict): Promise<number>;
    insertSql(table: string, row: Dict): string;
    delete(table: string, where?: Where): Promise<number>;
    deleteSql(table: string, where?: Where): string;
    update(table: string, row: Dict, where?: Where): Promise<number>;
    updateSql(table: string, row: Dict, where?: Where): string;
    select<T = Dict>(table: string, where?: Where, opts?: SelectOptions): Promise<T[]>;
    selectSql(table: string, where?: Where, opts?: SelectOptions): string;
    selectCount(table: string, where?: Where, opts?: SelectOptions): Promise<number>;
    selectOne<T = Dict>(table: string, where?: Where, opts?: SelectOptions): Promise<T | null>;
    query<T = Dict>(sql: string): Promise<T[]>;
    private _Sql;
    load(SQL: string, SQL_ALTER: string[], SQL_INDEXES: string[], id?: string): Promise<void>;
    scope<T = any>(cb: (db: DatabaseCRUD, self: DatabaseTools) => Promise<T>): Promise<T>;
    transaction<T = any>(cb: (db: DatabaseCRUD, self: DatabaseTools) => Promise<T>): Promise<T>;
    db(): Database;
}