import { MemoryConfig, MemoryRecord, MemoryState } from '@celiums/memory-types';

/**
 * @celiums/memory — SQLite Store
 *
 * Single-file persistent memory store. Zero infrastructure — just a .db file.
 * Sits between InMemoryMemoryStore (volatile dev) and MemoryStore (PG+Qdrant+Valkey production).
 *
 * Features:
 * - better-sqlite3 for synchronous, fast, battle-tested persistence
 * - FTS5 full-text search built into SQLite
 * - Vector embeddings stored as BLOB, cosine computed in JS
 * - Same API as InMemoryMemoryStore — drop-in replacement
 * - Atomic writes via SQLite transactions
 * - Survives process restarts, portable between machines
 *
 * When to use:
 * - You want persistence but don't want Docker/PG/Qdrant/Valkey
 * - Single-user deployments (local dev, personal assistants, single-tenant apps)
 * - Up to ~500K memories comfortably
 *
 * When to upgrade to MemoryStore:
 * - Multi-user production with concurrent writes
 * - > 1M memories needing HNSW indexing
 * - Distributed deployments needing shared state
 *
 * @license Apache-2.0
 */

interface SqliteStoreConfig extends MemoryConfig {
    /** Path to SQLite database file. Defaults to ./celiums-memory.db */
    sqlitePath?: string;
}
declare class SqliteMemoryStore {
    private db;
    private config;
    private sqlitePath;
    private embeddingDimensions;
    constructor(config: SqliteStoreConfig);
    initialize(): Promise<void>;
    saveMemory(memory: MemoryRecord): Promise<MemoryRecord>;
    getMemory(id: string): Promise<MemoryRecord | null>;
    searchByImportance(userId: string, minImportance: number, limit?: number): Promise<MemoryRecord[]>;
    deleteMemories(ids: string[]): Promise<number>;
    updateLifecycle(id: string, importance: number, state: MemoryState): Promise<MemoryRecord | null>;
    reactivate(id: string): Promise<MemoryRecord | null>;
    getForLifecycle(userId: string, batchSize?: number): Promise<MemoryRecord[]>;
    health(): Promise<{
        postgres: boolean;
        qdrant: boolean;
        valkey: boolean;
        overall: boolean;
    }>;
    embed(text: string): Promise<number[]>;
    private deterministicEmbed;
    semanticSearch(vector: number[], userId: string, projectId: string | null, limit?: number, scoreThreshold?: number): Promise<Array<{
        id: string;
        score: number;
    }>>;
    fullTextSearch(query: string, userId: string, projectId: string | null, limit?: number): Promise<Array<{
        id: string;
        score: number;
    }>>;
    private likeSearch;
    getMemoriesByIds(ids: string[]): Promise<MemoryRecord[]>;
    getRecentSessionMemories(userId: string, sessionId: string, limit?: number): Promise<MemoryRecord[]>;
    findSimilarMemories(vector: number[], userId: string, threshold?: number, limit?: number): Promise<Array<{
        id: string;
        score: number;
    }>>;
    updateMemory(id: string, updates: Partial<Pick<MemoryRecord, 'content' | 'summary' | 'importance' | 'emotionalValence' | 'emotionalArousal' | 'emotionalDominance' | 'confidence' | 'strength' | 'state' | 'consolidatedAt' | 'consolidationCount' | 'linkedMemoryIds' | 'tags' | 'entities'>>): Promise<MemoryRecord | null>;
    updateSession(sessionId: string, updates: any): Promise<void>;
    bulkUpdateLifecycle(updates: Array<{
        id: string;
        importance: number;
        strength: number;
        state: MemoryState;
    }>): Promise<void>;
    getUserProfile(userId: string): Promise<any>;
    getProjectContext(projectId: string): Promise<any>;
    shutdown(): Promise<void>;
    getStats(userId: string): Promise<{
        totalMemories: any;
        byType: {
            episodic: any;
            semantic: any;
            procedural: any;
            emotional: any;
        };
        byState: {
            encoding: any;
            active: any;
            consolidated: any;
            decayed: any;
            archived: any;
        };
        avgImportance: any;
        avgStrength: any;
    }>;
}

export { SqliteMemoryStore, type SqliteStoreConfig };