import { AgentConfig } from '../types/agent';
import { VelocityPrediction, QualityPrediction, ProjectContext, PredictionConfidence, ActualVelocityData, ActualQualityData, AccuracyMetrics, TrendData, ActionableRecommendation } from '../types';
export declare class PerformancePredictionService {
    private config;
    private organizationalMemory;
    private bestPracticeEvolution;
    private crossProjectIntelligence;
    private domainOrchestration;
    private predictionModels;
    private historicalDataStore;
    private predictionCache;
    private featureEngineering;
    private modelRegistry;
    private predictionMetrics;
    private calibrationData;
    private ensembleConfigurations;
    private logger;
    private models;
    private performanceHistory;
    private learningMetrics;
    constructor(config: AgentConfig);
    predictVelocity(projectContext: ProjectContext, predictionHorizon?: number, options?: PredictionOptions): Promise<VelocityPrediction>;
    predictQuality(projectContext: ProjectContext, predictionHorizon?: number, options?: PredictionOptions): Promise<QualityPrediction>;
    validatePredictions(predictionId: string, actualResults: ActualVelocityData | ActualQualityData, predictionType: 'velocity' | 'quality'): Promise<ValidationResults>;
    getPerformanceTrends(scope: 'project' | 'team' | 'organization', timeframe: {
        startDate: Date;
        endDate: Date;
    }, metrics?: string[]): Promise<PerformanceTrends>;
    private initializePredictionSystem;
    private startPredictionEngine;
    private extractVelocityFeatures;
    private extractQualityFeatures;
    private selectVelocityModels;
    private selectQualityModels;
    private generateEnsemblePredictions;
    private generateSessionId;
    private getTeamSizeScore;
    private getComplexityScore;
    private getSecurityScore;
    private getPerformanceScore;
    private calculateAverage;
    private calculateTrend;
    private calculateVariance;
    private calculateConsistency;
    private getWeekOfYear;
    private calculatePredictionConfidence;
    private calculatePredictionVariance;
    private createEmptyPredictionMetrics;
    private logPredictionEvent;
    private checkPredictionCache;
    private gatherHistoricalVelocityData;
    private gatherHistoricalQualityData;
    private getModelsByType;
    private applyDomainAdjustments;
    private calibratePredictions;
    private identifyVelocityFactors;
    private identifyQualityFactors;
    private generateVelocityRecommendations;
    private generateQualityRecommendations;
    private calculateHistoricalBaseline;
    private createPredictionMethodology;
    private cachePrediction;
    private updatePredictionMetrics;
    private convertCachedToVelocityPrediction;
    private convertCachedToQualityPrediction;
    private defineQualityThresholds;
    private retrievePrediction;
    private calculateAccuracyMetrics;
    private updateModelAccuracy;
    private analyzeePredictionErrors;
    private generateCalibrationAdjustments;
    private updateCalibrationData;
    private identifyModelImprovements;
    private generateValidationRecommendations;
    private updateValidationMetrics;
    private initializeVelocityModels;
    private initializeQualityModels;
    private initializeFeatureEngineering;
    private initializeEnsembleConfigurations;
    private loadCalibrationData;
    private retrainModels;
    private cleanupPredictionCache;
    private getSimilarProjectVelocityData;
    private getAdoptedPractices;
    private getTestingMetrics;
    private getCodeQualityMetrics;
    private generateSingleModelPrediction;
    private combineModelPredictions;
    private analyzeVelocityTrends;
    private analyzeQualityTrends;
    private analyzeAccuracyTrends;
    private performFactorAnalysis;
    private generatePerformanceInsights;
    private generateTrendPredictions;
    private generateTrendRecommendations;
    private calculateTrendConfidence;
}
interface PredictionOptions {
    forceRefresh?: boolean;
    includeExplanations?: boolean;
    customFactors?: string[];
    confidenceThreshold?: number;
}
interface ValidationResults {
    predictionId: string;
    predictionType: 'velocity' | 'quality';
    actualResults: ActualVelocityData | ActualQualityData;
    accuracyMetrics: AccuracyMetrics;
    errorAnalysis: ErrorAnalysis;
    calibrationAdjustments: CalibrationAdjustment[];
    modelImprovements: ModelImprovement[];
    recommendations: ActionableRecommendation[];
    validatedAt: Date;
}
interface ErrorAnalysis {
    overallError: number;
    systematicBias: number;
    variabilityError: number;
    factorErrors: Map<string, number>;
    outliers: OutlierPoint[];
    rootCauses: string[];
}
interface OutlierPoint {
    predicted: number;
    actual: number;
    deviation: number;
    context: Record<string, any>;
}
interface CalibrationAdjustment {
    factor: string;
    currentWeight: number;
    adjustedWeight: number;
    rationale: string;
}
interface ModelImprovement {
    type: 'feature_engineering' | 'algorithm_tuning' | 'ensemble_optimization' | 'data_augmentation';
    description: string;
    expectedImprovement: number;
    effort: 'low' | 'medium' | 'high';
    priority: 'low' | 'medium' | 'high';
}
interface PerformanceTrends {
    scope: 'project' | 'team' | 'organization';
    timeframe: {
        startDate: Date;
        endDate: Date;
    };
    velocityTrends: TrendData[];
    qualityTrends: TrendData[];
    accuracyTrends: TrendData[];
    factorAnalysis: FactorAnalysis[];
    insights: PerformanceInsight[];
    predictions: TrendPrediction[];
    recommendations: ActionableRecommendation[];
    confidence: number;
    generatedAt: Date;
}
interface FactorAnalysis {
    factor: string;
    importance: number;
    trend: 'increasing' | 'decreasing' | 'stable';
    correlation: number;
    impact: 'positive' | 'negative' | 'neutral';
}
interface PerformanceInsight {
    type: 'trend' | 'anomaly' | 'opportunity' | 'risk';
    title: string;
    description: string;
    evidence: string[];
    confidence: number;
    impact: 'low' | 'medium' | 'high';
}
interface TrendPrediction {
    metric: string;
    currentValue: number;
    predictedValue: number;
    timeframe: number;
    confidence: PredictionConfidence;
    factors: string[];
}
export {};
//# sourceMappingURL=performance-prediction.d.ts.map