/**
 * FirestoreCortexStore — cloud Firestore-backed implementation of CortexStore.
 *
 * Uses firebase-admin for Firestore access. Vector search uses Firestore native
 * findNearest() for production-grade similarity search.
 * Dates stored as Firestore Timestamps. Embeddings stored as VectorValue.
 *
 * This is the cloud counterpart to SqliteCortexStore. Both implement the same
 * CortexStore interface, so engines work identically on either backend.
 */
import type { Firestore, FieldValue as FieldValueType } from '@google-cloud/firestore';
import type { CortexStore, StoreCapabilities } from '../core/store.js';
import type { Memory, Observation, Edge, OpsEntry, OpsFilters, Signal, BeliefEntry, SearchResult, FSRSData, QueryFilter } from '../core/types.js';
export interface FirestoreStoreOptions {
    /** GCP project ID (required if not using Application Default Credentials) */
    projectId?: string;
    /** Firestore database ID (default: '(default)') */
    databaseId?: string;
    /** Namespace prefix for collection names (for multi-tenant isolation) */
    namespace?: string;
}
export declare class FirestoreCortexStore implements CortexStore {
    private db;
    private ns;
    constructor(db: Firestore, namespace?: string, fieldValue?: typeof FieldValueType);
    /** Inject the host's FieldValue to avoid ESM dual-package class identity issues. */
    static setFieldValue(fv: typeof FieldValueType): void;
    /** Create a FirestoreCortexStore from firebase-admin Firestore instance. */
    static fromFirestore(db: Firestore, namespace?: string, fieldValue?: typeof FieldValueType): FirestoreCortexStore;
    /** Get the prefixed collection name. */
    private col;
    putMemory(memory: Omit<Memory, 'id'>): Promise<string>;
    getMemory(id: string): Promise<Memory | null>;
    updateMemory(id: string, updates: Partial<Omit<Memory, 'id'>>): Promise<void>;
    findNearest(embedding: number[], limit: number): Promise<SearchResult[]>;
    touchMemory(id: string, fsrsUpdates: Partial<FSRSData>): Promise<void>;
    getAllMemories(): Promise<Memory[]>;
    getRecentMemories(days: number, limit: number): Promise<Memory[]>;
    putObservation(obs: Omit<Observation, 'id'>): Promise<string>;
    getUnprocessedObservations(limit: number): Promise<Observation[]>;
    markObservationProcessed(id: string): Promise<void>;
    putEdge(edge: Omit<Edge, 'id'>): Promise<string>;
    getEdgesFrom(memoryId: string): Promise<Edge[]>;
    getEdgesForMemories(memoryIds: string[]): Promise<Edge[]>;
    appendOps(entry: Omit<OpsEntry, 'id'>): Promise<string>;
    queryOps(filters: OpsFilters): Promise<OpsEntry[]>;
    updateOps(id: string, updates: Partial<Omit<OpsEntry, 'id'>>): Promise<void>;
    putSignal(signal: Omit<Signal, 'id'>): Promise<string>;
    putBelief(entry: Omit<BeliefEntry, 'id'>): Promise<string>;
    getBeliefHistory(conceptId: string): Promise<BeliefEntry[]>;
    put(collection: string, doc: Record<string, unknown>): Promise<string>;
    get(collection: string, id: string): Promise<Record<string, unknown> | null>;
    update(collection: string, id: string, updates: Record<string, unknown>): Promise<void>;
    query(collection: string, filters: QueryFilter[], options?: {
        limit?: number;
        orderBy?: string;
        orderDir?: 'asc' | 'desc';
    }): Promise<Record<string, unknown>[]>;
    countDocuments(collection: string, filters?: QueryFilter[]): Promise<number>;
    delete(collection: string, id: string): Promise<void>;
    /**
     * Wraps db.runTransaction so any direct ref.set/update/delete issued through
     * the txn-bound proxy commits atomically. The proxy implements only the
     * subset of CortexStore that maps cleanly onto Firestore's reads-before-writes
     * transactional model: typed put/get/update for memories, observations,
     * edges, ops, signals, beliefs, plus generic put/get/update/delete.
     *
     * Unsupported inside the txn fn: findNearest (no transactional vector search),
     * queries that scan (no transactional query()), countDocuments, getRecent*,
     * getAllMemories, getBeliefHistory, queryOps. Callers needing those reads
     * must perform them outside the transaction and pass the IDs in.
     *
     * Nested calls are forbidden — Firestore actually allows nesting but mixing
     * outer reads with inner writes is a known footgun, so we treat parity with
     * SQLite as the contract.
     */
    withTransaction<T>(fn: (txn: CortexStore) => Promise<T>): Promise<T>;
    upsertMemory(memory: Memory): Promise<void>;
    upsertObservation(obs: Observation): Promise<void>;
    upsertEdge(edge: Edge): Promise<void>;
    upsertOpsEntry(entry: OpsEntry): Promise<void>;
    upsertSignal(signal: Signal): Promise<void>;
    upsertBelief(belief: BeliefEntry): Promise<void>;
    getCapabilities(): Promise<StoreCapabilities>;
}
//# sourceMappingURL=firestore.d.ts.map