import { type WhereObject } from '../types/query.types';
export declare abstract class BaseEntityClass<T = any> {
    static $table: string;
}
export declare class QueryBuilder<T = any> {
    private sql;
    private extra;
    private dbName;
    private dbType;
    private tableName;
    private entity;
    private data;
    private is_typeorm;
    private where_values;
    private isDebug;
    private debugFunc;
    constructor(dbName: string, table: string | (new () => T) | typeof BaseEntityClass<T>, opt?: any);
    select<K extends keyof T>(fields?: K[]): this;
    private fields;
    order<K extends keyof T>(orderby: K[], type?: 'ASC' | 'DESC'): this;
    limit(limit: number): this;
    offset(offset: number): this;
    first(): Promise<T>;
    end(): Promise<T>;
    private selectMethods;
    count<K extends keyof T>(fields?: K): Promise<number>;
    max<K extends keyof T>(field: K): Promise<number>;
    min<K extends keyof T>(field: K): Promise<number>;
    avg<K extends keyof T>(field: K): Promise<number>;
    sum<K extends keyof T>(field: K): Promise<number>;
    update(set_values: Partial<T> | Partial<T>): this;
    private set;
    delete(): this;
    where(...where_values: (string | WhereObject<Partial<T> | Partial<T>>)[]): this;
    insert(into_values: Partial<T>): Promise<boolean>;
    private values;
    isIgnoreValue(value: any): boolean;
    isIgnoreField(fields: any[]): boolean;
    debug(type?: 'now' | 'final', func?: (sql: string, data: any) => void): this;
    exists(): Promise<boolean>;
    clone<C = T>(opt?: {
        db?: string;
        table?: string | (new () => C) | typeof BaseEntityClass<C>;
    }): QueryBuilder<C>;
    raw(query: string, values?: (string | number | boolean | null)[]): Promise<any>;
    toSQL(): [string, any[]];
    pluck<K extends keyof T>(field: K): Promise<Array<any>>;
    between<K extends keyof T>(field: K, start: number, end: number): Promise<any>;
    disconnect(): Promise<void>;
    reconnect(): Promise<this>;
    run<R = any>(): Promise<R>;
}