import { SystemPerformanceMetrics, MetricsAlert } from './systemMetricsCollector';
/**
 * Dashboard Configuration
 */
export interface DashboardConfig {
    refreshIntervalMs: number;
    enableRealTime: boolean;
    maxDataPoints: number;
    alertSeverityFilter: ('low' | 'medium' | 'high' | 'critical')[];
    displayComponents: {
        systemOverview: boolean;
        memoryMetrics: boolean;
        performanceMetrics: boolean;
        healthStatus: boolean;
        alertsPanel: boolean;
        trendsAnalysis: boolean;
        correlationTracking: boolean;
    };
}
/**
 * Dashboard Data Snapshot
 */
export interface DashboardSnapshot {
    timestamp: number;
    correlationId: string;
    overview: {
        status: 'healthy' | 'warning' | 'critical';
        uptime: string;
        version: string;
        environment: string;
        totalRequests: number;
        activeConnections: number;
    };
    currentMetrics: SystemPerformanceMetrics | null;
    timeSeries: {
        memoryUsage: Array<{
            timestamp: number;
            value: number;
        }>;
        cpuUsage: Array<{
            timestamp: number;
            value: number;
        }>;
        responseTime: Array<{
            timestamp: number;
            value: number;
        }>;
        errorRate: Array<{
            timestamp: number;
            value: number;
        }>;
        requestRate: Array<{
            timestamp: number;
            value: number;
        }>;
    };
    alerts: MetricsAlert[];
    componentHealth: Array<{
        name: string;
        status: 'healthy' | 'warning' | 'critical';
        details: string;
        lastCheck: number;
    }>;
    performance: {
        avgResponseTime: number;
        requestsPerMinute: number;
        successRate: number;
        errorRate: number;
        throughput: number;
    };
    trends: Array<{
        metric: string;
        direction: 'up' | 'down' | 'stable';
        change: number;
        timeframe: string;
    }>;
}
/**
 * Dashboard Widget Configuration
 */
export interface DashboardWidget {
    id: string;
    type: 'chart' | 'metric' | 'alert' | 'status' | 'table' | 'gauge';
    title: string;
    position: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    config: {
        metric?: string;
        timeRange?: number;
        refreshRate?: number;
        thresholds?: {
            warning: number;
            critical: number;
        };
        chartType?: 'line' | 'bar' | 'gauge' | 'pie';
        aggregation?: 'avg' | 'sum' | 'max' | 'min';
    };
}
/**
 * Monitoring Dashboard
 * Real-time system monitoring interface
 */
export declare class MonitoringDashboard {
    private static instance;
    private config;
    private dashboardTimer?;
    private currentSnapshot?;
    private widgets;
    private subscribers;
    private constructor();
    static getInstance(config?: DashboardConfig): MonitoringDashboard;
    /**
     * Start dashboard monitoring
     */
    startDashboard(): void;
    /**
     * Stop dashboard monitoring
     */
    stopDashboard(): void;
    /**
     * Generate current dashboard snapshot
     */
    generateSnapshot(): Promise<DashboardSnapshot>;
    /**
     * Generate time series data for charts
     */
    private generateTimeSeriesData;
    /**
     * Generate component health summary
     */
    private generateComponentHealthSummary;
    /**
     * Calculate performance summary
     */
    private calculatePerformanceSummary;
    /**
     * Generate trend summary
     */
    private generateTrendSummary;
    /**
     * Format uptime string
     */
    private formatUptime;
    /**
     * Subscribe to dashboard updates
     */
    subscribe(callback: (snapshot: DashboardSnapshot) => void): () => void;
    /**
     * Notify all subscribers of new snapshot
     */
    private notifySubscribers;
    /**
     * Initialize default dashboard widgets
     */
    private initializeDefaultWidgets;
    /**
     * Get dashboard widgets configuration
     */
    getWidgets(): DashboardWidget[];
    /**
     * Update widget configuration
     */
    updateWidget(widgetId: string, updates: Partial<DashboardWidget>): void;
    /**
     * Add new widget
     */
    addWidget(widget: DashboardWidget): void;
    /**
     * Remove widget
     */
    removeWidget(widgetId: string): void;
    /**
     * Get current dashboard snapshot
     */
    getCurrentSnapshot(): DashboardSnapshot | undefined;
    /**
     * Update dashboard configuration
     */
    updateConfiguration(newConfig: Partial<DashboardConfig>): void;
    /**
     * Export dashboard data for external use
     */
    exportDashboardData(): {
        snapshot: DashboardSnapshot | undefined;
        config: DashboardConfig;
        widgets: DashboardWidget[];
        exportTime: number;
    };
    /**
     * Generate dashboard health report
     */
    generateHealthReport(): {
        dashboardHealthy: boolean;
        subscriberCount: number;
        lastUpdateAge: number;
        refreshRate: number;
        dataQuality: 'good' | 'stale' | 'missing';
    };
}
export declare const monitoringDashboard: MonitoringDashboard;
/**
 * Helper function to start monitoring dashboard
 */
export declare function startSystemDashboard(config?: Partial<DashboardConfig>): void;
/**
 * Helper function to get real-time system status
 */
export declare function getSystemDashboardStatus(): {
    status: 'healthy' | 'warning' | 'critical';
    alerts: number;
    uptime: string;
    performance: {
        responseTime: number;
        successRate: number;
        throughput: number;
    };
};
//# sourceMappingURL=monitoringDashboard.d.ts.map