import { Pool, ClientConfig, PoolClient } from "pg";
import { Database as SqliteDatabase } from "better-sqlite3";
export interface Database {
    database?: string;
    user?: string;
    password?: string;
    host?: string;
    port?: number;
    ssl?: boolean;
    sslmode?: string;
}
export declare type env = "production" | "test" | "development";
export declare type DBDict = Record<env, Database>;
export declare enum Dialect {
    Postgres = "postgres",
    SQLite = "sqlite"
}
interface DatabaseInfo {
    dialect: Dialect;
    config: ClientConfig;
    filePath?: string;
}
export default class DB {
    db: DatabaseInfo;
    static instance: DB;
    static dialect: Dialect;
    private pool;
    private q;
    private constructor();
    getConnection(): Connection;
    getPool(): Queryer;
    getNewClient(): Promise<Client>;
    getSQLiteClient(): Promise<Sqlite>;
    endPool(): Promise<void>;
    static getInstance(): DB;
    static getDialect(): Dialect;
    static initDB(args?: {
        connectionString?: string;
        dbFile?: string;
        db?: Database | DBDict;
    }): void;
}
export declare const defaultTimestampParser: any;
export interface Queryer {
    query(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
    queryAll(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
    exec(query: string, values?: any[]): Promise<ExecResult>;
}
export interface SyncQueryer extends Queryer {
    execSync(query: string, values?: any[]): ExecResult;
    queryAllSync(query: string, values?: any[]): QueryResult<QueryResultRow>;
    querySync(query: string, values?: any[]): QueryResult<QueryResultRow>;
}
export interface Connection extends Queryer {
    self(): Queryer;
    newClient(): Promise<Client>;
    close(): Promise<void>;
}
export interface QueryResultRow {
    [column: string]: any;
}
export interface QueryResult<R extends QueryResultRow = any> {
    rows: R[];
    rowCount: number;
}
interface ExecResult {
    rows: QueryResultRow[];
    rowCount: number;
}
export interface Client extends Queryer {
    release(err?: Error | boolean): void;
}
export interface SyncClient extends Client, SyncQueryer {
    runInTransaction(cb: () => void): void;
}
export declare class Sqlite implements Connection, SyncClient {
    db: SqliteDatabase;
    constructor(db: SqliteDatabase);
    self(): this;
    newClient(): Promise<this>;
    query(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
    private convertValues;
    querySync(query: string, values?: any[]): QueryResult<QueryResultRow>;
    queryAll(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
    queryAllSync(query: string, values?: any[]): QueryResult<QueryResultRow>;
    exec(query: string, values?: any[]): Promise<ExecResult>;
    execSync(query: string, values?: any[]): ExecResult;
    close(): Promise<void>;
    release(err?: Error | boolean): Promise<void>;
    runInTransaction(cb: () => void | Promise<void>): void;
}
export declare class Postgres implements Connection {
    private pool;
    constructor(pool: Pool);
    self(): this;
    newClient(): Promise<PostgresClient>;
    query(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
    queryAll(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
    exec(query: string, values?: any[]): Promise<ExecResult>;
    close(): Promise<void>;
}
export declare class PostgresClient implements Client {
    private client;
    constructor(client: PoolClient);
    query(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
    queryAll(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
    exec(query: string, values?: any[]): Promise<ExecResult>;
    release(err?: Error | boolean): Promise<void>;
}
export {};