import type Mysql from 'mysql';
import type Pg from 'pg';
import type { Resolvable } from '../sbvr-api/common-types.js';
import { Engines } from '@balena/abstract-sql-compiler';
import { EventEmitter } from 'eventemitter3';
import { TypedError } from 'typed-error';
export declare const metrics: EventEmitter<string | symbol, any>;
export interface CodedError extends Error {
    code: number | string;
}
export interface Row {
    [fieldName: string]: any;
}
export interface Result {
    rows: Row[];
    rowsAffected: number;
    insertId?: number | undefined;
}
export type Sql = string;
export type Bindings = any[];
export declare class DatabaseError extends TypedError {
    code?: number | string;
    constructor(message?: string | CodedError | SQLError);
}
export declare class ConstraintError extends DatabaseError {
}
export declare class UniqueConstraintError extends ConstraintError {
}
export declare class ForeignKeyConstraintError extends ConstraintError {
}
export declare class CheckConstraintError extends ConstraintError {
}
export declare class ExclusionConstraintError extends ConstraintError {
}
export declare class TransactionClosedError extends DatabaseError {
}
export declare class ReadOnlyViolationError extends DatabaseError {
}
declare const alwaysExport: {
    DatabaseError: typeof DatabaseError;
    ConstraintError: typeof ConstraintError;
    UniqueConstraintError: typeof UniqueConstraintError;
    ForeignKeyConstraintError: typeof ForeignKeyConstraintError;
    CheckConstraintError: typeof CheckConstraintError;
    ExclusionConstraintError: typeof ExclusionConstraintError;
    TransactionClosedError: typeof TransactionClosedError;
    ReadOnlyViolationError: typeof ReadOnlyViolationError;
};
type BaseDatabase = typeof alwaysExport;
interface TransactionFn {
    <T>(fn: (tx: Tx) => Resolvable<T>, options?: {
        timeoutMS?: number;
    }): Promise<T>;
    (): Promise<Tx>;
}
export interface Database extends BaseDatabase {
    engine: Engines;
    executeSql: (this: Database, sql: Sql, bindings?: Bindings) => Promise<Result>;
    transaction: TransactionFn;
    readTransaction: TransactionFn;
}
interface EngineParams {
    [engine: string]: (options: unknown) => Database;
}
export declare const engines: EngineParams;
export declare function registerTransactionLockNamespace(namespaceKey: string, namespaceId: number): void;
declare class AutomaticClose {
    private stackTraceErr?;
    private automaticCloseTimeout;
    private automaticClose;
    private pending;
    private timeoutMS;
    constructor(tx: Tx, stackTraceErr?: Error | undefined, timeoutMS?: number);
    incrementPending(): void;
    decrementPending(): void;
    cancelPending(): void;
}
export declare abstract class Tx {
    protected readOnly: boolean;
    private closed;
    protected automaticClose: AutomaticClose | undefined;
    constructor(readOnly: boolean, stackTraceErr?: Error | AutomaticClose, timeoutMS?: number);
    private closeTransaction;
    isClosed(): boolean;
    protected abstract clone(readOnly?: boolean): Tx;
    asReadOnly(): Tx;
    isReadOnly(): boolean;
    executeSql(sql: Sql, bindings?: Bindings, ...args: any[]): Promise<Result>;
    protected $executeSql(sql: Sql, bindings?: Bindings, ...args: any[]): Promise<Result>;
    rollback(): Promise<void>;
    end(): Promise<void>;
    disableAutomaticClose(): void;
    private listeners;
    on<T extends keyof Tx['listeners']>(name: T, fn: Tx['listeners'][T][number]): void;
    private clearListeners;
    protected abstract _executeSql(sql: Sql, bindings: Bindings, addReturning?: false | string): Promise<Result>;
    protected abstract _rollback(): Promise<void>;
    protected abstract _commit(): Promise<void>;
    getTxLevelLock(_namespaceKey: string, _key: number, _blocking?: boolean): Promise<boolean>;
    abstract tableList(extraWhereClause?: string): Promise<Result>;
    dropTable(tableName: string, ifExists?: boolean): Promise<Result>;
}
interface EngineParams {
    postgres: (options: string | Pg.PoolConfig | {
        primary: Pg.PoolConfig;
        replica?: Pg.PoolConfig;
    }) => Database;
}
interface EngineParams {
    mysql: (options: Mysql.PoolConfig) => Database;
}
interface EngineParams {
    websql: (databaseName: string) => Database;
}
export type DatabaseOptions<T extends keyof EngineParams> = {
    engine: T;
    params: Parameters<EngineParams[T]>[0];
};
export declare const connect: <T extends keyof EngineParams>(databaseOptions: DatabaseOptions<T>) => Database;
export {};