import { Connection, QueryCounter, ConnectionPool, Dialect } from '.';
import { Database as SchemaInfo, Column as ColumnInfo } from '../types';
interface ClientConfig {
    database?: string;
    [key: string]: unknown;
}
interface PoolConfig extends ClientConfig {
    connectionLimit?: number;
    max?: number;
}
interface QueryResult {
    command: string;
    rowCount: number | null;
    rows: {
        [key: string]: unknown;
    }[];
}
interface Client {
    connect(): Promise<void>;
    query(sql: string): Promise<QueryResult>;
    end(): Promise<void>;
}
interface PoolClient {
    query(sql: string): Promise<QueryResult>;
    release(): void;
}
interface Pool {
    connect(): Promise<PoolClient>;
    end(): Promise<void>;
}
declare const Pool: new (config?: PoolConfig) => Pool, Client: new (config?: ClientConfig) => Client;
export declare class _ConnectionPool extends ConnectionPool {
    dialect: Dialect;
    pool: Pool;
    constructor(options: PoolConfig);
    getConnection(): Promise<Connection>;
    end(): Promise<void>;
    escape(value: string): string;
    escapeId(name: string): string;
    escapeDate(date: Date): string;
}
export declare class _Connection extends Connection {
    dialect: Dialect;
    connection: Client | PoolClient;
    queryCounter: QueryCounter;
    constructor(options: ClientConfig | PoolClient, connected?: string);
    release(): void;
    _query(sql: string, pk?: string): Promise<any[] | any>;
    end(): Promise<void>;
    escape(value: string): string;
    escapeId(name: string): string;
    escapeDate(date: Date): string;
}
type ColumnUsage = {
    column: string;
    position: number | null;
};
type ColumnUsageMap = {
    [key: string]: {
        [key: string]: ColumnUsage[];
    };
};
type ForeignKeyMap = {
    [key: string]: {
        [key: string]: {
            table: string;
            constraint: string;
        };
    };
};
declare class SchemaBuilder {
    connection: Connection;
    catalogName: string;
    escapedCatalogName: string;
    escapedSchemaName: string;
    constructor(connection: Connection, catalogName: string, schemaName?: string);
    get dialet(): Dialect;
    getResult(): Promise<SchemaInfo>;
    getTableMap(): Promise<{
        [key: string]: string;
    }>;
    getColumns(): Promise<{
        [key: string]: ColumnInfo[];
    }>;
    getTableConstraints(): Promise<{
        [key: string]: {
            [key: string]: string;
        };
    }>;
    getKeyColumnUsage(): Promise<ColumnUsageMap>;
    getForeignKeyMap(): Promise<ForeignKeyMap>;
    getEnumMap(): Promise<{
        [key: string]: string[];
    }>;
}
declare const _default: {
    createConnectionPool: (options: PoolConfig) => ConnectionPool;
    createConnection: (options: ClientConfig | PoolClient) => Connection;
    SchemaBuilder: typeof SchemaBuilder;
};
export default _default;