import { UniversalDAO } from '../core/universal-dao';
import { SQLiteRow } from '../types';
export interface QueryCondition {
    field: string;
    operator: string;
    value: any;
}
export interface JoinClause {
    type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL OUTER';
    table: string;
    condition: string;
}
export interface SubQuery {
    query: QueryBuilder;
    alias: string;
}
/**
 * Enhanced QueryBuilder with advanced SQL query construction capabilities
 */
export declare class QueryBuilder {
    private tableName;
    private selectFields;
    private joinClauses;
    private whereConditions;
    private groupByFields;
    private havingConditions;
    private orderByFields;
    private limitValue;
    private offsetValue;
    private params;
    private unionQueries;
    private subQueries;
    private cteQueries;
    private dao;
    constructor(dao?: UniversalDAO);
    static table(name: string, dao?: UniversalDAO): QueryBuilder;
    static from(name: string, dao?: UniversalDAO): QueryBuilder;
    select(fields: string | string[]): QueryBuilder;
    selectRaw(raw: string): QueryBuilder;
    selectDistinct(fields: string | string[]): QueryBuilder;
    join(table: string, condition: string, type?: JoinClause['type']): QueryBuilder;
    innerJoin(table: string, condition: string): QueryBuilder;
    leftJoin(table: string, condition: string): QueryBuilder;
    rightJoin(table: string, condition: string): QueryBuilder;
    fullOuterJoin(table: string, condition: string): QueryBuilder;
    where(field: string, operator: string, value?: any): QueryBuilder;
    where(field: string, value: any): QueryBuilder;
    where(conditions: Record<string, any>): QueryBuilder;
    whereEquals(field: string, value: any): QueryBuilder;
    whereNot(field: string, value: any): QueryBuilder;
    whereLike(field: string, value: string): QueryBuilder;
    whereNotLike(field: string, value: string): QueryBuilder;
    whereIn(field: string, values: any[]): QueryBuilder;
    whereNotIn(field: string, values: any[]): QueryBuilder;
    whereBetween(field: string, min: any, max: any): QueryBuilder;
    whereNotBetween(field: string, min: any, max: any): QueryBuilder;
    whereNull(field: string): QueryBuilder;
    whereNotNull(field: string): QueryBuilder;
    whereExists(subquery: QueryBuilder): QueryBuilder;
    whereNotExists(subquery: QueryBuilder): QueryBuilder;
    orWhere(field: string, operator: string, value?: any): QueryBuilder;
    orWhere(field: string, value: any): QueryBuilder;
    groupBy(fields: string | string[]): QueryBuilder;
    having(field: string, operator: string, value?: any): QueryBuilder;
    havingCount(field: string, operator: string, value: number): QueryBuilder;
    orderBy(field: string, direction?: 'ASC' | 'DESC'): QueryBuilder;
    orderByDesc(field: string): QueryBuilder;
    orderByRaw(raw: string): QueryBuilder;
    latest(field?: string): QueryBuilder;
    oldest(field?: string): QueryBuilder;
    limit(count: number): QueryBuilder;
    offset(count: number): QueryBuilder;
    skip(count: number): QueryBuilder;
    take(count: number): QueryBuilder;
    firstRow(): QueryBuilder;
    paginate(page: number, perPage: number): QueryBuilder;
    union(query: QueryBuilder): QueryBuilder;
    unionAll(query: QueryBuilder): QueryBuilder;
    with(alias: string, query: QueryBuilder): QueryBuilder;
    whereSubQuery(field: string, operator: string, subquery: QueryBuilder): QueryBuilder;
    count(field?: string): QueryBuilder;
    sum(field: string): QueryBuilder;
    avg(field: string): QueryBuilder;
    max(field: string): QueryBuilder;
    min(field: string): QueryBuilder;
    toSQL(): {
        sql: string;
        params: any[];
    };
    private buildCondition;
    get(): Promise<SQLiteRow[]>;
    first(): Promise<SQLiteRow | null>;
    pluck(column: string): Promise<any[]>;
    exists(): Promise<boolean>;
    countResult(): Promise<number>;
    static insert(tableName: string, data: Record<string, any>): {
        sql: string;
        params: any[];
    };
    static insertMany(tableName: string, dataArray: Record<string, any>[]): {
        sql: string;
        params: any[];
    };
    static update(tableName: string, data: Record<string, any>, where: string, whereParams?: any[]): {
        sql: string;
        params: any[];
    };
    static delete(tableName: string, where: string, whereParams?: any[]): {
        sql: string;
        params: any[];
    };
    static upsert(tableName: string, data: Record<string, any>, conflictColumns: string[]): {
        sql: string;
        params: any[];
    };
    clone(): QueryBuilder;
    toRawSQL(): string;
    explain(): QueryBuilder;
}
//# sourceMappingURL=query-builder.d.ts.map