import { EventEmitter } from 'events';
/**
 * Resource management interfaces
 */
export interface ResourceMetrics {
    cpu: CPUMetrics;
    memory: MemoryMetrics;
    disk: DiskMetrics;
    network: NetworkMetrics;
    process: ProcessMetrics;
    system: SystemMetrics;
}
export interface CPUMetrics {
    usage: number;
    cores: number;
    loadAverage: number[];
    temperature?: number;
    frequency?: number;
}
export interface MemoryMetrics {
    total: number;
    free: number;
    used: number;
    available: number;
    usage: number;
    heap: HeapMetrics;
    gc: GCMetrics;
}
export interface HeapMetrics {
    used: number;
    total: number;
    limit: number;
    external: number;
    arrayBuffers: number;
}
export interface GCMetrics {
    collections: number;
    duration: number;
    reclaimedBytes: number;
    avgPauseTime: number;
}
export interface DiskMetrics {
    total: number;
    free: number;
    used: number;
    usage: number;
    iops: number;
    throughput: number;
    paths: Record<string, DiskPathMetrics>;
}
export interface DiskPathMetrics {
    size: number;
    used: number;
    free: number;
    usage: number;
}
export interface NetworkMetrics {
    bytesReceived: number;
    bytesSent: number;
    packetsReceived: number;
    packetsSent: number;
    connectionsActive: number;
    errors: number;
}
export interface ProcessMetrics {
    pid: number;
    uptime: number;
    threads: number;
    handles: number;
    cpu: number;
    memory: number;
}
export interface SystemMetrics {
    platform: string;
    arch: string;
    nodeVersion: string;
    hostname: string;
    uptime: number;
    loadAverage: number[];
}
export interface ResourceAlert {
    type: AlertType;
    severity: AlertSeverity;
    resource: string;
    message: string;
    threshold: number;
    currentValue: number;
    timestamp: Date;
    metadata?: Record<string, any>;
}
export declare enum AlertType {
    CPU_HIGH = "cpu_high",
    MEMORY_HIGH = "memory_high",
    DISK_FULL = "disk_full",
    DISK_LOW = "disk_low",
    NETWORK_ERROR = "network_error",
    PROCESS_UNRESPONSIVE = "process_unresponsive",
    GC_PRESSURE = "gc_pressure",
    TEMPERATURE_HIGH = "temperature_high"
}
export declare enum AlertSeverity {
    LOW = 1,
    MEDIUM = 2,
    HIGH = 3,
    CRITICAL = 4
}
export interface ResourceThreshold {
    type: AlertType;
    warning: number;
    critical: number;
    sustained: boolean;
}
export interface ResourceManagerConfig {
    monitoringIntervalMs: number;
    alertSustainedDurationMs: number;
    cleanupIntervalMs: number;
    thresholds: ResourceThreshold[];
    enableGCMonitoring: boolean;
    enableDiskMonitoring: boolean;
    enableNetworkMonitoring: boolean;
    diskPaths: string[];
    historicalDataRetentionMs: number;
}
/**
 * Comprehensive resource manager with proactive monitoring
 */
export declare class AdvancedResourceManager extends EventEmitter {
    private config;
    private logger;
    private isMonitoring;
    private monitoringInterval?;
    private cleanupInterval?;
    private currentMetrics?;
    private metricsHistory;
    private alertHistory;
    private sustainedAlerts;
    private gcMetrics;
    private networkBaseline;
    constructor(config?: ResourceManagerConfig);
    /**
     * Start resource monitoring
     */
    start(): Promise<void>;
    /**
     * Stop resource monitoring
     */
    stop(): Promise<void>;
    /**
     * Get current resource metrics
     */
    getCurrentMetrics(): ResourceMetrics | undefined;
    /**
     * Get historical metrics
     */
    getHistoricalMetrics(durationMs?: number): ResourceMetrics[];
    /**
     * Get resource utilization trends
     */
    getResourceTrends(durationMs?: number): ResourceTrends;
    /**
     * Get active alerts
     */
    getActiveAlerts(): ResourceAlert[];
    /**
     * Trigger resource cleanup
     */
    performResourceCleanup(): Promise<{
        memoryFreed: number;
        diskSpaceFreed: number;
        cacheCleared: boolean;
    }>;
    /**
     * Optimize resource usage based on current metrics
     */
    optimizeResources(): Promise<{
        recommendations: string[];
        actionsApplied: string[];
    }>;
    private monitorResources;
    private collectMetrics;
    private collectCPUMetrics;
    private collectMemoryMetrics;
    private collectDiskMetrics;
    private collectNetworkMetrics;
    private collectProcessMetrics;
    private collectSystemMetrics;
    private getDiskUsage;
    private checkThresholds;
    private handleSustainedAlert;
    private createAlert;
    private handleCriticalAlert;
    private getMetricValue;
    private generateAlertMessage;
    private setupGCMonitoring;
    private setupEventListeners;
    private cleanupHistoricalData;
    private cleanupTempFiles;
    private calculateTrend;
    private predictResourceExhaustion;
    private createEmptyTrends;
}
interface TrendMetrics {
    slope: number;
    direction: 'increasing' | 'decreasing' | 'stable';
    volatility: number;
}
interface ResourceTrends {
    cpu: TrendMetrics;
    memory: TrendMetrics;
    disk: TrendMetrics;
    network: {
        bytesReceived: TrendMetrics;
        bytesSent: TrendMetrics;
    };
    predictedExhaustion: ResourceExhaustionPrediction;
}
interface ResourceExhaustionPrediction {
    memoryExhaustionTime: number | null;
    diskExhaustionTime: number | null;
}
export declare const resourceManager: AdvancedResourceManager;
export {};
//# sourceMappingURL=resourceManager.d.ts.map