/**
 * StorageRouter - Intelligent routing of operations to appropriate storage backends
 * Optimized for sub-10ms latency and efficient resource utilization
 */
import { StorageEngine, StorageResult, Document, DocumentQuery, VectorData, VectorQuery, VectorSearchResult, TimeSeriesPoint, TimeSeriesQuery, TransactionContext, BatchOperation, StorageConfig, PerformanceMetrics, ShardInfo, ChangeEvent, StreamConfig, StorageBackend, ShardingStrategy } from '../interfaces/storage-engine';
import { D1Config } from '../adapters/d1-adapter';
import { KVConfig } from '../adapters/kv-adapter';
import { R2Config } from '../adapters/r2-adapter';
import { DurableObjectConfig } from '../adapters/durable-object-adapter';
export interface RouterConfig {
    d1: D1Config;
    kv: KVConfig;
    r2: R2Config;
    durableObject: DurableObjectConfig;
    sharding: ShardingStrategy;
    routing: RoutingRules;
    fallback: FallbackConfig;
    optimization: OptimizationConfig;
}
export interface RoutingRules {
    documentSizeThreshold: number;
    vectorDimensionThreshold: number;
    timeSeriesRetention: {
        hot: string;
        warm: string;
        cold: string;
    };
    cacheRules: {
        documentCache: boolean;
        vectorCache: boolean;
        queryResultCache: boolean;
        cacheTTL: number;
    };
}
export interface FallbackConfig {
    enabled: boolean;
    fallbackOrder: StorageBackend[];
    maxRetries: number;
    fallbackDelay: number;
}
export interface OptimizationConfig {
    enableQueryOptimization: boolean;
    enableBatchOptimization: boolean;
    enableCompressionOptimization: boolean;
    enableShardingOptimization: boolean;
    adaptiveRouting: boolean;
}
export interface RoutedOperation {
    id: string;
    backend: StorageBackend;
    shard?: string;
    priority: 'high' | 'medium' | 'low';
    estimatedLatency: number;
    fallbackBackends: StorageBackend[];
}
export declare class StorageRouter implements StorageEngine {
    private d1;
    private kv;
    private r2;
    private durableObject;
    private config;
    private metrics;
    private shardMap;
    private routingCache;
    private adaptiveMetrics;
    constructor(config: RouterConfig);
    initialize(config: StorageConfig): Promise<void>;
    destroy(): Promise<void>;
    health(): Promise<{
        healthy: boolean;
        shards: ShardInfo[];
    }>;
    insertDocument(collection: string, document: Document): Promise<StorageResult<Document>>;
    findDocuments(collection: string, query: DocumentQuery): Promise<StorageResult<Document[]>>;
    updateDocument(collection: string, id: string, update: Partial<Document>): Promise<StorageResult<Document>>;
    deleteDocument(collection: string, id: string): Promise<StorageResult<boolean>>;
    countDocuments(collection: string, filter?: Record<string, any>): Promise<StorageResult<number>>;
    insertVector(collection: string, vector: VectorData): Promise<StorageResult<VectorData>>;
    searchVectors(collection: string, query: VectorQuery): Promise<StorageResult<VectorSearchResult[]>>;
    deleteVector(collection: string, id: string): Promise<StorageResult<boolean>>;
    upsertVector(collection: string, vector: VectorData): Promise<StorageResult<VectorData>>;
    insertTimeSeriesPoint(point: TimeSeriesPoint): Promise<StorageResult<boolean>>;
    insertTimeSeriesBatch(points: TimeSeriesPoint[]): Promise<StorageResult<number>>;
    queryTimeSeries(query: TimeSeriesQuery): Promise<StorageResult<TimeSeriesPoint[]>>;
    aggregateTimeSeries(query: TimeSeriesQuery): Promise<StorageResult<Record<string, any>>>;
    private routeDocumentOperation;
    private routeVectorOperation;
    private routeDocumentQuery;
    private routeVectorQuery;
    private executeWithFallback;
    private updateAdaptiveMetrics;
    private getOptimalBackendForCollection;
    private getBackendLatency;
    private getEstimatedLatency;
    private hashQuery;
    private initializeShardMap;
    insertMany(collection: string, documents: Document[]): Promise<StorageResult<Document[]>>;
    updateMany(collection: string, filter: Record<string, any>, update: Partial<Document>): Promise<StorageResult<number>>;
    deleteMany(collection: string, filter: Record<string, any>): Promise<StorageResult<number>>;
    insertHybrid(collection: string, document: Document, vector: VectorData): Promise<StorageResult<{
        document: Document;
        vector: VectorData;
    }>>;
    searchHybrid(collection: string, vectorQuery: VectorQuery, documentFilter?: Record<string, any>): Promise<StorageResult<{
        document: Document;
        score: number;
    }[]>>;
    executeSQL(sql: string, params?: any[]): Promise<StorageResult<any>>;
    executeBatchSQL(operations: {
        sql: string;
        params?: any[];
    }[]): Promise<StorageResult<any[]>>;
    putBlob(key: string, data: ArrayBuffer | Uint8Array, metadata?: Record<string, string>): Promise<StorageResult<string>>;
    getBlob(key: string): Promise<StorageResult<{
        data: ArrayBuffer;
        metadata?: Record<string, string>;
    }>>;
    deleteBlob(key: string): Promise<StorageResult<boolean>>;
    listBlobs(prefix?: string, limit?: number): Promise<StorageResult<{
        key: string;
        size: number;
        lastModified: Date;
    }[]>>;
    putKV(key: string, value: any, options?: {
        ttl?: number;
        metadata?: Record<string, string>;
    }): Promise<StorageResult<boolean>>;
    getKV(key: string): Promise<StorageResult<{
        value: any;
        metadata?: Record<string, string>;
    }>>;
    deleteKV(key: string): Promise<StorageResult<boolean>>;
    listKV(prefix?: string, limit?: number): Promise<StorageResult<{
        key: string;
        metadata?: Record<string, string>;
    }[]>>;
    ensureIndex(collection: string, field: string, options?: {
        unique?: boolean;
        sparse?: boolean;
    }): Promise<StorageResult<boolean>>;
    dropIndex(collection: string, field: string): Promise<StorageResult<boolean>>;
    getIndexes(collection: string): Promise<StorageResult<{
        field: string;
        type: string;
        options: any;
    }[]>>;
    optimizeCollection(collection: string): Promise<StorageResult<{
        indices: number;
        compressionRatio: number;
    }>>;
    beginTransaction(isolation?: 'read_committed' | 'serializable'): Promise<StorageResult<TransactionContext>>;
    commitTransaction(context: TransactionContext): Promise<StorageResult<boolean>>;
    rollbackTransaction(context: TransactionContext): Promise<StorageResult<boolean>>;
    executeBatch(batch: BatchOperation): Promise<StorageResult<any[]>>;
    watchCollection(collection: string, config: StreamConfig): Promise<AsyncIterable<ChangeEvent>>;
    createStream(config: StreamConfig): Promise<ReadableStream>;
    getMetrics(): Promise<PerformanceMetrics>;
    getShardInfo(): Promise<ShardInfo[]>;
    optimizePerformance(): Promise<StorageResult<{
        optimizations: string[];
    }>>;
    createBackup(collections?: string[]): Promise<StorageResult<string>>;
    restoreBackup(backupId: string): Promise<StorageResult<boolean>>;
    createCollection(name: string, options?: {
        sharding?: any;
        indexing?: any;
    }): Promise<StorageResult<boolean>>;
    dropCollection(name: string): Promise<StorageResult<boolean>>;
    listCollections(): Promise<StorageResult<{
        name: string;
        documents: number;
        size: number;
    }[]>>;
    private cacheDocument;
    private getCachedDocument;
    private invalidateDocumentCache;
    private cacheQueryResult;
    private getCachedQueryResult;
    private insertLargeDocument;
    private deleteLargeDocument;
    private determineTimeSeriesTier;
    private parseTimeRange;
    private queryHotTimeSeries;
    private queryWarmTimeSeries;
    private queryColdTimeSeries;
    private buildTimeSeriesSQL;
    private buildTimeSeriesAggregationSQL;
    private getCollectionVectorCount;
}
//# sourceMappingURL=storage-router.d.ts.map