/**
 * Vector Store
 *
 * In-memory vector store with efficient similarity search.
 * Uses brute-force search for simplicity, with optional
 * approximate nearest neighbor support for larger indices.
 */
import { VectorStore } from "./types.js";
interface VectorEntry {
    id: string;
    embedding: number[];
    metadata: Record<string, unknown>;
}
/**
 * Simple in-memory vector store
 */
export declare class InMemoryVectorStore implements VectorStore {
    private vectors;
    private persistPath?;
    private dirty;
    private autoSaveInterval;
    constructor(persistPath?: string);
    /**
     * Add a single vector
     */
    add(id: string, embedding: number[], metadata?: Record<string, unknown>): Promise<void>;
    /**
     * Add multiple vectors in batch
     */
    addBatch(items: Array<{
        id: string;
        embedding: number[];
        metadata?: Record<string, unknown>;
    }>): Promise<void>;
    /**
     * Search for similar vectors
     */
    search(embedding: number[], k: number, filter?: Record<string, unknown>): Promise<Array<{
        id: string;
        score: number;
    }>>;
    /**
     * Delete a vector by ID
     */
    delete(id: string): Promise<void>;
    /**
     * Delete vectors matching a filter
     */
    deleteByFilter(filter: Record<string, unknown>): Promise<number>;
    /**
     * Get count of vectors
     */
    count(): Promise<number>;
    /**
     * Clear all vectors
     */
    clear(): Promise<void>;
    /**
     * Get a vector by ID
     */
    get(id: string): VectorEntry | undefined;
    /**
     * Check if a vector exists
     */
    has(id: string): boolean;
    /**
     * Get all IDs
     */
    getAllIds(): string[];
    /**
     * Check if metadata matches filter
     */
    private matchesFilter;
    /**
     * Save to disk
     */
    saveToDisk(): Promise<void>;
    /**
     * Load from disk
     */
    private loadFromDisk;
    /**
     * Start auto-save interval
     */
    private startAutoSave;
    /**
     * Stop auto-save and save final state
     */
    dispose(): Promise<void>;
    /**
     * Get memory usage estimate
     */
    getMemoryUsage(): number;
}
/**
 * Partitioned vector store for larger datasets
 * Divides vectors into partitions for faster search
 */
export declare class PartitionedVectorStore implements VectorStore {
    private partitions;
    private partitionKey;
    private persistDir?;
    constructor(partitionKey?: string, persistDir?: string);
    /**
     * Get or create partition
     */
    private getPartition;
    /**
     * Add a single vector
     */
    add(id: string, embedding: number[], metadata?: Record<string, unknown>): Promise<void>;
    /**
     * Add multiple vectors in batch
     */
    addBatch(items: Array<{
        id: string;
        embedding: number[];
        metadata?: Record<string, unknown>;
    }>): Promise<void>;
    /**
     * Search for similar vectors
     */
    search(embedding: number[], k: number, filter?: Record<string, unknown>): Promise<Array<{
        id: string;
        score: number;
    }>>;
    /**
     * Delete a vector by ID
     */
    delete(id: string): Promise<void>;
    /**
     * Delete vectors matching a filter
     */
    deleteByFilter(filter: Record<string, unknown>): Promise<number>;
    /**
     * Get count of vectors
     */
    count(): Promise<number>;
    /**
     * Clear all vectors
     */
    clear(): Promise<void>;
    /**
     * Save all partitions
     */
    saveToDisk(): Promise<void>;
    /**
     * Dispose all partitions
     */
    dispose(): Promise<void>;
    /**
     * Get partition names
     */
    getPartitionNames(): string[];
    /**
     * Get partition statistics
     */
    getPartitionStats(): Promise<Record<string, number>>;
}
/**
 * Create a vector store
 */
export declare function createVectorStore(type?: "memory" | "partitioned", options?: {
    persistPath?: string;
    persistDir?: string;
    partitionKey?: string;
}): VectorStore;
export {};
