@ponceca/firestore-sdk 0.1.0

package/dist/firestore/index.d.ts

@@ -0,0 +1,1476 @@
+import { g as Firestore, e as FirebaseApp, j as FirestoreSettings, a as DocumentData, l as FirestoreInstance, C as CollectionReference, b as DocumentReference, c as DocumentSnapshot, S as SetOptions, E as EndAtConstraint, Q as Query, k as QuerySnapshot, m as LimitConstraint, O as OrderByDirection, n as OrderByConstraint, o as QueryConstraint, p as StartAtConstraint, W as WhereFilterOp, q as WhereConstraint, r as SnapshotListenOptions, U as Unsubscribe, d as FieldValue } from '../types-meoR-Ecp.js';
+export { A as AuthTokenProvider, D as DocumentChange, s as DocumentChangeType, F as FieldPath, h as FirestoreError, i as FirestoreErrorCode, L as ListenSource } from '../types-meoR-Ecp.js';
+
+/**
+ * Firestore SDK - Firestore Instance
+ * getFirestore, initializeFirestore, connectFirestoreEmulator
+ * API 100% compatible con Firebase v9+
+ */
+
+/**
+ * Obtiene la instancia de Firestore para una app
+ *
+ * @param app Aplicación Firebase (opcional, usa la app por defecto)
+ * @returns Instancia de Firestore
+ *
+ * @example
+ * ```typescript
+ * import { initializeApp } from '@ponceca/firestore-sdk';
+ * import { getFirestore } from '@ponceca/firestore-sdk/firestore';
+ *
+ * const app = initializeApp({
+ *   projectId: 'my-project'
+ * });
+ *
+ * const db = getFirestore(app);
+ * ```
+ */
+declare function getFirestore(app?: FirebaseApp): Firestore;
+/**
+ * Inicializa Firestore con configuración personalizada
+ *
+ * @param app Aplicación Firebase
+ * @param settings Configuración de Firestore
+ * @returns Instancia de Firestore configurada
+ *
+ * @example
+ * ```typescript
+ * const db = initializeFirestore(app, {
+ *   host: 'firestore.example.com',
+ *   ssl: true
+ * });
+ * ```
+ */
+declare function initializeFirestore(app: FirebaseApp, settings: FirestoreSettings): Firestore;
+/**
+ * Termina la instancia de Firestore
+ *
+ * @param firestore Instancia de Firestore
+ */
+declare function terminate(firestore: Firestore): Promise<void>;
+/**
+ * Limpia la persistencia local.
+ * Borra todo el cache de documentos y la cola de mutaciones pendientes.
+ * Debe llamarse cuando Firestore NO está en uso (antes de inicializar o después de terminar).
+ *
+ * @param firestore Instancia de Firestore
+ */
+declare function clearIndexedDbPersistence(firestore: Firestore): Promise<void>;
+/**
+ * Habilita la persistencia offline para Firestore.
+ * Activa el cache local de documentos y la cola de mutaciones para operaciones offline.
+ * Debe llamarse antes de cualquier otra operación con Firestore.
+ *
+ * @param firestore Instancia de Firestore
+ *
+ * @example
+ * ```typescript
+ * const db = getFirestore(app);
+ * await enableIndexedDbPersistence(db);
+ * // Ahora las lecturas/escrituras funcionan offline
+ * ```
+ */
+declare function enableIndexedDbPersistence(firestore: Firestore): Promise<void>;
+/**
+ * Habilita la persistencia offline multi-tab.
+ * Activa la misma persistencia que enableIndexedDbPersistence.
+ * En esta implementación, multi-tab opera igual que single-tab.
+ *
+ * @param firestore Instancia de Firestore
+ */
+declare function enableMultiTabIndexedDbPersistence(firestore: Firestore): Promise<void>;
+/**
+ * Habilita la red — reanuda la comunicación con el servidor.
+ * Sincroniza las mutaciones pendientes en la cola.
+ * Si no hay persistencia habilitada, es un no-op.
+ *
+ * @param firestore Instancia de Firestore
+ */
+declare function enableNetwork(firestore: Firestore): Promise<void>;
+/**
+ * Deshabilita la red — todas las operaciones serán locales.
+ * Las escrituras se acumulan en la cola de mutaciones hasta que se re-habilite.
+ * Las lecturas se servirán desde el cache local.
+ * Si no hay persistencia habilitada, es un no-op.
+ *
+ * @param firestore Instancia de Firestore
+ */
+declare function disableNetwork(firestore: Firestore): Promise<void>;
+/**
+ * Espera a que todas las operaciones pendientes se sincronicen con el servidor.
+ * Resuelve inmediatamente si no hay escrituras pendientes o si la persistencia no está habilitada.
+ *
+ * @param firestore Instancia de Firestore
+ */
+declare function waitForPendingWrites(firestore: Firestore): Promise<void>;
+/**
+ * Conecta Firestore al emulador local
+ * Compatible con Firebase: connectFirestoreEmulator(db, 'localhost', 8080)
+ *
+ * @param firestore Instancia de Firestore
+ * @param host Host del emulador (ej: 'localhost')
+ * @param port Puerto del emulador (ej: 3000)
+ * @param options Opciones adicionales (mockUserToken para auth)
+ *
+ * @example
+ * ```typescript
+ * import { getFirestore, connectFirestoreEmulator } from '@ponceca/firestore-sdk/firestore';
+ *
+ * const db = getFirestore(app);
+ *
+ * // Conectar al emulador local
+ * connectFirestoreEmulator(db, 'localhost', 3000);
+ * ```
+ */
+declare function connectFirestoreEmulator(firestore: Firestore, host: string, port: number, options?: {
+    mockUserToken?: string | object;
+}): void;
+/**
+ * Establece el token de autenticación para Firestore
+ * Útil para integrar con sistemas de auth externos o JWT personalizados
+ *
+ * @param firestore Instancia de Firestore
+ * @param token Token de autenticación (JWT, API Key, etc.) o null para eliminar
+ *
+ * @example
+ * ```typescript
+ * import { getFirestore, setAuthToken } from '@ponceca/firestore-sdk/firestore';
+ *
+ * const db = getFirestore(app);
+ *
+ * // Establecer token JWT
+ * setAuthToken(db, 'eyJhbGciOiJIUzI1NiIs...');
+ *
+ * // O con un token de tu sistema de auth
+ * const userToken = await myAuthSystem.getToken();
+ * setAuthToken(db, userToken);
+ *
+ * // Eliminar token (logout)
+ * setAuthToken(db, null);
+ * ```
+ */
+declare function setAuthToken(firestore: Firestore, token: string | null): void;
+/**
+ * Obtiene el token de autenticación actual
+ *
+ * @param firestore Instancia de Firestore
+ * @returns Token actual o undefined si no hay
+ */
+declare function getAuthToken(firestore: Firestore): string | undefined;
+
+/**
+ * Firestore SDK - Referencias
+ * doc(), collection(), DocumentReference, CollectionReference
+ */
+
+/**
+ * Crea una referencia a un documento
+ *
+ * @param firestore Instancia de Firestore
+ * @param pathSegments Segmentos del path
+ * @returns DocumentReference
+ *
+ * @example
+ * ```typescript
+ * // Path directo
+ * const ref = doc(db, 'users', 'user123');
+ *
+ * // Desde colección
+ * const ref = doc(collection(db, 'users'), 'user123');
+ *
+ * // Subcolección
+ * const ref = doc(db, 'users', 'user123', 'posts', 'post456');
+ * ```
+ */
+declare function doc<T = DocumentData>(firestore: FirestoreInstance, ...pathSegments: string[]): DocumentReference<T>;
+declare function doc<T = DocumentData>(reference: CollectionReference<T>, ...pathSegments: string[]): DocumentReference<T>;
+/**
+ * Crea una referencia a una colección
+ *
+ * @param firestore Instancia de Firestore
+ * @param pathSegments Segmentos del path
+ * @returns CollectionReference
+ *
+ * @example
+ * ```typescript
+ * // Colección de primer nivel
+ * const ref = collection(db, 'users');
+ *
+ * // Subcolección
+ * const ref = collection(db, 'users', 'user123', 'posts');
+ *
+ * // Desde documento
+ * const ref = collection(doc(db, 'users', 'user123'), 'posts');
+ * ```
+ */
+declare function collection<T = DocumentData>(firestore: FirestoreInstance, ...pathSegments: string[]): CollectionReference<T>;
+declare function collection<T = DocumentData>(reference: DocumentReference, ...pathSegments: string[]): CollectionReference<T>;
+
+/**
+ * Firestore SDK - CRUD Operations
+ * getDoc, setDoc, updateDoc, deleteDoc, addDoc
+ */
+
+/**
+ * Obtiene un documento de Firestore
+ *
+ * @param reference Referencia al documento
+ * @returns Promise con DocumentSnapshot
+ *
+ * @example
+ * ```typescript
+ * const docRef = doc(db, 'users', 'user123');
+ * const snapshot = await getDoc(docRef);
+ *
+ * if (snapshot.exists()) {
+ *   console.log('Data:', snapshot.data());
+ * } else {
+ *   console.log('No existe');
+ * }
+ * ```
+ */
+declare function getDoc<T = DocumentData>(reference: DocumentReference<T>): Promise<DocumentSnapshot<T>>;
+/**
+ * Obtiene un documento exclusivamente del cache local.
+ * Compatible con Firestore Web SDK: getDocFromCache(ref)
+ */
+declare function getDocFromCache<T = DocumentData>(reference: DocumentReference<T>): Promise<DocumentSnapshot<T>>;
+/**
+ * Escribe un documento en Firestore
+ * Sobrescribe el documento si existe, lo crea si no existe
+ *
+ * @param reference Referencia al documento
+ * @param data Datos a escribir
+ * @param options Opciones de escritura
+ *
+ * @example
+ * ```typescript
+ * // Sobrescribir completamente
+ * await setDoc(doc(db, 'users', 'user123'), {
+ *   name: 'Juan',
+ *   age: 25
+ * });
+ *
+ * // Merge con datos existentes
+ * await setDoc(doc(db, 'users', 'user123'), {
+ *   age: 26
+ * }, { merge: true });
+ * ```
+ */
+declare function setDoc<T = DocumentData>(reference: DocumentReference<T>, data: T, options?: SetOptions): Promise<void>;
+/**
+ * Obtiene un documento forzando lectura desde el servidor
+ * Siempre hace la petición al servidor, ignorando el cache local.
+ * Actualiza el cache si la persistencia está habilitada.
+ *
+ * @param reference Referencia al documento
+ * @returns Promise con DocumentSnapshot
+ */
+declare function getDocFromServer<T = DocumentData>(reference: DocumentReference<T>): Promise<DocumentSnapshot<T>>;
+/**
+ * Actualiza campos específicos de un documento
+ * El documento debe existir
+ *
+ * Soporta dos formas de invocación:
+ * 1. updateDoc(ref, { field: value, ... })
+ * 2. updateDoc(ref, field, value, ...moreFieldsAndValues)
+ *
+ * @param reference Referencia al documento
+ * @param dataOrField Objeto con campos o nombre del primer campo
+ * @param moreFieldsAndValues Valores alternados field, value, field, value...
+ *
+ * @example
+ * ```typescript
+ * // Forma objeto
+ * await updateDoc(doc(db, 'users', 'user123'), {
+ *   age: 26,
+ *   'address.city': 'Madrid'
+ * });
+ *
+ * // Forma alternada campo/valor
+ * await updateDoc(doc(db, 'users', 'user123'), 'age', 26, 'name', 'Ana');
+ * ```
+ */
+declare function updateDoc<T = DocumentData>(reference: DocumentReference<T>, dataOrField: Partial<T> | string, ...moreFieldsAndValues: unknown[]): Promise<void>;
+/**
+ * Elimina un documento de Firestore
+ *
+ * @param reference Referencia al documento
+ *
+ * @example
+ * ```typescript
+ * await deleteDoc(doc(db, 'users', 'user123'));
+ * ```
+ */
+declare function deleteDoc(reference: DocumentReference): Promise<void>;
+/**
+ * Añade un nuevo documento a una colección con ID auto-generado
+ *
+ * @param reference Referencia a la colección
+ * @param data Datos del documento
+ * @returns Referencia al nuevo documento
+ *
+ * @example
+ * ```typescript
+ * const newDocRef = await addDoc(collection(db, 'users'), {
+ *   name: 'Juan',
+ *   age: 25
+ * });
+ * console.log('Nuevo ID:', newDocRef.id);
+ * ```
+ */
+declare function addDoc<T = DocumentData>(reference: CollectionReference<T>, data: T): Promise<DocumentReference<T>>;
+
+/**
+ * Firestore SDK - Query Builder
+ * query, where, orderBy, limit, limitToLast, startAt, startAfter, endAt, endBefore, getDocs
+ */
+
+/**
+ * Crea una nueva query con las restricciones especificadas
+ *
+ * @param reference Referencia a la colección
+ * @param constraints Restricciones de query
+ * @returns Nueva Query
+ *
+ * @example
+ * ```typescript
+ * const q = query(
+ *   collection(db, 'users'),
+ *   where('age', '>=', 18),
+ *   orderBy('age', 'desc'),
+ *   limit(10)
+ * );
+ * ```
+ */
+declare function query<T = DocumentData>(reference: CollectionReference<T> | Query<T>, ...constraints: QueryConstraint[]): Query<T>;
+declare function where(field: string, op: WhereFilterOp, value: unknown): WhereConstraint;
+/**
+ * Crea una restricción ORDER BY
+ *
+ * @param field Campo por el cual ordenar
+ * @param direction Dirección del orden ('asc' | 'desc')
+ *
+ * @example
+ * ```typescript
+ * orderBy('createdAt', 'desc')
+ * orderBy('name') // 'asc' por defecto
+ * ```
+ */
+declare function orderBy(field: string, direction?: OrderByDirection): OrderByConstraint;
+/**
+ * Limita el número de resultados
+ *
+ * @param n Número máximo de documentos
+ *
+ * @example
+ * ```typescript
+ * limit(10)
+ * ```
+ */
+declare function limit(n: number): LimitConstraint;
+/**
+ * Limita el número de resultados desde el final
+ *
+ * @param n Número máximo de documentos
+ *
+ * @example
+ * ```typescript
+ * limitToLast(5)
+ * ```
+ */
+declare function limitToLast(n: number): LimitConstraint;
+/**
+ * Inicia la query desde un punto específico (inclusivo)
+ *
+ * @param values Valores de cursor
+ *
+ * @example
+ * ```typescript
+ * query(ref, orderBy('age'), startAt(18))
+ * ```
+ */
+declare function startAt(...values: unknown[]): StartAtConstraint;
+/**
+ * Inicia la query después de un punto específico (exclusivo)
+ *
+ * @param values Valores de cursor
+ *
+ * @example
+ * ```typescript
+ * query(ref, orderBy('age'), startAfter(18))
+ * ```
+ */
+declare function startAfter(...values: unknown[]): StartAtConstraint;
+/**
+ * Termina la query en un punto específico (inclusivo)
+ *
+ * @param values Valores de cursor
+ *
+ * @example
+ * ```typescript
+ * query(ref, orderBy('age'), endAt(65))
+ * ```
+ */
+declare function endAt(...values: unknown[]): EndAtConstraint;
+/**
+ * Termina la query antes de un punto específico (exclusivo)
+ *
+ * @param values Valores de cursor
+ *
+ * @example
+ * ```typescript
+ * query(ref, orderBy('age'), endBefore(65))
+ * ```
+ */
+declare function endBefore(...values: unknown[]): EndAtConstraint;
+/**
+ * Ejecuta una query y obtiene los documentos
+ *
+ * @param queryRef Query a ejecutar
+ * @returns Promise con QuerySnapshot
+ *
+ * @example
+ * ```typescript
+ * const q = query(collection(db, 'users'), where('age', '>=', 18));
+ * const snapshot = await getDocs(q);
+ *
+ * snapshot.forEach(doc => {
+ *   console.log(doc.id, '=>', doc.data());
+ * });
+ * ```
+ */
+declare function getDocs<T = DocumentData>(queryRef: Query<T> | CollectionReference<T>): Promise<QuerySnapshot<T>>;
+/**
+ * Obtiene documentos exclusivamente del cache local.
+ * Compatible con Firestore Web SDK: getDocsFromCache(query)
+ */
+declare function getDocsFromCache<T = DocumentData>(queryRef: Query<T> | CollectionReference<T>): Promise<QuerySnapshot<T>>;
+/**
+ * Obtiene documentos forzando lectura desde el servidor
+ * Siempre toca el servidor, ignorando el cache local.
+ * Actualiza el cache si la persistencia está habilitada.
+ *
+ * @param queryRef Query o referencia a colección
+ * @returns Promise con QuerySnapshot
+ */
+declare function getDocsFromServer<T = DocumentData>(queryRef: Query<T> | CollectionReference<T>): Promise<QuerySnapshot<T>>;
+
+/**
+ * Firestore SDK - Real-time Listeners
+ * onSnapshot para documentos y queries
+ */
+
+/**
+ * Callback para cambios en documentos
+ */
+type DocumentSnapshotCallback<T = DocumentData> = (snapshot: DocumentSnapshot<T>) => void;
+/**
+ * Callback para cambios en queries
+ */
+type QuerySnapshotCallback<T = DocumentData> = (snapshot: QuerySnapshot<T>) => void;
+/**
+ * Callback para errores
+ */
+type ErrorCallback = (error: Error) => void;
+/**
+ * Observer para snapshots
+ */
+interface SnapshotObserver<T> {
+    next?: (snapshot: T) => void;
+    error?: (error: Error) => void;
+    complete?: () => void;
+}
+/**
+ * Escucha cambios en un documento en tiempo real
+ *
+ * @param reference Referencia al documento
+ * @param onNext Callback llamado cuando hay cambios
+ * @param onError Callback para errores (opcional)
+ * @returns Función para cancelar la suscripción
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = onSnapshot(
+ *   doc(db, 'users', 'user123'),
+ *   (snapshot) => {
+ *     if (snapshot.exists()) {
+ *       console.log('Data:', snapshot.data());
+ *     }
+ *   },
+ *   (error) => {
+ *     console.error('Error:', error);
+ *   }
+ * );
+ *
+ * // Cancelar suscripción
+ * unsubscribe();
+ * ```
+ */
+declare function onSnapshot<T = DocumentData>(reference: DocumentReference<T>, options: SnapshotListenOptions, onNext: DocumentSnapshotCallback<T>, onError?: ErrorCallback): Unsubscribe;
+/**
+ * Escucha cambios en un documento con opciones y observer
+ */
+declare function onSnapshot<T = DocumentData>(reference: DocumentReference<T>, options: SnapshotListenOptions, observer: SnapshotObserver<DocumentSnapshot<T>>): Unsubscribe;
+/**
+ * Escucha cambios en un documento en tiempo real
+ */
+declare function onSnapshot<T = DocumentData>(reference: DocumentReference<T>, onNext: DocumentSnapshotCallback<T>, onError?: ErrorCallback): Unsubscribe;
+/**
+ * Escucha cambios en un documento con observer
+ */
+declare function onSnapshot<T = DocumentData>(reference: DocumentReference<T>, observer: SnapshotObserver<DocumentSnapshot<T>>): Unsubscribe;
+/**
+ * Escucha cambios en una query en tiempo real
+ *
+ * @param query Query a escuchar
+ * @param onNext Callback llamado cuando hay cambios
+ * @param onError Callback para errores (opcional)
+ * @returns Función para cancelar la suscripción
+ *
+ * @example
+ * ```typescript
+ * const q = query(collection(db, 'messages'), orderBy('timestamp', 'desc'), limit(50));
+ *
+ * const unsubscribe = onSnapshot(q, (snapshot) => {
+ *   snapshot.docChanges().forEach(change => {
+ *     if (change.type === 'added') {
+ *       console.log('Nuevo mensaje:', change.doc.data());
+ *     }
+ *   });
+ * });
+ * ```
+ */
+declare function onSnapshot<T = DocumentData>(query: Query<T> | CollectionReference<T>, options: SnapshotListenOptions, onNext: QuerySnapshotCallback<T>, onError?: ErrorCallback): Unsubscribe;
+/**
+ * Escucha cambios en una query con opciones y observer
+ */
+declare function onSnapshot<T = DocumentData>(query: Query<T> | CollectionReference<T>, options: SnapshotListenOptions, observer: SnapshotObserver<QuerySnapshot<T>>): Unsubscribe;
+/**
+ * Escucha cambios en una query en tiempo real
+ */
+declare function onSnapshot<T = DocumentData>(query: Query<T> | CollectionReference<T>, onNext: QuerySnapshotCallback<T>, onError?: ErrorCallback): Unsubscribe;
+/**
+ * Escucha cambios en una query con observer
+ */
+declare function onSnapshot<T = DocumentData>(query: Query<T> | CollectionReference<T>, observer: SnapshotObserver<QuerySnapshot<T>>): Unsubscribe;
+
+/**
+ * Firestore SDK - Field Values
+ * serverTimestamp, increment, arrayUnion, arrayRemove, deleteField
+ */
+
+/**
+ * Crea un valor que será reemplazado por el timestamp del servidor
+ *
+ * @returns FieldValue representando el timestamp del servidor
+ *
+ * @example
+ * ```typescript
+ * await setDoc(doc(db, 'posts', 'post1'), {
+ *   title: 'Mi post',
+ *   createdAt: serverTimestamp()
+ * });
+ * ```
+ */
+declare function serverTimestamp(): FieldValue;
+/**
+ * Crea un valor que incrementa el campo numérico existente
+ * Soporta números y strings numéricos (para alta precisión).
+ *
+ * @param n Cantidad a incrementar (puede ser negativo)
+ * @returns FieldValue representando el incremento
+ *
+ * @example
+ * ```typescript
+ * await updateDoc(doc(db, 'counters', 'pageViews'), {
+ *   count: increment(1)
+ * });
+ * // Precisión decimal
+ * await updateDoc(doc(db, 'accounts', 'wallet'), {
+ *   balance: increment("100.50")
+ * });
+ * ```
+ */
+declare function increment(n: number | string): FieldValue;
+/**
+ * Crea un valor que añade elementos a un array existente
+ * Solo añade elementos que no existen ya
+ *
+ * @param elements Elementos a añadir
+ * @returns FieldValue representando la unión de arrays
+ *
+ * @example
+ * ```typescript
+ * await updateDoc(doc(db, 'users', 'user1'), {
+ *   tags: arrayUnion('developer', 'javascript')
+ * });
+ * ```
+ */
+declare function arrayUnion(...elements: unknown[]): FieldValue;
+/**
+ * Crea un valor que elimina elementos de un array existente
+ *
+ * @param elements Elementos a eliminar
+ * @returns FieldValue representando la eliminación de elementos
+ *
+ * @example
+ * ```typescript
+ * await updateDoc(doc(db, 'users', 'user1'), {
+ *   tags: arrayRemove('oldTag')
+ * });
+ * ```
+ */
+declare function arrayRemove(...elements: unknown[]): FieldValue;
+/**
+ * Crea un valor que elimina el campo del documento
+ *
+ * @returns FieldValue representando la eliminación del campo
+ *
+ * @example
+ * ```typescript
+ * await updateDoc(doc(db, 'users', 'user1'), {
+ *   tempField: deleteField()
+ * });
+ * ```
+ */
+declare function deleteField(): FieldValue;
+
+/**
+ * Firestore SDK - WriteBatch & Transaction
+ * Operaciones atómicas en batch y transacciones
+ */
+
+/**
+ * Batch de escrituras atómicas
+ */
+interface WriteBatch {
+    /**
+     * Establece un documento
+     */
+    set<T = DocumentData>(reference: DocumentReference<T>, data: T, options?: SetOptions): WriteBatch;
+    /**
+     * Actualiza un documento
+     */
+    update<T = DocumentData>(reference: DocumentReference<T>, data: Partial<T>): WriteBatch;
+    /**
+     * Elimina un documento
+     */
+    delete(reference: DocumentReference): WriteBatch;
+    /**
+     * Ejecuta el batch
+     */
+    commit(): Promise<void>;
+}
+/**
+ * Crea un nuevo WriteBatch
+ *
+ * @param firestore Instancia de Firestore
+ * @returns WriteBatch
+ *
+ * @example
+ * ```typescript
+ * const batch = writeBatch(db);
+ *
+ * batch.set(doc(db, 'cities', 'NYC'), { name: 'New York' });
+ * batch.update(doc(db, 'cities', 'LA'), { population: 4000000 });
+ * batch.delete(doc(db, 'cities', 'OLD'));
+ *
+ * await batch.commit();
+ * ```
+ */
+declare function writeBatch(firestore: FirestoreInstance): WriteBatch;
+/**
+ * Transacción de Firestore
+ */
+interface Transaction {
+    /**
+     * Lee un documento dentro de la transacción
+     */
+    get<T = DocumentData>(reference: DocumentReference<T>): Promise<DocumentSnapshot<T>>;
+    /**
+     * Establece un documento
+     */
+    set<T = DocumentData>(reference: DocumentReference<T>, data: T, options?: SetOptions): Transaction;
+    /**
+     * Actualiza un documento
+     */
+    update<T = DocumentData>(reference: DocumentReference<T>, data: Partial<T>): Transaction;
+    /**
+     * Elimina un documento
+     */
+    delete(reference: DocumentReference): Transaction;
+}
+/**
+ * Opciones para runTransaction
+ */
+interface TransactionOptions {
+    /** Número máximo de reintentos */
+    maxAttempts?: number;
+}
+/**
+ * Ejecuta una función dentro de una transacción
+ *
+ * @param firestore Instancia de Firestore
+ * @param updateFunction Función a ejecutar
+ * @param options Opciones de transacción
+ * @returns Resultado de la función
+ *
+ * @example
+ * ```typescript
+ * const newBalance = await runTransaction(db, async (transaction) => {
+ *   const accountRef = doc(db, 'accounts', 'account1');
+ *   const accountDoc = await transaction.get(accountRef);
+ *
+ *   if (!accountDoc.exists()) {
+ *     throw new Error('Account does not exist');
+ *   }
+ *
+ *   const currentBalance = accountDoc.data()!.balance;
+ *   const newBalance = currentBalance - 100;
+ *
+ *   if (newBalance < 0) {
+ *     throw new Error('Insufficient funds');
+ *   }
+ *
+ *   transaction.update(accountRef, { balance: newBalance });
+ *   return newBalance;
+ * });
+ * ```
+ */
+declare function runTransaction<T>(firestore: FirestoreInstance, updateFunction: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
+
+/**
+ * Firestore SDK - Tipos Especiales
+ * Timestamp, GeoPoint, Bytes, FieldPath, VectorValue
+ * Compatible con Firebase Firestore v9
+ */
+/**
+ * Representa un punto en el tiempo con precisión de nanosegundos.
+ * Compatible con Firestore Timestamp.
+ */
+declare class Timestamp {
+    readonly seconds: number;
+    readonly nanoseconds: number;
+    /**
+     * Crea un nuevo Timestamp.
+     *
+     * @param seconds Segundos desde la época Unix (1 enero 1970 UTC)
+     * @param nanoseconds Nanosegundos adicionales (0-999999999)
+     */
+    constructor(seconds: number, nanoseconds: number);
+    /**
+     * Crea un Timestamp para el momento actual.
+     */
+    static now(): Timestamp;
+    /**
+     * Crea un Timestamp desde un objeto Date.
+     */
+    static fromDate(date: Date): Timestamp;
+    /**
+     * Crea un Timestamp desde milisegundos.
+     */
+    static fromMillis(milliseconds: number): Timestamp;
+    /**
+     * Convierte el Timestamp a un objeto Date.
+     */
+    toDate(): Date;
+    /**
+     * Convierte el Timestamp a milisegundos.
+     */
+    toMillis(): number;
+    /**
+     * Convierte a formato ISO 8601 para serialización.
+     */
+    toJSON(): string;
+    /**
+     * Compara con otro Timestamp.
+     */
+    isEqual(other: Timestamp): boolean;
+    /**
+     * Representación en string.
+     */
+    toString(): string;
+    /**
+     * Compara dos Timestamps.
+     * @returns negativo si this < other, positivo si this > other, 0 si iguales
+     */
+    compareTo(other: Timestamp): number;
+    /**
+     * Obtiene el valor primitivo para comparaciones.
+     */
+    valueOf(): number;
+}
+/**
+ * Representa un punto geográfico con latitud y longitud.
+ * Compatible con Firestore GeoPoint.
+ */
+declare class GeoPoint {
+    readonly latitude: number;
+    readonly longitude: number;
+    /**
+     * Crea un nuevo GeoPoint.
+     *
+     * @param latitude Latitud en grados (-90 a 90)
+     * @param longitude Longitud en grados (-180 a 180)
+     */
+    constructor(latitude: number, longitude: number);
+    /**
+     * Compara con otro GeoPoint.
+     */
+    isEqual(other: GeoPoint): boolean;
+    /**
+     * Convierte a objeto plano para serialización.
+     */
+    toJSON(): {
+        latitude: number;
+        longitude: number;
+    };
+    /**
+     * Representación en string.
+     */
+    toString(): string;
+}
+/**
+ * Representa datos binarios inmutables.
+ * Compatible con Firestore Bytes.
+ */
+declare class Bytes {
+    private readonly _bytes;
+    private constructor();
+    /**
+     * Crea Bytes desde una cadena Base64.
+     */
+    static fromBase64String(base64: string): Bytes;
+    /**
+     * Crea Bytes desde un Uint8Array.
+     */
+    static fromUint8Array(array: Uint8Array): Bytes;
+    /**
+     * Convierte a cadena Base64.
+     */
+    toBase64(): string;
+    /**
+     * Convierte a Uint8Array.
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Compara con otro Bytes.
+     */
+    isEqual(other: Bytes): boolean;
+    /**
+     * Representación en string.
+     */
+    toString(): string;
+}
+/**
+ * Representa una ruta de campo en un documento.
+ * Permite acceder a campos anidados de forma segura.
+ */
+declare class FieldPath {
+    private readonly _fields;
+    /**
+     * Crea un FieldPath desde segmentos de campo.
+     *
+     * @param fieldNames Nombres de campos anidados
+     *
+     * @example
+     * ```typescript
+     * new FieldPath('user', 'address', 'city')
+     * // Equivale a 'user.address.city'
+     * ```
+     */
+    constructor(...fieldNames: string[]);
+    /**
+     * Compara con otro FieldPath.
+     */
+    isEqual(other: FieldPath): boolean;
+    /**
+     * Convierte a string con notación de puntos.
+     */
+    toString(): string;
+    /**
+     * Obtiene los segmentos del path.
+     */
+    get segments(): string[];
+}
+/**
+ * Crea un FieldPath que apunta al ID del documento.
+ * Útil para queries que filtran por document ID.
+ *
+ * @example
+ * ```typescript
+ * query(collection(db, 'users'), where(documentId(), '==', 'user123'))
+ * ```
+ */
+declare function documentId(): FieldPath;
+/**
+ * Representa un vector de números para embeddings/ML.
+ * Compatible con Firestore VectorValue.
+ */
+declare class VectorValue {
+    private readonly _values;
+    private constructor();
+    /**
+     * Convierte a array de números.
+     */
+    toArray(): number[];
+    /**
+     * Compara con otro VectorValue.
+     */
+    isEqual(other: VectorValue): boolean;
+    /**
+     * Representación en string.
+     */
+    toString(): string;
+    /**
+     * Obtiene la dimensión del vector.
+     */
+    get length(): number;
+}
+/**
+ * Crea un VectorValue desde un array de números.
+ *
+ * @param values Array de números
+ *
+ * @example
+ * ```typescript
+ * const embedding = vector([0.1, 0.2, 0.3, 0.4]);
+ * await setDoc(docRef, { embedding });
+ * ```
+ */
+declare function vector(values: number[]): VectorValue;
+
+/**
+ * Firestore SDK - Queries Avanzadas
+ * and(), or(), collectionGroup()
+ * Compatible con Firebase Firestore v9
+ */
+
+/**
+ * Filtro compuesto AND
+ */
+interface AndConstraint {
+    readonly type: 'and';
+    readonly constraints: QueryConstraint[];
+}
+/**
+ * Filtro compuesto OR
+ */
+interface OrConstraint {
+    readonly type: 'or';
+    readonly constraints: QueryConstraint[];
+}
+/**
+ * Tipo unión para filtros compuestos
+ */
+type CompositeFilterConstraint = AndConstraint | OrConstraint;
+/**
+ * Combina múltiples constraints con lógica AND.
+ *
+ * @param constraints Restricciones a combinar
+ * @returns Constraint compuesto AND
+ *
+ * @example
+ * ```typescript
+ * const q = query(
+ *   collection(db, 'products'),
+ *   and(
+ *     where('category', '==', 'electronics'),
+ *     where('price', '<=', 1000),
+ *     where('inStock', '==', true)
+ *   )
+ * );
+ * ```
+ */
+declare function and(...constraints: QueryConstraint[]): AndConstraint;
+/**
+ * Combina múltiples constraints con lógica OR.
+ *
+ * @param constraints Restricciones a combinar
+ * @returns Constraint compuesto OR
+ *
+ * @example
+ * ```typescript
+ * const q = query(
+ *   collection(db, 'products'),
+ *   or(
+ *     where('category', '==', 'electronics'),
+ *     where('category', '==', 'computers')
+ *   )
+ * );
+ * ```
+ */
+declare function or(...constraints: QueryConstraint[]): OrConstraint;
+/**
+ * Referencia a un grupo de colecciones para queries.
+ */
+interface CollectionGroupReference<T = DocumentData> extends Query<T> {
+    readonly type: 'collectionGroup';
+    readonly collectionId: string;
+}
+/**
+ * Crea una query que abarca todas las colecciones con el mismo ID.
+ * Útil para buscar en subcolecciones anidadas en cualquier parte.
+ *
+ * @param firestore Instancia de Firestore
+ * @param collectionId ID de la colección a buscar
+ * @returns Query sobre el grupo de colecciones
+ *
+ * @example
+ * ```typescript
+ * // Buscar todos los comentarios en cualquier post
+ * const allComments = query(
+ *   collectionGroup(db, 'comments'),
+ *   where('author', '==', 'john'),
+ *   orderBy('createdAt', 'desc'),
+ *   limit(10)
+ * );
+ *
+ * const snapshot = await getDocs(allComments);
+ * ```
+ */
+declare function collectionGroup<T = DocumentData>(firestore: FirestoreInstance, collectionId: string): CollectionGroupReference<T>;
+/**
+ * Verifica si un constraint es un filtro compuesto AND
+ */
+declare function isAndConstraint(constraint: QueryConstraint): constraint is AndConstraint;
+/**
+ * Verifica si un constraint es un filtro compuesto OR
+ */
+declare function isOrConstraint(constraint: QueryConstraint): constraint is OrConstraint;
+/**
+ * Verifica si un constraint es un filtro compuesto
+ */
+declare function isCompositeFilter(constraint: QueryConstraint): constraint is CompositeFilterConstraint;
+/**
+ * Verifica si una query es un collection group
+ */
+declare function isCollectionGroup<T>(ref: Query<T> | CollectionReference<T>): boolean;
+
+/**
+ * Firestore SDK - Agregaciones
+ * getCountFromServer, getAggregateFromServer, count, sum, average
+ * Compatible con Firebase Firestore v9
+ */
+
+/**
+ * Especificación de campo de agregación
+ */
+interface AggregateField<T> {
+    readonly _aggregateType: 'count' | 'sum' | 'average';
+    readonly _field?: string;
+    /** Tipo interno para TypeScript */
+    readonly _valueType?: T;
+}
+/**
+ * Especificación de agregación (objeto con campos)
+ */
+type AggregateSpec = {
+    [key: string]: AggregateField<unknown>;
+};
+/**
+ * Resultado de agregación basado en el spec
+ */
+type AggregateSpecData<T extends AggregateSpec> = {
+    [K in keyof T]: T[K] extends AggregateField<infer U> ? U : never;
+};
+/**
+ * Snapshot de resultado de agregación
+ */
+interface AggregateQuerySnapshot<T extends AggregateSpec> {
+    /** Obtiene los datos de agregación */
+    data(): AggregateSpecData<T>;
+}
+/**
+ * Crea un campo de agregación para contar documentos.
+ *
+ * @example
+ * ```typescript
+ * const snapshot = await getAggregateFromServer(
+ *   query(collection(db, 'users')),
+ *   { userCount: count() }
+ * );
+ * console.log(snapshot.data().userCount);
+ * ```
+ */
+declare function count(): AggregateField<number>;
+/**
+ * Crea un campo de agregación para sumar valores de un campo.
+ *
+ * @param field Nombre del campo a sumar
+ *
+ * @example
+ * ```typescript
+ * const snapshot = await getAggregateFromServer(
+ *   query(collection(db, 'orders')),
+ *   { totalAmount: sum('amount') }
+ * );
+ * console.log(snapshot.data().totalAmount);
+ * ```
+ */
+declare function sum(field: string): AggregateField<number>;
+/**
+ * Crea un campo de agregación para calcular el promedio de un campo.
+ *
+ * @param field Nombre del campo a promediar
+ *
+ * @example
+ * ```typescript
+ * const snapshot = await getAggregateFromServer(
+ *   query(collection(db, 'products')),
+ *   { avgPrice: average('price') }
+ * );
+ * console.log(snapshot.data().avgPrice);
+ * ```
+ */
+declare function average(field: string): AggregateField<number | null>;
+/**
+ * Obtiene el conteo de documentos de una query desde el servidor.
+ *
+ * @param query Query a contar
+ * @returns Promise con snapshot conteniendo el conteo
+ *
+ * @example
+ * ```typescript
+ * const q = query(collection(db, 'users'), where('active', '==', true));
+ * const snapshot = await getCountFromServer(q);
+ * console.log('Active users:', snapshot.data().count);
+ * ```
+ */
+declare function getCountFromServer<T = DocumentData>(query: Query<T> | CollectionReference<T>): Promise<AggregateQuerySnapshot<{
+    count: AggregateField<number>;
+}>>;
+/**
+ * Ejecuta múltiples agregaciones en una query desde el servidor.
+ *
+ * @param query Query base para la agregación
+ * @param aggregateSpec Especificación de campos a agregar
+ * @returns Promise con snapshot conteniendo los resultados
+ *
+ * @example
+ * ```typescript
+ * const q = query(collection(db, 'orders'), where('status', '==', 'completed'));
+ * const snapshot = await getAggregateFromServer(q, {
+ *   totalOrders: count(),
+ *   totalRevenue: sum('amount'),
+ *   avgOrderValue: average('amount')
+ * });
+ *
+ * const data = snapshot.data();
+ * console.log('Total orders:', data.totalOrders);
+ * console.log('Total revenue:', data.totalRevenue);
+ * console.log('Average order:', data.avgOrderValue);
+ * ```
+ */
+declare function getAggregateFromServer<T = DocumentData, S extends AggregateSpec = AggregateSpec>(query: Query<T> | CollectionReference<T>, aggregateSpec: S): Promise<AggregateQuerySnapshot<S>>;
+
+/**
+ * Firestore SDK - Utilidades
+ * withConverter, refEqual, queryEqual, snapshotEqual, onSnapshotsInSync
+ * Compatible con Firebase Firestore v9
+ */
+
+/**
+ * Convertidor de datos para tipado fuerte.
+ * Transforma datos entre el formato de la aplicación y Firestore.
+ */
+interface FirestoreDataConverter<T> {
+    /**
+     * Convierte un objeto de la aplicación a datos de Firestore.
+     */
+    toFirestore(modelObject: T): DocumentData;
+    /**
+     * Convierte un snapshot de Firestore a un objeto de la aplicación.
+     */
+    fromFirestore(snapshot: QueryDocumentSnapshot<DocumentData>): T;
+}
+/**
+ * QueryDocumentSnapshot garantiza que el documento existe.
+ */
+interface QueryDocumentSnapshot<T = DocumentData> extends DocumentSnapshot<T> {
+    exists(): true;
+    data(): T;
+}
+/**
+ * Referencia a documento con converter.
+ */
+interface DocumentReferenceWithConverter<T> extends DocumentReference<T> {
+    /** Converter asociado */
+    readonly converter: FirestoreDataConverter<T> | null;
+}
+/**
+ * Referencia a colección con converter.
+ */
+interface CollectionReferenceWithConverter<T> extends CollectionReference<T> {
+    /** Converter asociado */
+    readonly converter: FirestoreDataConverter<T> | null;
+}
+/**
+ * Query con converter.
+ */
+interface QueryWithConverter<T> extends Query<T> {
+    /** Converter asociado */
+    readonly converter: FirestoreDataConverter<T> | null;
+}
+/**
+ * Aplica un converter a una referencia de documento.
+ *
+ * @param reference Referencia de documento
+ * @param converter Convertidor de datos
+ * @returns Referencia con converter aplicado
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *   name: string;
+ *   age: number;
+ * }
+ *
+ * const userConverter: FirestoreDataConverter<User> = {
+ *   toFirestore: (user) => ({ name: user.name, age: user.age }),
+ *   fromFirestore: (snap) => {
+ *     const data = snap.data();
+ *     return { name: data.name, age: data.age };
+ *   }
+ * };
+ *
+ * const userRef = doc(db, 'users', '123').withConverter(userConverter);
+ * const userSnap = await getDoc(userRef);
+ * const user = userSnap.data(); // Tipo: User | undefined
+ * ```
+ */
+declare function withConverter<T>(reference: DocumentReference<DocumentData>, converter: FirestoreDataConverter<T> | null): DocumentReference<T>;
+declare function withConverter<T>(reference: CollectionReference<DocumentData>, converter: FirestoreDataConverter<T> | null): CollectionReference<T>;
+declare function withConverter<T>(reference: Query<DocumentData>, converter: FirestoreDataConverter<T> | null): Query<T>;
+/**
+ * Compara dos referencias de documento.
+ *
+ * @param left Primera referencia
+ * @param right Segunda referencia
+ * @returns true si apuntan al mismo documento
+ *
+ * @example
+ * ```typescript
+ * const ref1 = doc(db, 'users', '123');
+ * const ref2 = doc(db, 'users', '123');
+ * console.log(refEqual(ref1, ref2)); // true
+ * ```
+ */
+declare function refEqual<T>(left: DocumentReference<T> | CollectionReference<T>, right: DocumentReference<T> | CollectionReference<T>): boolean;
+/**
+ * Compara dos queries.
+ *
+ * @param left Primera query
+ * @param right Segunda query
+ * @returns true si son equivalentes
+ *
+ * @example
+ * ```typescript
+ * const q1 = query(collection(db, 'users'), where('age', '>', 18));
+ * const q2 = query(collection(db, 'users'), where('age', '>', 18));
+ * console.log(queryEqual(q1, q2)); // true
+ * ```
+ */
+declare function queryEqual<T>(left: Query<T>, right: Query<T>): boolean;
+/**
+ * Compara dos snapshots de documento.
+ *
+ * @param left Primer snapshot
+ * @param right Segundo snapshot
+ * @returns true si representan el mismo estado
+ *
+ * @example
+ * ```typescript
+ * const snap1 = await getDoc(docRef);
+ * const snap2 = await getDoc(docRef);
+ * console.log(snapshotEqual(snap1, snap2)); // true si no hubo cambios
+ * ```
+ */
+declare function snapshotEqual<T>(left: DocumentSnapshot<T> | QuerySnapshot<T>, right: DocumentSnapshot<T> | QuerySnapshot<T>): boolean;
+/**
+ * Escucha cuando todos los snapshots están sincronizados.
+ * Se llama cuando todos los listeners activos han recibido una actualización.
+ *
+ * @param firestore Instancia de Firestore
+ * @param onSync Callback a ejecutar cuando todos estén sincronizados
+ * @returns Función para cancelar la suscripción
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = onSnapshotsInSync(db, () => {
+ *   console.log('All snapshots are in sync');
+ * });
+ *
+ * // Más tarde...
+ * unsubscribe();
+ * ```
+ */
+declare function onSnapshotsInSync(firestore: FirestoreInstance, onSync: () => void): Unsubscribe;
+
+/**
+ * Firestore SDK - Búsqueda Avanzada
+ * Extensiones de búsqueda que superan las capacidades de Firestore original
+ *
+ * Operadores disponibles:
+ * - _search: Full-text search con normalización de acentos
+ * - _contains: Búsqueda in-string (busca "tel" en "Hotel")
+ * - _fuzzy: Fuzzy matching con tolerancia a errores de tipeo
+ * - _similar: Similitud de trigramas (coincidencia parcial)
+ *
+ * @example
+ * ```typescript
+ * import { whereContains, whereFuzzy, orderByRelevance } from '@ponceca/firestore-sdk';
+ *
+ * // Buscar "tel" dentro de cualquier parte del campo (encuentra "Hotel")
+ * const q1 = query(collection(db, 'places'), whereContains('name', 'tel'));
+ *
+ * // Buscar con tolerancia a errores de tipeo ("algodoon" → "algodón")
+ * const q2 = query(collection(db, 'products'), whereFuzzy('description', 'algodoon'));
+ *
+ * // Ordenar por relevancia
+ * const q3 = query(
+ *   collection(db, 'articles'),
+ *   whereSearch('title', 'javascript'),
+ *   orderByRelevance()
+ * );
+ * ```
+ */
+
+/**
+ * Busca texto usando full-text search con normalización de acentos.
+ * Insensible a mayúsculas/minúsculas y acentos.
+ *
+ * @param field Campo a buscar
+ * @param value Texto a buscar
+ * @returns Constraint de búsqueda
+ *
+ * @example
+ * ```typescript
+ * // Busca "camion" y encuentra "Camión", "CAMIÓN", "camion"
+ * const q = query(collection(db, 'vehicles'), whereSearch('name', 'camion'));
+ * ```
+ */
+declare function whereSearch(field: string, value: string): WhereConstraint;
+/**
+ * Busca texto en cualquier posición del campo (in-string search).
+ * Busca "tel" y encuentra "Hotel", "telefono", "cartel".
+ *
+ * @param field Campo a buscar
+ * @param value Texto a buscar
+ * @returns Constraint de búsqueda
+ *
+ * @example
+ * ```typescript
+ * // Busca "tel" dentro de cualquier parte (encuentra "Hotel", "telefono")
+ * const q = query(collection(db, 'places'), whereContains('name', 'tel'));
+ * ```
+ */
+declare function whereContains(field: string, value: string): WhereConstraint;
+/**
+ * Busca texto con tolerancia a errores de tipeo (fuzzy matching).
+ * Usa distancia de Levenshtein para encontrar coincidencias aproximadas.
+ *
+ * @param field Campo a buscar
+ * @param value Texto a buscar
+ * @returns Constraint de búsqueda
+ *
+ * @example
+ * ```typescript
+ * // Busca "algodoon" y encuentra "algodón"
+ * const q = query(collection(db, 'products'), whereFuzzy('material', 'algodoon'));
+ * ```
+ */
+declare function whereFuzzy(field: string, value: string): WhereConstraint;
+/**
+ * Busca texto por similitud de trigramas.
+ * Encuentra coincidencias parciales basadas en secuencias de 3 caracteres.
+ *
+ * @param field Campo a buscar
+ * @param value Texto a buscar
+ * @returns Constraint de búsqueda
+ *
+ * @example
+ * ```typescript
+ * // Encuentra palabras similares a "javascript"
+ * const q = query(collection(db, 'articles'), whereSimilar('title', 'javascript'));
+ * ```
+ */
+declare function whereSimilar(field: string, value: string): WhereConstraint;
+/**
+ * Ordena los resultados por relevancia (score de búsqueda).
+ * Debe usarse junto con operadores de búsqueda (_search, _contains, _fuzzy, _similar).
+ * Los documentos más relevantes aparecen primero.
+ *
+ * @param direction Dirección del ordenamiento ('desc' = más relevantes primero)
+ * @returns Constraint de ordenamiento
+ *
+ * @example
+ * ```typescript
+ * const q = query(
+ *   collection(db, 'products'),
+ *   whereSearch('description', 'laptop gaming'),
+ *   orderByRelevance('desc')
+ * );
+ * ```
+ */
+declare function orderByRelevance(direction?: 'asc' | 'desc'): OrderByConstraint;
+/**
+ * Paginación por offset directo.
+ * Permite saltar a cualquier página sin leer documentos anteriores.
+ *
+ * @param count Número de documentos a saltar
+ * @returns Constraint de offset
+ *
+ * @example
+ * ```typescript
+ * // Ir directamente a la página 5 (saltando 40 documentos)
+ * const q = query(
+ *   collection(db, 'products'),
+ *   limit(10),
+ *   offset(40)
+ * );
+ * ```
+ */
+declare function offset(count: number): {
+    type: 'offset';
+    count: number;
+};
+interface FastSearchOptions {
+    /** Campo específico donde buscar. Si está vacío, busca en todos los campos (global). */
+    field?: string;
+    /** Máximo de resultados a retornar. Default: 50 */
+    limit?: number;
+    /** Usar búsqueda fuzzy (tolerante a errores de tipeo). Default: false */
+    fuzzy?: boolean;
+}
+interface FastSearchResult<T = DocumentData> {
+    id: string;
+    data: T;
+}
+interface FastSearchResponse<T = DocumentData> {
+    count: number;
+    documents: FastSearchResult<T>[];
+    /** Indica si fue búsqueda global o por campo específico */
+    searchMode?: string;
+}
+/**
+ * Búsqueda ultra rápida vía endpoint dedicado.
+ * Ideal para autocomplete y prefijos con latencia mínima.
+ * Usa fetch directo para minimizar overhead.
+ *
+ * @param firestore Instancia de Firestore
+ * @param collectionPath Ruta de colección
+ * @param term Término de búsqueda
+ * @param options Opciones de búsqueda (incluye field para búsqueda específica)
+ *
+ * @example
+ * // Búsqueda en campo específico (recomendado)
+ * const results = await fastSearch(db, 'articles', 'javascript', { field: 'title' });
+ *
+ * // Búsqueda global (todos los campos)
+ * const results = await fastSearch(db, 'articles', 'javascript');
+ */
+declare function fastSearch<T = DocumentData>(firestore: FirestoreInstance, collectionPath: string, term: string, options?: FastSearchOptions): Promise<FastSearchResponse<T>>;
+
+export { type AggregateField, type AggregateQuerySnapshot, type AggregateSpec, type AggregateSpecData, type AndConstraint, Bytes, type CollectionGroupReference, CollectionReference, type CollectionReferenceWithConverter, type CompositeFilterConstraint, DocumentData, DocumentReference, type DocumentReferenceWithConverter, DocumentSnapshot, type DocumentSnapshotCallback, EndAtConstraint, type ErrorCallback, type FastSearchOptions, type FastSearchResponse, type FastSearchResult, FieldPath as FieldPathClass, FieldValue, Firestore, type FirestoreDataConverter, FirestoreInstance, FirestoreSettings, GeoPoint, LimitConstraint, type OrConstraint, OrderByConstraint, OrderByDirection, Query, QueryConstraint, type QueryDocumentSnapshot, QuerySnapshot, type QuerySnapshotCallback, type QueryWithConverter, SetOptions, SnapshotListenOptions, type SnapshotObserver, StartAtConstraint, Timestamp, type Transaction, type TransactionOptions, Unsubscribe, VectorValue, WhereConstraint, WhereFilterOp, type WriteBatch, addDoc, and, arrayRemove, arrayUnion, average, clearIndexedDbPersistence, collection, collectionGroup, connectFirestoreEmulator, count, deleteDoc, deleteField, disableNetwork, doc, documentId, enableIndexedDbPersistence, enableMultiTabIndexedDbPersistence, enableNetwork, endAt, endBefore, fastSearch, getAggregateFromServer, getAuthToken, getCountFromServer, getDoc, getDocFromCache, getDocFromServer, getDocs, getDocsFromCache, getDocsFromServer, getFirestore, increment, initializeFirestore, isAndConstraint, isCollectionGroup, isCompositeFilter, isOrConstraint, limit, limitToLast, offset, onSnapshot, onSnapshotsInSync, or, orderBy, orderByRelevance, query, queryEqual, refEqual, runTransaction, serverTimestamp, setAuthToken, setDoc, snapshotEqual, startAfter, startAt, sum, terminate, updateDoc, vector, waitForPendingWrites, where, whereContains, whereFuzzy, whereSearch, whereSimilar, withConverter, writeBatch };