/**
 * Performance Optimizer - System-wide performance optimization strategies
 */
import { EventEmitter } from 'events';
/**
 * Optimization configuration
 */
export interface OptimizationConfig {
    clustering: {
        enabled: boolean;
        workers: number;
        restartOnFailure: boolean;
    };
    connectionPooling: {
        minConnections: number;
        maxConnections: number;
        idleTimeout: number;
        connectionTimeout: number;
    };
    queryOptimization: {
        enabled: boolean;
        batchSize: number;
        parallelQueries: number;
        queryTimeout: number;
    };
    memoryManagement: {
        maxHeapSize: number;
        gcInterval: number;
        monitorLeaks: boolean;
    };
    taskBatching: {
        enabled: boolean;
        batchSize: number;
        batchTimeout: number;
    };
    compression: {
        enabled: boolean;
        algorithm: 'gzip' | 'brotli' | 'lz4';
        level: number;
        threshold: number;
    };
}
/**
 * Performance metrics
 */
export interface PerformanceMetrics {
    cpu: {
        usage: number;
        loadAverage: number[];
        cores: number;
    };
    memory: {
        heapUsed: number;
        heapTotal: number;
        rss: number;
        external: number;
        arrayBuffers: number;
    };
    eventLoop: {
        latency: number;
        utilization: number;
    };
    gc: {
        count: number;
        duration: number;
        lastRun: Date;
    };
    throughput: {
        tasksPerSecond: number;
        requestsPerSecond: number;
        bytesPerSecond: number;
    };
}
/**
 * Connection pool
 */
declare class ConnectionPool<T> {
    private available;
    private inUse;
    private factory;
    private destroyer;
    private config;
    private logger;
    constructor(factory: () => Promise<T>, destroyer: (conn: T) => Promise<void>, config: any);
    initialize(): Promise<void>;
    acquire(): Promise<T>;
    release(conn: T): Promise<void>;
    destroy(): Promise<void>;
    getStats(): any;
}
/**
 * Task batcher
 */
declare class TaskBatcher<T, R> {
    private queue;
    private timer?;
    private processor;
    private config;
    private logger;
    constructor(processor: (batch: T[]) => Promise<R[]>, config: any);
    add(item: T): Promise<R>;
    private scheduleBatch;
    private processBatch;
}
/**
 * Performance Optimizer
 */
export declare class PerformanceOptimizer extends EventEmitter {
    private config;
    private logger;
    private metrics;
    private connectionPools;
    private taskBatchers;
    private workers;
    private gcInterval?;
    private metricsInterval?;
    private eventLoopMonitor?;
    private isRunning;
    constructor(config: OptimizationConfig);
    /**
     * Initialize metrics
     */
    private initializeMetrics;
    /**
     * Start optimizer
     */
    start(): Promise<void>;
    /**
     * Stop optimizer
     */
    stop(): Promise<void>;
    /**
     * Setup clustering
     */
    private setupClustering;
    /**
     * Handle worker message
     */
    private handleWorkerMessage;
    /**
     * Create connection pool
     */
    createConnectionPool<T>(name: string, factory: () => Promise<T>, destroyer: (conn: T) => Promise<void>): ConnectionPool<T>;
    /**
     * Create task batcher
     */
    createTaskBatcher<T, R>(name: string, processor: (batch: T[]) => Promise<R[]>): TaskBatcher<T, R>;
    /**
     * Start monitoring
     */
    private startMonitoring;
    /**
     * Stop monitoring
     */
    private stopMonitoring;
    /**
     * Collect metrics
     */
    private collectMetrics;
    /**
     * Monitor event loop
     */
    private monitorEventLoop;
    /**
     * Setup memory management
     */
    private setupMemoryManagement;
    /**
     * Monitor memory leaks
     */
    private monitorMemoryLeaks;
    /**
     * Optimize query
     */
    optimizeQuery<T>(query: () => Promise<T>, options?: {
        cache?: boolean;
        batch?: boolean;
        parallel?: boolean;
    }): Promise<T>;
    /**
     * Track query performance
     */
    private trackQueryPerformance;
    /**
     * Update worker metrics
     */
    private updateWorkerMetrics;
    /**
     * Get metrics
     */
    getMetrics(): PerformanceMetrics;
    /**
     * Get optimization recommendations
     */
    getRecommendations(): string[];
}
export {};
//# sourceMappingURL=performance-optimizer.d.ts.map