import { Req } from "badmfck-signal";
import { BaseService } from "./BaseService";
import { IDBAdapter } from "./db/IDBAdapter";
export interface IDBQueryField {
    name?: string | null;
    value: string | number | boolean | Date | null | undefined;
    system?: boolean;
    ignoreInInsert?: boolean;
    ignoreInUpdate?: boolean;
    useInReplace?: boolean;
    __parsedValue?: string | number | boolean | null | undefined;
    fields?: Record<string, number | boolean | string | null>;
}
export interface IDBQueryFields {
    [key: string]: string | number | boolean | Date | IDBQueryField | null | undefined;
}
export interface IDBQuery {
    dbid?: string;
    query: string;
    fields?: IDBQueryFields;
    throwable?: boolean;
    onDuplicateErrorText?: string;
    onErrorText?: string;
    transactionID?: number;
    rollbackOnFail?: boolean;
    calculateCount?: boolean;
    parseQueryOnly?: boolean;
    debug?: boolean;
}
export interface IDBBulkQueryItem {
    query: string;
    fields: IDBQueryFields;
    throwable?: boolean;
    calculateCount?: boolean;
}
export interface IDBBulkQuery {
    dbid?: string;
    bulk: IDBBulkQueryItem[];
    queued?: boolean;
}
export interface IDBError {
    code: string;
    errno: number;
    fatal: boolean;
    sql: string;
    name: string;
    message: string;
    isDuplicateError: boolean;
}
export interface IDBResult {
    data?: any | null;
    error?: IDBError | null;
    total?: number;
    execution: {
        started_at: number;
        finished_at: number;
    };
}
export interface IDBSericeOptions {
    id: string;
    type: "mysql" | "postgres";
    connection: DBAdapterOptions;
}
export interface DBAdapterOptions {
    connectionLimit: number;
    host: string;
    user: string;
    password: string;
    port: number;
    database: string;
    connectionParamers?: string;
    idleTimeoutMillis?: number;
    connectionTimeoutMillis?: number;
    queueLimit?: number;
    transactionFailReport?: (trx: any, message: string) => void;
    transactionFailReportDir?: string;
    maxTransactionWaitTime?: number;
    maxQueryTimeout?: number;
    debug?: boolean;
}
export interface IPoolStatus {
    lastSuccessQueryTime: string;
    poolConnections: number;
    acquiredPoolConnections: number;
}
export interface IDBStatFrame {
    transactionsCount: number;
    averageQueryTime: number;
    totalQueries: number;
    maxQueryTime: number;
    minQueryTime: number;
    failedQueries: number;
    longestQueries: {
        query: string;
        execution: number;
    }[];
}
export declare const REQ_DB: Req<IDBQuery, IDBResult>;
export declare const REQ_DBX: Req<IDBBulkQuery, IDBResult[]>;
export declare const REQ_DB_TBEGIN: Req<{
    dbid: string;
}, IDBResult>;
export declare const REQ_DB_TCOMMIT: Req<{
    dbid: string;
    trxid: number;
}, IDBResult>;
export declare const REQ_DB_TROLLBACK: Req<{
    dbid: string;
    trxid: number;
}, IDBResult>;
export declare class DBService extends BaseService {
    static allInstances: DBService[];
    options: IDBSericeOptions;
    adapter: IDBAdapter | null;
    constructor(options: IDBSericeOptions);
    init(): Promise<void>;
    static escape(id: string, value: any): string;
    getAdapter(dbid?: string | null): IDBAdapter | IDBError;
    static healthcheck(range?: "hour" | "day" | "week"): {
        id: string;
        host: string;
        port: number;
        poolStatus: IPoolStatus | null;
        stat: (IDBStatFrame & {
            slot: number;
        })[] | null;
    }[];
    private static aggregateStat;
    finishService(): Promise<void>;
    createMysqlDatabase(): Promise<void>;
}