/**
 * @file Performance Regression Detector
 * @description Statistical analysis to detect performance regressions in real-time.
 * Uses moving averages, standard deviation, and trend analysis to identify
 * significant degradations in application performance.
 *
 * Features:
 * - Statistical regression detection
 * - Baseline establishment
 * - Trend analysis
 * - Anomaly detection
 * - Alert thresholds
 * - Historical comparison
 */
/**
 * Regression severity level
 */
export type RegressionSeverity = 'minor' | 'moderate' | 'severe' | 'critical';
/**
 * Regression status
 */
export type RegressionStatus = 'stable' | 'improving' | 'regressing' | 'anomaly';
/**
 * Metric sample for analysis
 */
export interface MetricSample {
    /** Metric name */
    name: string;
    /** Metric value */
    value: number;
    /** Timestamp */
    timestamp: number;
    /** Additional context */
    context?: Record<string, unknown>;
}
/**
 * Baseline statistics for a metric
 */
export interface MetricBaseline {
    /** Metric name */
    name: string;
    /** Mean value */
    mean: number;
    /** Standard deviation */
    standardDeviation: number;
    /** Median value */
    median: number;
    /** 95th percentile */
    p95: number;
    /** 99th percentile */
    p99: number;
    /** Minimum value */
    min: number;
    /** Maximum value */
    max: number;
    /** Sample count */
    sampleCount: number;
    /** Timestamp when baseline was established */
    establishedAt: number;
    /** Last updated timestamp */
    updatedAt: number;
}
/**
 * Detected regression event
 */
export interface RegressionEvent {
    /** Unique event ID */
    id: string;
    /** Metric name */
    metric: string;
    /** Current value */
    currentValue: number;
    /** Baseline value (mean) */
    baselineValue: number;
    /** Percentage deviation from baseline */
    deviation: number;
    /** Z-score (standard deviations from mean) */
    zScore: number;
    /** Regression severity */
    severity: RegressionSeverity;
    /** Detection timestamp */
    timestamp: number;
    /** Number of consecutive regression samples */
    consecutiveRegressions: number;
    /** Additional context */
    context?: Record<string, unknown>;
}
/**
 * Trend analysis result
 */
export interface TrendAnalysis {
    /** Metric name */
    metric: string;
    /** Trend direction */
    direction: 'improving' | 'stable' | 'degrading';
    /** Trend strength (0-1) */
    strength: number;
    /** Slope of linear regression */
    slope: number;
    /** Predicted value at next interval */
    predictedNext: number;
    /** Correlation coefficient (R-squared) */
    rSquared: number;
    /** Analysis period in samples */
    periodSamples: number;
    /** Timestamp */
    timestamp: number;
}
/**
 * Anomaly detection result
 */
export interface AnomalyResult {
    /** Is this value an anomaly */
    isAnomaly: boolean;
    /** Anomaly score (higher = more anomalous) */
    score: number;
    /** Z-score of the value */
    zScore: number;
    /** Is it an upper outlier */
    isUpperOutlier: boolean;
    /** Is it a lower outlier */
    isLowerOutlier: boolean;
    /** Expected range */
    expectedRange: {
        min: number;
        max: number;
    };
}
/**
 * Regression detection configuration
 */
export interface RegressionDetectorConfig {
    /** Enable regression detection */
    enabled: boolean;
    /** Minimum samples required for baseline */
    minBaselineSamples: number;
    /** Maximum samples to store per metric */
    maxSamplesPerMetric: number;
    /** Z-score threshold for regression (default: 2.0) */
    zScoreThreshold: number;
    /** Percentage threshold for regression (default: 0.15 = 15%) */
    percentageThreshold: number;
    /** Consecutive regressions required to trigger alert */
    consecutiveThreshold: number;
    /** Baseline recalculation interval in ms */
    baselineUpdateInterval: number;
    /** Trend analysis window size */
    trendWindowSize: number;
    /** Enable anomaly filtering */
    filterAnomalies: boolean;
    /** Anomaly score threshold */
    anomalyThreshold: number;
    /** Severity thresholds (deviation percentages) */
    severityThresholds: {
        minor: number;
        moderate: number;
        severe: number;
        critical: number;
    };
    /** Callback for regression events */
    onRegression?: (event: RegressionEvent) => void;
    /** Callback for recovery events */
    onRecovery?: (metric: string, baseline: MetricBaseline) => void;
    /** Debug mode */
    debug: boolean;
}
/**
 * Regression detector state summary
 */
export interface DetectorSummary {
    /** Total metrics tracked */
    metricsTracked: number;
    /** Metrics with established baselines */
    metricsWithBaselines: number;
    /** Metrics currently regressing */
    regressingMetrics: string[];
    /** Total regressions detected */
    totalRegressions: number;
    /** Recent regressions (last 24h) */
    recentRegressions: RegressionEvent[];
    /** Overall system status */
    status: RegressionStatus;
}
/**
 * Performance regression detection engine
 */
export declare class RegressionDetector {
    private config;
    private samples;
    private baselines;
    private consecutiveCounts;
    private regressionHistory;
    private baselineUpdateTimers;
    private idCounter;
    constructor(config?: Partial<RegressionDetectorConfig>);
    /**
     * Record a metric sample
     */
    recordSample(sample: MetricSample): RegressionEvent | null;
    /**
     * Get or establish baseline for a metric
     */
    getBaseline(metric: string): MetricBaseline | null;
    /**
     * Manually set baseline for a metric
     */
    setBaseline(metric: string, baseline: Partial<MetricBaseline>): void;
    /**
     * Perform trend analysis for a metric
     */
    analyzeTrend(metric: string): TrendAnalysis | null;
    /**
     * Detect anomalies in a value
     */
    detectAnomaly(value: number, baseline: MetricBaseline): AnomalyResult;
    /**
     * Get regression history
     */
    getRegressionHistory(limit?: number): RegressionEvent[];
    /**
     * Get summary of detector state
     */
    getSummary(): DetectorSummary;
    /**
     * Reset detector state for a specific metric
     */
    resetMetric(metric: string): void;
    /**
     * Reset all detector state
     */
    reset(): void;
    /**
     * Export current state for persistence
     */
    exportState(): {
        baselines: Record<string, MetricBaseline>;
        consecutiveCounts: Record<string, number>;
    };
    /**
     * Import persisted state
     */
    importState(state: {
        baselines?: Record<string, MetricBaseline>;
        consecutiveCounts?: Record<string, number>;
    }): void;
    private maybeUpdateBaseline;
    private checkRegression;
    private calculateSeverity;
    private generateId;
    private log;
}
/**
 * Get or create the global regression detector
 */
export declare function getRegressionDetector(config?: Partial<RegressionDetectorConfig>): RegressionDetector;
/**
 * Reset the detector instance
 */
export declare function resetRegressionDetector(): void;
/**
 * Record a performance sample
 */
export declare function recordPerformanceSample(metric: string, value: number, context?: Record<string, unknown>): RegressionEvent | null;
/**
 * Analyze performance trend for a metric
 */
export declare function analyzePerformanceTrend(metric: string): TrendAnalysis | null;
/**
 * Get current regression summary
 */
export declare function getRegressionSummary(): DetectorSummary;