/**
 * Vector Storage Engine - AI embeddings and similarity search
 * Part of CBD Universal Database Phase 2
 */
import { EventEmitter } from 'events';
export interface VectorRecord {
    id: string;
    vector: number[];
    metadata: Record<string, any>;
    norm?: number;
    timestamp: Date;
}
export interface SimilarityResult {
    id: string;
    score: number;
    vector: number[];
    metadata: Record<string, any>;
    distance: number;
}
export interface VectorIndex {
    name: string;
    dimensions: number;
    algorithm: 'cosine' | 'euclidean' | 'dot_product' | 'hamming';
    vectors: Map<string, VectorRecord>;
    indexStructure?: any;
}
export interface VectorSearchOptions {
    limit?: number;
    threshold?: number;
    includeMetadata?: boolean;
    filters?: Record<string, any>;
}
export interface HybridResult extends SimilarityResult {
    textScore?: number;
    combinedScore: number;
}
export interface VectorStats {
    totalVectors: number;
    dimensions: number;
    indexSize: number;
    averageNorm: number;
    searchLatency: {
        p50: number;
        p95: number;
        p99: number;
    };
}
export declare class VectorStorageEngine extends EventEmitter {
    private indexes;
    private defaultIndex;
    private stats;
    constructor();
    /**
     * Initialize method for CBD service compatibility
     */
    initialize(): Promise<void>;
    search(collection: string, vector: number[], options?: VectorSearchOptions): Promise<SimilarityResult[]>;
    /**
     * Insert method for CBD service compatibility
     */
    insert(id: string, vector: number[], metadata?: Record<string, any>): Promise<any>;
    /**
     * Store a vector with metadata
     */
    storeVector(id: string, vector: number[], metadata?: Record<string, any>, indexName?: string): Promise<void>;
    /**
     * Store multiple vectors in batch
     */
    storeVectorsBatch(vectors: Array<{
        id: string;
        vector: number[];
        metadata?: Record<string, any>;
    }>, indexName?: string): Promise<void>;
    /**
     * Find similar vectors using various similarity metrics
     */
    findSimilar(queryVector: number[], options?: VectorSearchOptions, indexName?: string): Promise<SimilarityResult[]>;
    /**
     * Hybrid search combining vector similarity and metadata filtering
     */
    hybridSearch(queryVector: number[], textQuery?: string, options?: VectorSearchOptions & {
        textWeight?: number;
        vectorWeight?: number;
    }, indexName?: string): Promise<HybridResult[]>;
    /**
     * Update a vector and its metadata
     */
    updateVector(id: string, vector: number[], metadata?: Record<string, any>, indexName?: string): Promise<void>;
    /**
     * Delete a vector from the index
     */
    deleteVector(id: string, indexName?: string): Promise<boolean>;
    /**
     * Create a new vector index
     */
    createVectorIndex(name: string, dimensions: number, algorithm?: 'cosine' | 'euclidean' | 'dot_product' | 'hamming'): Promise<void>;
    /**
     * Drop a vector index
     */
    dropVectorIndex(name: string): Promise<void>;
    /**
     * Get vector by ID
     */
    getVector(id: string, indexName?: string): Promise<VectorRecord | null>;
    /**
     * Get index statistics
     */
    getIndexStats(indexName?: string): Promise<VectorStats | null>;
    /**
     * List all vector indexes
     */
    listIndexes(): Promise<string[]>;
    /**
     * Bulk delete vectors by metadata filter
     */
    deleteByFilter(filters: Record<string, any>, indexName?: string): Promise<number>;
    private getOrCreateIndex;
    private calculateNorm;
    private calculateSimilarity;
    private cosineSimilarity;
    private euclideanSimilarity;
    private dotProduct;
    private matchesFilters;
    private calculateTextSimilarity;
    private trackLatency;
    private percentile;
}
//# sourceMappingURL=VectorStorageEngine.d.ts.map