import { EventEmitter } from 'events';
import { LoadTestResult } from './advanced-load-tester';
import { BenchmarkReport } from './performance-benchmark-suite';
export interface RegressionDetectionConfig {
    sensitivityLevel: 'low' | 'medium' | 'high';
    minimumDataPoints: number;
    lookbackPeriod: number;
    statisticalConfidence: number;
    adaptiveLearning: boolean;
    alertThresholds: RegressionThresholds;
    excludeMetrics: string[];
    customMetrics: CustomMetricConfig[];
}
export interface RegressionThresholds {
    responseTimePercent: number;
    throughputPercent: number;
    errorRateAbsolute: number;
    memoryPercent: number;
    cpuPercent: number;
    complianceScoreAbsolute: number;
}
export interface CustomMetricConfig {
    name: string;
    extractorFunction: string;
    thresholdPercent: number;
    importance: 'low' | 'medium' | 'high';
}
export interface PerformanceDataPoint {
    timestamp: Date;
    testName: string;
    category: string;
    metrics: Record<string, number>;
    metadata: Record<string, any>;
    environment: EnvironmentInfo;
}
export interface EnvironmentInfo {
    gitCommit?: string;
    gitBranch?: string;
    nodeVersion: string;
    platform: string;
    architecture: string;
    cpuCores: number;
    totalMemory: number;
    deploymentVersion?: string;
}
export interface RegressionAnalysis {
    testName: string;
    analysisTimestamp: Date;
    regressionDetected: boolean;
    confidence: number;
    severity: 'minor' | 'moderate' | 'severe' | 'critical';
    affectedMetrics: MetricRegression[];
    statisticalTests: StatisticalTestResult[];
    trendAnalysis: TrendAnalysisResult;
    environmentalFactors: EnvironmentalImpact[];
    recommendations: RegressionRecommendation[];
    falsePositiveScore: number;
}
export interface MetricRegression {
    metricName: string;
    baselineValue: number;
    currentValue: number;
    percentageChange: number;
    absoluteChange: number;
    significance: number;
    trend: 'improving' | 'stable' | 'degrading';
    seasonalityDetected: boolean;
    anomalyScore: number;
}
export interface StatisticalTestResult {
    testName: string;
    testType: 'ttest' | 'mannwhitney' | 'ks_test' | 'changepoint';
    pValue: number;
    statistic: number;
    significant: boolean;
    effect_size?: number;
}
export interface TrendAnalysisResult {
    overallTrend: 'improving' | 'stable' | 'degrading';
    trendStrength: number;
    changePoints: ChangePoint[];
    seasonalComponents: SeasonalComponent[];
    forecastedValues: ForecastPoint[];
}
export interface ChangePoint {
    timestamp: Date;
    confidence: number;
    description: string;
    impactMagnitude: number;
}
export interface SeasonalComponent {
    period: string;
    amplitude: number;
    phase: number;
    confidence: number;
}
export interface ForecastPoint {
    timestamp: Date;
    value: number;
    confidenceInterval: {
        lower: number;
        upper: number;
    };
}
export interface EnvironmentalImpact {
    factor: string;
    impact: 'positive' | 'negative' | 'neutral';
    magnitude: number;
    confidence: number;
    description: string;
}
export interface RegressionRecommendation {
    priority: 'low' | 'medium' | 'high' | 'critical';
    category: 'investigation' | 'optimization' | 'infrastructure' | 'process';
    title: string;
    description: string;
    actionItems: string[];
    estimatedEffort: 'low' | 'medium' | 'high';
    expectedImpact: 'low' | 'medium' | 'high';
}
export interface RegressionReport {
    reportId: string;
    generatedAt: Date;
    timePeriod: {
        start: Date;
        end: Date;
    };
    summary: RegressionSummary;
    analyses: RegressionAnalysis[];
    overallTrends: GlobalTrend[];
    systemHealthScore: number;
    recommendedActions: RegressionRecommendation[];
}
export interface RegressionSummary {
    totalTests: number;
    regressionsDetected: number;
    falsePositives: number;
    criticalRegressions: number;
    averageConfidence: number;
    mostAffectedMetrics: string[];
    performanceTrend: 'improving' | 'stable' | 'degrading';
}
export interface GlobalTrend {
    metric: string;
    trend: 'improving' | 'stable' | 'degrading';
    strength: number;
    acrossTests: number;
    significance: number;
}
export declare class RegressionDetector extends EventEmitter {
    private dataDirectory;
    private config;
    private historicalData;
    private _regressionModels;
    private baselineData;
    private knownRegressionsCache;
    constructor(config: RegressionDetectionConfig, dataDirectory?: string);
    getRegressionModels(): Map<string, any>;
    private initializeDetector;
    analyzeLoadTestResults(result: LoadTestResult): Promise<RegressionAnalysis>;
    analyzeBenchmarkResults(report: BenchmarkReport): Promise<RegressionAnalysis[]>;
    addPerformanceData(dataPoint: PerformanceDataPoint): Promise<void>;
    private performRegressionAnalysis;
    private performStatisticalTests;
    private performTTest;
    private performMannWhitneyTest;
    private detectChangePoint;
    private analyzeMetricRegressions;
    private performTrendAnalysis;
    private analyzeEnvironmentalFactors;
    private generateRecommendations;
    generateRegressionReport(timePeriod: {
        start: Date;
        end: Date;
    }): Promise<RegressionReport>;
    private approximateTTestPValue;
    private approximateMannWhitneyPValue;
    private calculateBaseline;
    private calculateRecentAverage;
    private calculateMetricSignificance;
    private determineMetricTrend;
    private detectSeasonality;
    private checkPeriodicPattern;
    private calculateVariance;
    private calculateAnomalyScore;
    private isRegressionThresholdExceeded;
    private detectOverallRegression;
    private calculateConfidence;
    private calculateSeverity;
    private calculateFalsePositiveScore;
    private convertLoadTestToDataPoint;
    private convertBenchmarkToDataPoint;
    private getCurrentEnvironment;
    private getHistoricalData;
    private getBaselineData;
    private extractMetricsTimeSeries;
    private createInsufficientDataAnalysis;
    private calculateLinearTrend;
    private calculateTrendStrength;
    private calculateSlope;
    private detectMultipleChangePoints;
    private analyzeSeasonalComponents;
    private generateForecasts;
    private analyzeGitCommitImpact;
    private analyzeDeploymentImpact;
    private analyzeTimeOfDayImpact;
    private analyzeResourceImpact;
    private loadHistoricalData;
    private initializeBaselines;
    private loadRegressionModels;
    private saveDataPoint;
    private updateRegressionModels;
    private calculateRegressionSummary;
    private analyzeGlobalTrends;
    private calculateSystemHealthScore;
    private consolidateRecommendations;
}
//# sourceMappingURL=regression-detector.d.ts.map