/**
 * Vector Storage Bridge - Seamless integration between NoSQL and unified storage
 * Optimizes vector operations through intelligent storage routing
 */
import { StorageRouter } from '../routing/storage-router';
import { NoSQLDBConfig } from '../../vector/nosql-db';
import { Vector, VectorSearchOptions, VectorSearchResult } from '../../vector/types';
import { StorageResult } from '../interfaces/storage-engine';
export interface VectorStorageBridgeConfig {
    storageRouter: StorageRouter;
    vectorDBConfig: NoSQLDBConfig;
    enableHybridOperations: boolean;
    cacheVectorResults: boolean;
    vectorCacheTTL: number;
    enableBatchOptimization: boolean;
}
/**
 * Bridge class that integrates vector operations with the unified storage engine
 */
export declare class VectorStorageBridge {
    private storageRouter;
    private vectorDB;
    private config;
    private vectorCache;
    constructor(config: VectorStorageBridgeConfig);
    /**
     * Initialize the bridge and all components
     */
    initialize(): Promise<void>;
    /**
     * Enhanced vector insert with storage routing optimization
     */
    insertVector(collection: string, vector: Vector, options?: {
        storeInDocument?: boolean;
        documentMetadata?: Record<string, any>;
        enableReplication?: boolean;
    }): Promise<StorageResult<Vector>>;
    /**
     * Enhanced vector search with caching and fallback strategies
     */
    searchVectors(collection: string, queryVector: Float32Array, options?: VectorSearchOptions & {
        enableFallback?: boolean;
        cacheResults?: boolean;
        includeDocuments?: boolean;
    }): Promise<StorageResult<VectorSearchResult[]>>;
    /**
     * Hybrid search combining vector similarity with document queries
     */
    hybridSearch(collection: string, query: {
        vector?: Float32Array;
        document?: any;
        weights?: {
            vector: number;
            document: number;
        };
        limit?: number;
    }): Promise<StorageResult<Array<{
        document: any;
        vector?: VectorSearchResult;
        hybridScore: number;
    }>>>;
    /**
     * Batch vector operations with optimization
     */
    batchInsertVectors(collection: string, vectors: Vector[], options?: {
        batchSize?: number;
        createDocuments?: boolean;
        enableParallel?: boolean;
    }): Promise<StorageResult<{
        successful: string[];
        failed: Array<{
            id: string;
            error: string;
        }>;
    }>>;
    /**
     * Get comprehensive metrics for vector operations
     */
    getVectorMetrics(): Promise<{
        vectorDB: any;
        storage: any;
        cache: {
            hitRate: number;
            size: number;
            totalRequests: number;
        };
    }>;
    /**
     * Cleanup resources
     */
    destroy(): Promise<void>;
    private createStorageAdapter;
    private generateCacheKey;
    private getFromCache;
    private setCache;
    private enhanceWithDocuments;
    private fallbackSearch;
    private recordSearchMetrics;
    private calculateCacheHitRate;
}
/**
 * Factory function to create a vector storage bridge
 */
export declare function createVectorStorageBridge(config: VectorStorageBridgeConfig): VectorStorageBridge;
//# sourceMappingURL=vector-storage-bridge.d.ts.map