import { DocumentQueryOptions, Document, PaginatedResponse } from "./types";
import type { NexaBase } from "./client";
export declare class NexaQuery {
    private client;
    private collection;
    private options;
    constructor(client: NexaBase, collection: string);
    /**
     * Selecciona campos específicos que se devolverán (traduce a SELECT en SQL).
     * Alias: fields()
     * @example .select('id,nombre,fecha_solicitud')
     */
    select(fields: string): NexaQuery;
    /**
     * Alias de select() — selecciona campos específicos.
     * @example .fields('id,nombre,fecha_solicitud')
     */
    fields(fields: string): NexaQuery;
    /**
     * Añade un filtro de igualdad
     */
    where(field: string, value: any): NexaQuery;
    /**
     * Añade un filtro con operador relacional (ej. '>', '<', 'like', 'in')
     */
    where(field: string, operator: string, value: any): NexaQuery;
    /**
     * Crea un grupo de filtros (AND/OR anidado)
     * @example
     * .whereGroup(q => q.where('status', 'active').where('price', '>', 100), 'OR')
     */
    whereGroup(callback: (q: NexaQuery) => void, logical?: 'AND' | 'OR'): NexaQuery;
    /**
     * Define el operador lógico para combinar los filtros (AND por defecto)
     */
    logical(operator: 'AND' | 'OR'): NexaQuery;
    /**
     * Ordena los resultados. Usa '-' para DESC.
     * @example .sort('-created_at,nombre')
     */
    sort(sort: string): NexaQuery;
    /**
     * Limita el número de resultados (per_page)
     */
    limit(per_page: number): NexaQuery;
    /**
     * Salta un número de páginas
     */
    page(page: number): NexaQuery;
    /**
     * Incluye metadata o relaciones adicionales.
     * @example .include('schema')
     */
    include(include: string): NexaQuery;
    /**
     * Agrupa los resultados por uno o más campos (Phase 14).
     * @example .groupBy('estado')
     * @example .groupBy(['estado', 'mes'])
     */
    groupBy(fields: string | string[]): NexaQuery;
    /**
     * Cuenta registros.
     * @example .count('*', 'total')
     */
    count(field?: string, alias?: string): NexaQuery;
    /**
     * Suma valores de un campo.
     * @example .sum('monto', 'total_monto')
     */
    sum(field: string, alias?: string): NexaQuery;
    /**
     * Promedio de un campo.
     */
    avg(field: string, alias?: string): NexaQuery;
    /**
     * Valor mínimo.
     */
    min(field: string, alias?: string): NexaQuery;
    /**
     * Valor máximo.
     */
    max(field: string, alias?: string): NexaQuery;
    /**
     * Extrae el mes de un campo de fecha.
     * @example .month('fecha_solicitud', 'mes_nombre')
     */
    month(field: string, alias?: string): NexaQuery;
    /**
     * Extrae el año de un campo de fecha.
     */
    year(field: string, alias?: string): NexaQuery;
    /**
     * Extrae el día de un campo de fecha.
     */
    day(field: string, alias?: string): NexaQuery;
    private addAggregate;
    /**
     * Realiza la búsqueda de texto
     */
    search(query: string): NexaQuery;
    /**
     * @internal Retorna las opciones actuales (para anidamiento)
     */
    getOptions(): DocumentQueryOptions;
    /**
     * Ejecuta la consulta y retorna los resultados.
     *
     * Siempre usa queryDocuments (POST /query, cuerpo JSON) en vez de
     * listDocuments (GET, query string). Antes se elegía entre las dos según
     * si la query tenía lógica OR/grupos anidados - pero esa decisión era
     * invisible para quien escribe la query y las dos rutas del backend NO
     * comparten la misma normalización de filtros, lo que hacía que la MISMA
     * llamada a .where() se comportara distinto según qué más hubiera en la
     * cadena. Casos concretos que se rompían por GET: valores `null`
     * (encontraba filas por GET, 0 resultados por POST - ver fix del backend),
     * y valores no-string como `Date` (se serializaban con `String(value)` en
     * la query string, perdiendo el formato ISO que sí preserva JSON.stringify
     * en el body de POST). POST es la ruta correcta y más robusta - GET queda
     * como legacy interno del client, ya no lo usa el builder.
     */
    get(): Promise<PaginatedResponse<Document>>;
    /**
     * Ejecuta la consulta y retorna el primer resultado.
     */
    first(): Promise<Document | null>;
}