/**
 * SqliteCortexStore — local SQLite-backed implementation of CortexStore.
 *
 * Uses better-sqlite3 for synchronous SQLite access wrapped in async interface.
 * Vector search uses brute-force cosine similarity (sufficient for <10k memories).
 * Dates stored as ISO-8601 strings. Arrays stored as JSON text, except
 * embeddings, which are raw Float32Array blobs (legacy JSON-text embeddings
 * are converted in place at open time and still readable either way).
 */
import type { CortexStore, StoreCapabilities } from '../core/store.js';
import type { Memory, Observation, Edge, OpsEntry, OpsFilters, Signal, SignalFilters, BeliefEntry, SearchResult, FSRSData, QueryFilter } from '../core/types.js';
export declare class SqliteCortexStore implements CortexStore {
    private db;
    private ns;
    private txnQueue;
    private inTransaction;
    constructor(dbPath: string, namespace?: string);
    private t;
    private createTables;
    /** Add columns introduced after initial schema. Safe to run repeatedly (no-ops on new DBs). */
    private migrateSchema;
    /**
     * One-time conversion of legacy JSON-text embeddings to Float32Array blobs.
     * Idempotent: only rows whose stored value is still text are touched, so
     * re-opening an already-converted DB is a no-op scan. Column affinity does
     * not matter here — SQLite stores blob values as blobs regardless of the
     * declared column type, and typeof() reports the stored type.
     */
    private migrateEmbeddingsToBlobs;
    private addColumn;
    private createIndexes;
    /**
     * External-content FTS5 index over memory name/definition/tags, kept in
     * sync by triggers. On first creation against a non-empty memories table,
     * the index is rebuilt from existing rows.
     */
    private createFtsTable;
    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[]>;
    searchText(text: string, 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>;
    getSignal(id: string): Promise<Signal | null>;
    getSignals(filters?: SignalFilters): Promise<Signal[]>;
    updateSignal(id: string, updates: Partial<Omit<Signal, 'id'>>): Promise<void>;
    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>;
    /**
     * Manual BEGIN IMMEDIATE / COMMIT / ROLLBACK rather than better-sqlite3's
     * db.transaction() wrapper. The wrapper is purely synchronous and commits
     * the moment the sync callback returns — it cannot survive an await
     * suspension inside an async user closure, and refuses outright if the
     * closure returns a Promise. Manual statements let the closure await store
     * ops correctly.
     *
     * Concurrent calls are serialized through a Promise-chained queue: only
     * one transaction is in flight at a time per store instance. Without this,
     * two parallel BEGINs would race and the second would throw SQLITE_ERROR
     * "cannot start a transaction within a transaction".
     *
     * Hard constraint on fn: avoid awaits to external systems (LLM, network).
     * They hold the transaction open and block every other writer through the
     * queue. Store ops are fine — they are sync under their async wrapper.
     *
     * Nested calls on the same store are forbidden and rejected explicitly.
     * See docs/concurrency.md.
     */
    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=sqlite.d.ts.map