/**
 * Vector Store with sqlite-vec integration
 * Dual-schema support (vector extension or BLOB fallback)
 */
import type { SQLiteManager } from "../storage/SQLiteManager.js";
import type { TextChunk } from "../chunking/index.js";
export interface VectorSearchResult {
    id: number;
    content: string;
    similarity: number;
    metadata?: Record<string, unknown>;
}
export interface ChunkSearchResult {
    chunkId: string;
    messageId: number;
    chunkIndex: number;
    totalChunks: number;
    content: string;
    startOffset: number;
    endOffset: number;
    similarity: number;
    strategy: string;
}
export interface ChunkEmbeddingData {
    messageId: number;
    chunk: TextChunk;
    embedding: Float32Array;
    modelName: string;
}
/**
 * Filter options for pre-filtering vector search
 */
export interface SearchFilterOptions {
    /** Filter by date range [start, end] as Unix timestamps */
    dateRange?: [number, number];
    /** Filter by conversation IDs (internal) */
    conversationIds?: number[];
    /** Filter by message types */
    messageTypes?: string[];
    /** Minimum similarity threshold */
    minSimilarity?: number;
}
export declare class VectorStore {
    private db;
    private sqliteManager;
    private hasVecExtension;
    private vecTablesInitialized;
    constructor(sqliteManager: SQLiteManager);
    /**
     * Detect if sqlite-vec extension is available
     */
    private detectVecExtension;
    /**
     * Check if vec extension is enabled
     */
    isVecEnabled(): boolean;
    /**
     * Generic helper to get existing embedding IDs from both BLOB and vec tables.
     * @param blobTable - BLOB table name (e.g., "message_embeddings")
     * @param idColumn - Column name for the entity ID (e.g., "message_id")
     * @param vecTable - Vec table name (e.g., "vec_message_embeddings")
     * @param prefix - ID prefix in vec table (e.g., "msg_")
     */
    private getExistingEmbeddingIds;
    /**
     * Get set of message IDs that already have embeddings.
     */
    getExistingMessageEmbeddingIds(): Set<number>;
    /**
     * Get set of decision IDs that already have embeddings.
     */
    getExistingDecisionEmbeddingIds(): Set<number>;
    /**
     * Get set of mistake IDs that already have embeddings.
     */
    getExistingMistakeEmbeddingIds(): Set<number>;
    /**
     * Ensure vec tables exist with correct dimensions
     */
    private ensureVecTables;
    /**
     * Prepare vec tables for search when dimensions are known.
     */
    prepareVecTables(dimensions: number): void;
    /**
     * Store an embedding for a message
     * @param messageId - The message ID
     * @param content - The message content
     * @param embedding - The embedding vector
     * @param modelName - The model used to generate the embedding (default: all-MiniLM-L6-v2)
     */
    storeMessageEmbedding(messageId: number, content: string, embedding: Float32Array, modelName?: string): Promise<void>;
    /**
     * Store embedding in BLOB table (fallback)
     */
    private storeInBlobTable;
    /**
     * Generic helper to store embeddings for decisions/mistakes (simpler schema without content).
     * @param entityId - The entity ID (decision or mistake)
     * @param embedding - The embedding vector
     * @param blobTable - BLOB table name (e.g., "decision_embeddings")
     * @param idColumn - Column name for entity ID (e.g., "decision_id")
     * @param vecTable - Vec table name (e.g., "vec_decision_embeddings")
     * @param prefix - ID prefix (e.g., "dec_")
     * @param entityType - For logging (e.g., "decision")
     */
    private storeEntityEmbedding;
    /**
     * Store an embedding for a decision
     */
    storeDecisionEmbedding(decisionId: number, embedding: Float32Array): Promise<void>;
    /**
     * Store an embedding for a mistake
     */
    storeMistakeEmbedding(mistakeId: number, embedding: Float32Array): Promise<void>;
    /**
     * Filter options for vector search
     */
    searchFilterOptions?: SearchFilterOptions;
    /**
     * Search for similar messages
     */
    searchMessages(queryEmbedding: Float32Array, limit?: number, filter?: SearchFilterOptions): Promise<VectorSearchResult[]>;
    /**
     * Search using sqlite-vec extension with optional pre-filtering
     */
    private searchWithVecExtension;
    /**
     * Check if filter has any conditions
     */
    private hasFilterConditions;
    /**
     * Search using manual cosine similarity (fallback) with optional pre-filtering
     */
    private searchWithCosine;
    /**
     * Calculate cosine similarity between two vectors
     */
    private cosineSimilarity;
    /**
     * Convert Float32Array to Buffer for storage
     */
    private float32ArrayToBuffer;
    /**
     * Convert Buffer to Float32Array for retrieval
     */
    private bufferToFloat32Array;
    /**
     * Get embedding count
     */
    getEmbeddingCount(): number;
    /**
     * Clear all embeddings
     */
    clearAllEmbeddings(): void;
    /**
     * Store embedding for a text chunk
     */
    storeChunkEmbedding(data: ChunkEmbeddingData): Promise<void>;
    /**
     * Store multiple chunk embeddings in batch
     */
    storeChunkEmbeddingsBatch(chunks: ChunkEmbeddingData[]): Promise<void>;
    /**
     * Ensure vec_chunk_embeddings virtual table exists
     */
    private ensureVecChunkTable;
    /**
     * Search chunk embeddings for similar content
     */
    searchChunks(queryEmbedding: Float32Array, limit?: number): Promise<ChunkSearchResult[]>;
    /**
     * Search chunks using sqlite-vec extension
     */
    private searchChunksWithVec;
    /**
     * Search chunks using manual cosine similarity (fallback)
     */
    private searchChunksWithCosine;
    /**
     * Get set of message IDs that already have chunk embeddings
     */
    getExistingChunkEmbeddingMessageIds(): Set<number>;
    /**
     * Get chunk count for statistics
     */
    getChunkEmbeddingCount(): number;
    /**
     * Check if chunk embeddings table exists
     */
    hasChunkEmbeddingsTable(): boolean;
}
//# sourceMappingURL=VectorStore.d.ts.map