import { Connection, QueryCounter, ConnectionPool, Dialect } from '.';
interface PoolOptions {
    connectionLimit?: number;
    connectionWait?: number;
    driver: string;
    database: string;
}
type Client<Connection> = {
    resolve: (connection: Connection) => void;
    reject: (reason: any) => void;
    createdAt: number;
    id: number;
};
export declare class GenericPool<Resource extends {
    end: () => void;
    history: QueryHistory;
}> {
    private create;
    maxSize: number;
    maxClientWaitTime: number;
    idle: Array<Resource>;
    busy: Array<Resource>;
    queue: Array<Client<Resource>>;
    nextClientId: number;
    intervalId: any;
    constructor(create: () => Resource, maxSize?: number, maxClientWaitTime?: number);
    get connectionCount(): number;
    allocate(): Promise<Resource>;
    assign(client: Client<Resource>): void;
    reclaim(item: Resource): void;
    end(): Promise<void>;
    checkConnectionLeak(): void;
}
export declare class _ConnectionPool extends ConnectionPool {
    dialect: Dialect;
    options: PoolOptions;
    pool: GenericPool<_Connection>;
    constructor(options: PoolOptions);
    get connectionCount(): number;
    getConnection(): Promise<Connection>;
    end(): Promise<void>;
    escape(value: string): string;
    escapeId(name: string): string;
    escapeDate(date: Date): string;
}
type GenericCommandResult = {
    insertId: number;
    affectedRowCount: number;
};
type GenericRow = {
    [key: string]: number | string | Buffer | null;
};
export type GenericQueryResult = GenericCommandResult | Array<GenericRow>;
type GenericError = {
    code: number;
    message: string;
};
type GenericConnection = {
    query: (query: string, callback: (error: GenericError | null, result?: GenericQueryResult) => void) => void;
    close: () => void;
};
type Driver = {
    Connection: {
        new (connStr: string): GenericConnection;
    };
};
export declare class QueryRecord {
    query: string;
    startTime: Date;
    endTime?: Date;
    error?: any;
    constructor(query: string);
    close(error: any): void;
}
export declare class QueryHistory {
    records: QueryRecord[];
    constructor();
    clear(): void;
    push(query: string): QueryRecord;
    last(): QueryRecord | null;
}
declare class _Connection extends Connection {
    _pool?: _ConnectionPool;
    _connected?: boolean;
    dialect: Dialect;
    driver: Driver;
    connection: GenericConnection;
    queryCounter: QueryCounter;
    history: QueryHistory;
    constructor(options: {
        driver: string;
        database: string;
    });
    release(): Promise<void>;
    _query(sql: string): Promise<any[] | any>;
    end(): Promise<void>;
    escape(value: string): string;
    escapeId(name: string): string;
    escapeDate(date: Date): string;
}
declare const _default: {
    createConnectionPool: (options: PoolOptions) => ConnectionPool;
    createConnection: (options: {
        driver: string;
        database: string;
    }) => Connection;
};
export default _default;
export declare function logError(error: any): void;