/**
 * File-based Memory Storage
 * Persistent memory using JSONL files with lockfile support for concurrent access
 */
import { MemoryEntry, MemoryConfig, SearchResult } from './memory';
export interface FileMemoryConfig extends MemoryConfig {
    filePath: string;
    compactionThreshold?: number;
    autoCompact?: boolean;
}
export interface FileMemoryEntry extends MemoryEntry {
    deleted?: boolean;
}
/**
 * FileMemory - Append-only JSONL storage with compaction
 */
export declare class FileMemory {
    private filePath;
    private entries;
    private maxEntries;
    private embeddingProvider?;
    private compactionThreshold;
    private autoCompact;
    private initialized;
    private writeQueue;
    constructor(config: FileMemoryConfig);
    /**
     * Initialize and load existing entries
     */
    initialize(): Promise<void>;
    /**
     * Add a memory entry
     */
    add(content: string, role: 'user' | 'assistant' | 'system', metadata?: Record<string, any>): Promise<MemoryEntry>;
    /**
     * Get a memory entry by ID
     */
    get(id: string): Promise<MemoryEntry | undefined>;
    /**
     * Get all entries
     */
    getAll(): Promise<MemoryEntry[]>;
    /**
     * Get recent entries
     */
    getRecent(count: number): Promise<MemoryEntry[]>;
    /**
     * Search memory by text similarity
     */
    search(query: string, limit?: number): Promise<SearchResult[]>;
    /**
     * Delete a memory entry (soft delete)
     */
    delete(id: string): Promise<boolean>;
    /**
     * Clear all memory
     */
    clear(): Promise<void>;
    /**
     * Compact the file by removing deleted entries
     */
    compact(): Promise<void>;
    /**
     * Get memory size
     */
    get size(): number;
    /**
     * Export memory to JSON
     */
    toJSON(): Promise<MemoryEntry[]>;
    /**
     * Import memory from JSON
     */
    fromJSON(entries: MemoryEntry[]): Promise<void>;
    /**
     * Build context string from recent memory
     */
    buildContext(count?: number): Promise<string>;
    private appendEntry;
    private textSearch;
    private cosineSimilarity;
    private generateId;
    private enforceLimit;
    private versions;
    /**
     * Get version history for an entry
     */
    getVersions(id: string): Promise<MemoryEntry[]>;
    /**
     * Update entry with versioning
     */
    update(id: string, content: string, metadata?: Record<string, any>): Promise<MemoryEntry | null>;
    /**
     * Restore to a specific version
     */
    restore(id: string, versionIndex: number): Promise<MemoryEntry | null>;
    /**
     * Query with filters
     */
    query(options: {
        role?: 'user' | 'assistant' | 'system';
        since?: number;
        until?: number;
        metadata?: Record<string, any>;
        limit?: number;
    }): Promise<MemoryEntry[]>;
    /**
     * Full-text search with ranking
     */
    searchText(query: string, options?: {
        limit?: number;
        fuzzy?: boolean;
    }): Promise<SearchResult[]>;
    private index;
    /**
     * Build search index
     */
    buildIndex(): Promise<void>;
    /**
     * Index single entry
     */
    private indexEntry;
    /**
     * Search using index
     */
    indexSearch(query: string, limit?: number): Promise<MemoryEntry[]>;
    /**
     * Get stats
     */
    getStats(): {
        entryCount: number;
        deletedCount: number;
        indexSize: number;
        versionedEntries: number;
    };
}
/**
 * Create a file-based memory instance
 */
export declare function createFileMemory(config: FileMemoryConfig): FileMemory;