import { Document, PaginatedResponse } from "./types";
import type { NexaBase } from "./client";
export declare class NexaQueryBuilder {
    private client;
    private collection;
    private _filters;
    private _data;
    private _options;
    constructor(client: NexaBase, collection: string);
    private addFilter;
    where(field: string, value: any): NexaQueryBuilder;
    where(field: string, operator: string, value: any): NexaQueryBuilder;
    orWhere(field: string, value: any): NexaQueryBuilder;
    orWhere(field: string, operator: string, value: any): NexaQueryBuilder;
    whereIn(field: string, values: any[]): NexaQueryBuilder;
    whereNotIn(field: string, values: any[]): NexaQueryBuilder;
    whereNull(field: string): NexaQueryBuilder;
    whereNotNull(field: string): NexaQueryBuilder;
    whereBetween(field: string, start: any, end: any): NexaQueryBuilder;
    whereStartsWith(field: string, value: string): NexaQueryBuilder;
    whereEndsWith(field: string, value: string): NexaQueryBuilder;
    whereLike(field: string, value: string): NexaQueryBuilder;
    whereILike(field: string, value: string): NexaQueryBuilder;
    set(data: Record<string, any>): NexaQueryBuilder;
    insert(data: Record<string, any>): NexaQueryBuilder;
    insertGetId(data?: Record<string, any>): Promise<Document>;
    insertWithFile(data: Record<string, any>, file: File, fieldName?: string): Promise<any>;
    /**
     * Inserta muchos documentos en una sola request/transacción del lado
     * del servidor (máximo 5000 por llamada — para más, dividir en varias
     * llamadas). Antes este método hacía un `createDocument()` por cada
     * documento en un loop secuencial — parecía "bulk" pero en realidad
     * eran N requests HTTP independientes, cada una con su propia
     * transacción compitiendo por el mismo contador de la colección. Con
     * concurrencia real (varios `insertBulk()` en paralelo, o incluso uno
     * solo con muchos documentos que comparten una FK, ej. el mismo
     * archivo de origen) esto podía terminar en deadlocks reales de
     * Postgres del lado del servidor.
     */
    insertBulk(documents: Record<string, any>[]): Promise<Document[]>;
    update(data: Record<string, any>): NexaQueryBuilder;
    updateGetModified(data?: Record<string, any>): Promise<number>;
    updateFirst(data?: Record<string, any>): Promise<Document | null>;
    updateFirstWithFile(data: Record<string, any>, file: File, fieldName?: string): Promise<any>;
    deleteGetCount(): Promise<number>;
    deleteFirst(): Promise<Document | null>;
    deleteById(id: string): Promise<void>;
    select(...fields: string[]): Promise<PaginatedResponse<Document>>;
    first(): Promise<Document | null>;
    find(id: string): Promise<Document | null>;
    count(): Promise<number>;
    exists(): Promise<boolean>;
    withIdempotency(key: string): NexaQueryBuilder;
    private _getFilteredDocuments;
    private _getFirstFilteredDocument;
    toQuery(): import("./query").NexaQuery;
}
export declare function createQueryBuilder(client: NexaBase, collection: string): NexaQueryBuilder;