import { ExpertType, WorkflowType } from '../types/workflow';
import { EventEmitter } from 'events';
/**
 * Performance analytics interfaces
 */
export interface PerformanceMetrics {
    system: SystemPerformanceMetrics;
    application: ApplicationPerformanceMetrics;
    workflow: WorkflowPerformanceMetrics;
    api: APIPerformanceMetrics;
    cache: CachePerformanceMetrics;
    errors: ErrorPerformanceMetrics;
}
export interface SystemPerformanceMetrics {
    cpu: {
        average: number;
        peak: number;
        distribution: number[];
        trends: TrendAnalysis;
    };
    memory: {
        average: number;
        peak: number;
        efficiency: number;
        leaks: MemoryLeakAnalysis[];
        trends: TrendAnalysis;
    };
    disk: {
        usage: number;
        iops: number;
        throughput: number;
        trends: TrendAnalysis;
    };
    network: {
        bandwidth: number;
        latency: number;
        packets: NetworkPacketStats;
        trends: TrendAnalysis;
    };
}
export interface ApplicationPerformanceMetrics {
    uptime: number;
    responseTime: {
        average: number;
        p50: number;
        p95: number;
        p99: number;
    };
    throughput: {
        requestsPerSecond: number;
        workflowsPerHour: number;
        expertsPerMinute: number;
    };
    availability: {
        percentage: number;
        downtime: number;
        incidents: IncidentSummary[];
    };
    performance: {
        score: number;
        bottlenecks: BottleneckIdentification[];
        recommendations: PerformanceRecommendation[];
    };
}
export interface WorkflowPerformanceMetrics {
    totalWorkflows: number;
    completedWorkflows: number;
    failedWorkflows: number;
    successRate: number;
    averageDuration: {
        linear: number;
        parallel: number;
        custom: number;
    };
    expertPerformance: Map<ExpertType, ExpertPerformanceStats>;
    optimizationImpact: OptimizationImpactAnalysis;
}
export interface APIPerformanceMetrics {
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    averageResponseTime: number;
    rateLimitHits: number;
    tokenUsage: {
        total: number;
        average: number;
        peak: number;
        cost: number;
    };
    circuitBreakerTrips: number;
}
export interface CachePerformanceMetrics {
    hitRate: number;
    missRate: number;
    evictionRate: number;
    memoryUsage: number;
    averageRetrievalTime: number;
    warmingEfficiency: number;
    sizingEfficiency: number;
}
export interface ErrorPerformanceMetrics {
    totalErrors: number;
    errorRate: number;
    errorDistribution: Map<string, number>;
    recoverySuccessRate: number;
    averageRecoveryTime: number;
    criticalErrors: number;
}
export interface TrendAnalysis {
    direction: 'increasing' | 'decreasing' | 'stable';
    velocity: number;
    confidence: number;
    prediction: number;
}
export interface MemoryLeakAnalysis {
    detected: boolean;
    severity: 'low' | 'medium' | 'high' | 'critical';
    growthRate: number;
    estimatedTimeToExhaustion: number;
    possibleSources: string[];
}
export interface NetworkPacketStats {
    sent: number;
    received: number;
    dropped: number;
    retransmitted: number;
}
export interface IncidentSummary {
    id: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    duration: number;
    impact: string;
    resolution: string;
    timestamp: Date;
}
export interface BottleneckIdentification {
    component: string;
    severity: number;
    impact: string;
    recommendations: string[];
    estimatedImprovement: number;
}
export interface PerformanceRecommendation {
    category: 'optimization' | 'scaling' | 'configuration' | 'architecture';
    priority: 'low' | 'medium' | 'high' | 'critical';
    title: string;
    description: string;
    estimatedImpact: number;
    implementationEffort: 'low' | 'medium' | 'high';
    cost: 'none' | 'low' | 'medium' | 'high';
}
export interface ExpertPerformanceStats {
    totalConsultations: number;
    averageResponseTime: number;
    successRate: number;
    cacheHitRate: number;
    resourceUtilization: {
        cpu: number;
        memory: number;
    };
    qualityMetrics: {
        averageResponseLength: number;
        topicCoverage: number;
        contextUtilization: number;
    };
}
export interface OptimizationImpactAnalysis {
    totalOptimizations: number;
    averageSpeedup: number;
    resourceSavings: {
        cpu: number;
        memory: number;
        time: number;
    };
    strategyEffectiveness: Map<string, StrategyEffectiveness>;
}
export interface StrategyEffectiveness {
    applications: number;
    averageImprovement: number;
    successRate: number;
    resourceImpact: {
        cpu: number;
        memory: number;
    };
}
export interface PerformanceAlert {
    id: string;
    type: PerformanceAlertType;
    severity: AlertSeverity;
    message: string;
    metric: string;
    threshold: number;
    currentValue: number;
    trend: TrendAnalysis;
    timestamp: Date;
    resolved: boolean;
    actions: PerformanceAction[];
}
export declare enum PerformanceAlertType {
    DEGRADATION = "degradation",
    THRESHOLD_BREACH = "threshold_breach",
    ANOMALY = "anomaly",
    PREDICTION = "prediction"
}
export declare enum AlertSeverity {
    INFO = "info",
    WARNING = "warning",
    ERROR = "error",
    CRITICAL = "critical"
}
export interface PerformanceAction {
    type: 'automatic' | 'manual';
    description: string;
    executed: boolean;
    result?: string;
}
/**
 * Advanced performance analytics system
 */
export declare class PerformanceAnalytics extends EventEmitter {
    private config;
    private logger;
    private isRunning;
    private analyticsInterval?;
    private metricsHistory;
    private alerts;
    private baselineMetrics?;
    private anomalyThresholds;
    private workflowStats;
    private expertStats;
    private optimizationStats;
    constructor(config?: {
        analysisIntervalMs: number;
        historyRetentionMs: number;
        anomalyDetectionEnabled: boolean;
        predictiveAnalysisEnabled: boolean;
        autoOptimizationEnabled: boolean;
    });
    /**
     * Start performance analytics
     */
    start(): Promise<void>;
    /**
     * Stop performance analytics
     */
    stop(): Promise<void>;
    /**
     * Get current performance metrics
     */
    getCurrentMetrics(): Promise<PerformanceMetrics>;
    /**
     * Get performance trends over time
     */
    getPerformanceTrends(durationMs?: number): PerformanceTrendAnalysis;
    /**
     * Get performance comparison against baseline
     */
    getBaselineComparison(): PerformanceComparison | null;
    /**
     * Get active performance alerts
     */
    getActiveAlerts(): PerformanceAlert[];
    /**
     * Get performance recommendations
     */
    getRecommendations(): PerformanceRecommendation[];
    /**
     * Generate performance report
     */
    generateReport(options?: {
        includeHistory?: boolean;
        includePredictions?: boolean;
        includeRecommendations?: boolean;
    }): PerformanceReport;
    /**
     * Record workflow execution for analysis
     */
    recordWorkflowExecution(workflowId: string, type: WorkflowType, duration: number, success: boolean, resourceUsage: any, optimizationsApplied: string[]): void;
    /**
     * Record expert consultation for analysis
     */
    recordExpertConsultation(expertType: ExpertType, duration: number, success: boolean, cacheHit: boolean, resourceUsage: any, responseMetrics: any): void;
    private performAnalysisCycle;
    private collectCurrentMetrics;
    private detectAnomalies;
    private performPredictiveAnalysis;
    private createPerformanceAlert;
    private executeAutomaticActions;
    private calculateTrend;
    private extractMetricValue;
    private calculateSlope;
    private calculateMemoryEfficiency;
    private calculateResponseTimeStats;
    private calculateThroughputStats;
    private calculateAvailabilityStats;
    private calculatePerformanceScore;
    private calculateWorkflowSuccessRate;
    private calculateAverageDurations;
    private generateSystemRecommendations;
    private generateApplicationRecommendations;
    private generateWorkflowRecommendations;
    private generateAPIRecommendations;
    private generateCacheRecommendations;
    private initializeAnomalyThresholds;
    private initializeOptimizationStats;
    private createDefaultExpertStats;
    private cleanupHistoricalData;
    private analyzeTrendCategory;
    private compareMetrics;
    private generatePerformanceSummary;
    private generateInsights;
    private suggestActions;
}
interface PerformanceTrendAnalysis {
    system: any;
    application: any;
    workflow: any;
    api: any;
    cache: any;
    errors: any;
}
interface PerformanceComparison {
    cpuChange: number;
    memoryChange: number;
    responseTimeChange: number;
    throughputChange: number;
    overallImprovement: number;
}
interface PerformanceSummary {
    overallHealth: 'excellent' | 'good' | 'warning' | 'critical';
    keyMetrics: {
        cpuUsage: number;
        memoryUsage: number;
        responseTime: number;
        successRate: number;
    };
    criticalIssues: number;
    recommendations: number;
}
interface PerformanceReport {
    timestamp: Date;
    summary: PerformanceSummary;
    currentMetrics: PerformanceMetrics;
    trends?: PerformanceTrendAnalysis;
    baselineComparison: PerformanceComparison | null;
    recommendations: PerformanceRecommendation[];
    alerts: PerformanceAlert[];
    insights: string[];
    actions: string[];
}
export declare const performanceAnalytics: PerformanceAnalytics;
export {};
//# sourceMappingURL=performanceAnalytics.d.ts.map