import type { Context } from '../context.js';
type Middleware = (ctx: Context, next: () => Promise<any>) => any;
interface AdaptiveConfig {
    enableBatching?: boolean;
    enableCaching?: boolean;
    enablePrefetching?: boolean;
    enableCompression?: boolean;
    ml?: {
        enabled: boolean;
        modelPath?: string;
        trainingInterval?: number;
    };
    performance?: {
        targetLatency?: number;
        maxMemory?: number;
        adaptiveThreshold?: number;
    };
}
interface RequestPattern {
    path: string;
    method: string;
    frequency: number;
    avgDuration: number;
    timestamp: number;
    queryParams?: Record<string, string>;
    headers?: Record<string, string>;
}
interface CacheStrategy {
    ttl: number;
    pattern: RegExp;
    invalidateOn?: string[];
}
/**
 * Adaptive Performance Optimizer
 *
 * Revolutionary features:
 * - ML-powered request prediction and prefetching
 * - Intelligent query coalescing and batching
 * - Adaptive compression based on content type and size
 * - Zero-copy streaming for large payloads
 * - Smart caching with predictive invalidation
 * - Bloom filter-based routing optimization
 * - Memory pool management for high-frequency objects
 * - JIT compilation hints for hot paths
 */
export declare function adaptiveOptimizer(config?: AdaptiveConfig): Middleware;
/**
 * Bloom Filter for fast route existence checks
 */
declare class BloomFilter {
    private bits;
    private size;
    private hashCount;
    constructor(size: number);
    add(value: string): void;
    test(value: string): boolean;
    private hash;
}
/**
 * Zero-copy streaming for large responses
 */
export declare function streamLargeResponse(data: AsyncIterable<any>): AsyncGenerator<any>;
/**
 * Memory pool for high-frequency objects
 */
export interface IObjectPool<T> {
    acquire(): T;
    release(obj: T): void;
    size(): number;
}
export declare class ObjectPool<T> implements IObjectPool<T> {
    private pool;
    private factory;
    private reset;
    private maxSize;
    constructor(factory: () => T, reset: (obj: T) => void, maxSize?: number);
    acquire(): T;
    release(obj: T): void;
    size(): number;
}
export { type AdaptiveConfig, type RequestPattern, type CacheStrategy, BloomFilter };
//# sourceMappingURL=adaptiveOptimizer.d.ts.map