/**
 * Enhanced NoSQL Storage Engine
 * Integrates unified storage with vector operations and advanced middleware
 */
import { StorageRouter, RouterConfig } from './routing/storage-router';
import { StorageMiddleware, StorageMiddlewareConfig } from './middleware/storage-middleware';
import { VectorStorageBridge } from './integrations/vector-storage-bridge';
export interface EnhancedStorageConfig {
    storage: RouterConfig;
    middleware?: StorageMiddlewareConfig;
    vectorConfig?: {
        enabled: boolean;
        config: any;
    };
    enableAdvancedFeatures?: boolean;
}
/**
 * Enhanced NoSQL Storage Engine
 * Integrates unified storage with vector operations
 */
export declare class NoSQLStorageEngine {
    private config;
    private router;
    private middleware;
    private vectorBridge?;
    private initialized;
    constructor(config: EnhancedStorageConfig);
    /**
     * Initialize the storage engine with optional vector database integration
     */
    initialize(): Promise<void>;
    /**
     * Get the storage router for direct access
     */
    getStorageRouter(): StorageRouter;
    /**
     * Get the vector bridge instance
     */
    getVectorBridge(): VectorStorageBridge | undefined;
    /**
     * Get the middleware instance
     */
    getMiddleware(): StorageMiddleware;
    /**
     * Unified data operation supporting multiple paradigms
     */
    unifiedInsert(collection: string, data: {
        document?: any;
        vector?: Float32Array;
        timeSeries?: any;
        metadata?: Record<string, any>;
    }): Promise<{
        documentId?: string;
        vectorId?: string;
        success: boolean;
    }>;
    /**
     * Unified search across multiple data types
     */
    unifiedSearch(collection: string, query: {
        document?: any;
        vector?: Float32Array;
        similarity?: {
            threshold?: number;
            limit?: number;
        };
        timeSeries?: any;
        hybrid?: boolean;
    }): Promise<{
        documents?: any[];
        vectorResults?: any[];
        timeSeriesPoints?: any[];
        hybridResults?: any[];
    }>;
    /**
     * Get comprehensive metrics across all storage types
     */
    getUnifiedMetrics(): Promise<{
        storage: any;
        vector?: any;
        middleware: any;
        overall: {
            totalOperations: number;
            averageLatency: number;
            errorRate: number;
            healthScore: number;
            cacheHitRate: number;
        };
    }>;
    /**
     * Advanced bulk operations with optimization
     */
    bulkOperation(operations: Array<{
        type: 'insert' | 'update' | 'delete';
        collection: string;
        data: any;
    }>, options?: {
        parallel?: boolean;
        batchSize?: number;
        continueOnError?: boolean;
    }): Promise<{
        successful: number;
        failed: number;
        errors: Array<{
            operation: any;
            error: string;
        }>;
    }>;
    /**
     * Cleanup and destroy all connections
     */
    destroy(): Promise<void>;
    private executeSingleOperation;
    private setupErrorHandlers;
    private generateId;
}
/**
 * Create enhanced storage engine with vector integration
 */
export declare function createEnhancedNoSQLStorage(config: EnhancedStorageConfig): NoSQLStorageEngine;
/**
 * Factory for creating a complete NoSQL setup with all features
 */
export declare function createCompleteNoSQLDB(d1Database: D1Database, kvNamespace: KVNamespace, r2Bucket: R2Bucket, durableObjectNamespace: DurableObjectNamespace, options?: {
    environment?: 'development' | 'production' | 'testing';
    enableVectorDB?: boolean;
    vectorConfig?: any;
    customMiddleware?: StorageMiddlewareConfig;
}): Promise<NoSQLStorageEngine>;
//# sourceMappingURL=enhanced-storage-engine.d.ts.map