import { ProjectContext, AgentConfig, QualityPrediction, QualityRecommendation, QualityThreshold, PredictionConfidence, PredictionData, OrganizationalMemoryService, ActionStep, Risk, Correlation, AccuracyMetrics, ActionableRecommendation, QualityMetric, QualityTrend, QualityRisk, QualityAnalysisConfig, QualityAlertConfig, TimeRange, QualityInsightsDashboard } from '../types/index.js';
export interface QualityTrendAnalysisConfig {
    analysisDepth: 'basic' | 'standard' | 'comprehensive' | 'enterprise';
    predictionHorizon: number;
    confidenceThreshold: number;
    enabledMetrics: QualityMetricType[];
    customMetrics: CustomQualityMetric[];
    thresholdConfiguration: QualityThresholdConfig;
    aiModelsEnabled: boolean;
    ensembleModeling: boolean;
    continuousLearning: boolean;
    patternRecognitionEnabled: boolean;
    alertingEnabled: boolean;
    alertThresholds: AlertThreshold[];
    notificationChannels: NotificationChannel[];
    organizationalMemoryIntegration: boolean;
    crossProjectAnalysis: boolean;
    benchmarkingEnabled: boolean;
    cacheEnabled: boolean;
    cacheTTL: number;
    batchProcessing: boolean;
    maxConcurrentAnalyses: number;
}
export type QualityMetricType = 'defect_rate' | 'code_quality' | 'test_coverage' | 'technical_debt' | 'security_risk' | 'maintainability' | 'performance' | 'reliability' | 'usability' | 'accessibility' | 'documentation_quality' | 'api_quality' | 'deployment_quality';
export interface CustomQualityMetric {
    name: string;
    description: string;
    calculator: (context: ProjectContext, data: any[]) => number;
    aggregation: 'average' | 'sum' | 'max' | 'min' | 'weighted_average';
    weight: number;
    threshold: QualityThreshold;
    category: 'code' | 'process' | 'team' | 'tools' | 'custom';
}
export interface QualityThresholdConfig {
    globalThresholds: Record<QualityMetricType, QualityThreshold>;
    projectSpecificThresholds: Record<string, Record<QualityMetricType, QualityThreshold>>;
    dynamicThresholds: boolean;
    adaptiveAdjustment: boolean;
}
export interface AlertThreshold {
    metric: QualityMetricType;
    severity: 'info' | 'warning' | 'error' | 'critical';
    condition: 'above' | 'below' | 'trend_up' | 'trend_down' | 'anomaly';
    value: number;
    duration: number;
    suppressionTime: number;
}
export interface NotificationChannel {
    type: 'email' | 'slack' | 'teams' | 'webhook' | 'sms';
    configuration: Record<string, any>;
    enabled: boolean;
    severityFilter: string[];
}
export interface QualityAnalysisRequest {
    sessionId: string;
    projectContext: ProjectContext;
    analysisType: 'trend' | 'prediction' | 'comprehensive' | 'realtime';
    timeframe: {
        startDate: Date;
        endDate: Date;
        predictionHorizon?: number;
    };
    scope: {
        includeHistorical: boolean;
        includePredictions: boolean;
        includeRecommendations: boolean;
        includeComparisons: boolean;
    };
    configuration: Partial<QualityTrendAnalysisConfig>;
    customParameters: Record<string, any>;
}
export interface QualityAnalysisResult {
    sessionId: string;
    analysisType: string;
    executedAt: Date;
    projectContext: ProjectContext;
    currentQuality: QualityMetricsSnapshot;
    historicalTrends: QualityTrendAnalysis;
    predictions: QualityPrediction;
    patterns: QualityPattern[];
    anomalies: QualityAnomaly[];
    correlations: QualityCorrelation[];
    insights: QualityInsight[];
    recommendations: QualityRecommendation[];
    alerts: QualityAlert[];
    actionPlans: QualityActionPlan[];
    benchmarks: QualityBenchmark[];
    peerComparisons: PeerComparison[];
    industryStandards: IndustryStandard[];
    confidence: PredictionConfidence;
    methodology: QualityAnalysisMethodology;
    validationResults: QualityValidationResult[];
    processingTime: number;
    dataQuality: DataQualityAssessment;
    nextAnalysisScheduled?: Date;
}
export interface QualityMetricsSnapshot {
    timestamp: Date;
    metrics: Record<QualityMetricType, QualityMetricValue>;
    overallScore: number;
    trend: 'improving' | 'stable' | 'declining' | 'unknown';
    contextualFactors: ContextualFactor[];
}
export interface QualityMetricValue {
    value: number;
    unit: string;
    normalized: number;
    threshold: QualityThreshold;
    status: 'excellent' | 'good' | 'warning' | 'critical';
    trend: TrendDirection;
    confidence: number;
    lastUpdated: Date;
}
export type TrendDirection = 'strongly_up' | 'up' | 'stable' | 'down' | 'strongly_down';
export interface QualityTrendAnalysis {
    projectId: string;
    analysisTimestamp: Date;
    metrics: QualityMetric[];
    trends: QualityTrend[];
    predictions: QualityPrediction[];
    risks: QualityRisk[];
    recommendations: QualityRecommendation[];
    confidence: number;
    metadata: {
        analysisConfig: QualityAnalysisConfig;
        dataPoints: number;
        timeSpan?: number;
        version: string;
    };
}
export interface MetricTrend {
    metric: QualityMetricType;
    direction: TrendDirection;
    slope: number;
    acceleration: number;
    seasonality: SeasonalComponent[];
    changePoints: ChangePoint[];
    significance: number;
    r2: number;
    forecast: TrendForecast;
}
export interface TrendAnalysis {
    overallDirection: TrendDirection;
    strength: number;
    consistency: number;
    volatility: number;
    momentum: number;
    cycleLength?: number;
    trendBreaks: TrendBreak[];
}
export interface QualityPattern {
    id: string;
    type: 'improvement' | 'degradation' | 'cycle' | 'anomaly' | 'correlation';
    name: string;
    description: string;
    metrics: QualityMetricType[];
    pattern: PatternSignature;
    confidence: number;
    frequency: number;
    impact: QualityImpact;
    duration: number;
    context: PatternContext;
    recommendations: string[];
    historicalOccurrences: PatternOccurrence[];
}
export interface QualityAnomaly {
    id: string;
    type: 'spike' | 'drop' | 'plateau' | 'oscillation' | 'drift';
    metric: QualityMetricType;
    timestamp: Date;
    duration: number;
    magnitude: number;
    significance: number;
    expectedValue: number;
    actualValue: number;
    context: AnomalyContext;
    possibleCauses: PossibleCause[];
    impact: QualityImpact;
    resolved: boolean;
    resolutionActions?: string[];
}
export interface QualityCorrelation {
    id: string;
    metrics: QualityMetricType[];
    correlation: Correlation;
    causality: CausalityAnalysis;
    timelag: number;
    strength: number;
    stability: number;
    context: CorrelationContext;
    actionableInsights: string[];
}
export interface QualityInsight {
    id: string;
    type: 'trend' | 'pattern' | 'anomaly' | 'opportunity' | 'risk' | 'benchmark';
    severity: 'info' | 'low' | 'medium' | 'high' | 'critical';
    title: string;
    description: string;
    evidence: InsightEvidence[];
    confidence: PredictionConfidence;
    impact: QualityImpact;
    recommendations: ActionableRecommendation[];
    timeframe: string;
    category: 'immediate' | 'short_term' | 'long_term' | 'strategic';
    stakeholders: string[];
    metrics: QualityMetricType[];
    aiGenerated: boolean;
    validated: boolean;
}
export interface QualityAlert {
    id: string;
    type: 'threshold' | 'trend' | 'anomaly' | 'prediction' | 'pattern';
    severity: 'info' | 'warning' | 'error' | 'critical';
    metric: QualityMetricType;
    title: string;
    description: string;
    value: number;
    threshold: number;
    timestamp: Date;
    status: 'active' | 'acknowledged' | 'resolved' | 'suppressed';
    assignee?: string;
    escalationLevel: number;
    suppressUntil?: Date;
    resolutionActions: string[];
    context: AlertContext;
    relatedAlerts: string[];
    automatedActions: AutomatedAction[];
}
export interface QualityActionPlan {
    id: string;
    title: string;
    description: string;
    category: 'improvement' | 'maintenance' | 'prevention' | 'remediation';
    priority: 'low' | 'medium' | 'high' | 'critical';
    targetMetrics: QualityMetricType[];
    expectedImpact: QualityImpact;
    effort: 'low' | 'medium' | 'high';
    duration: string;
    phases: ActionPlanPhase[];
    dependencies: string[];
    risks: Risk[];
    successCriteria: SuccessCriterion[];
    assignee: string;
    deadline: Date;
    status: 'planned' | 'in_progress' | 'completed' | 'on_hold' | 'cancelled';
    progress: number;
    milestones: ActionPlanMilestone[];
    resources: RequiredResource[];
}
export interface QualityBenchmark {
    type: 'internal' | 'external' | 'industry' | 'best_practice';
    name: string;
    description: string;
    metrics: Record<QualityMetricType, BenchmarkValue>;
    source: string;
    date: Date;
    applicability: BenchmarkApplicability;
    gaps: QualityGap[];
    recommendations: string[];
}
export interface PeerComparison {
    peerType: 'similar_projects' | 'same_team' | 'same_domain' | 'same_size';
    peers: PeerProject[];
    comparison: QualityComparison;
    insights: ComparativeInsight[];
    recommendations: string[];
}
export interface IndustryStandard {
    standard: string;
    version: string;
    authority: string;
    requirements: QualityRequirement[];
    compliance: ComplianceAssessment;
    gaps: ComplianceGap[];
    improvementPlan: string[];
}
export interface ContextualFactor {
    factor: string;
    impact: number;
    description: string;
    controllable: boolean;
    category: 'team' | 'process' | 'technical' | 'external' | 'organizational';
}
export interface SeasonalityAnalysis {
    hasSeasonality: boolean;
    seasonalStrength: number;
    periods: SeasonalPeriod[];
    patterns: SeasonalPattern[];
}
export interface VolatilityAnalysis {
    volatilityIndex: number;
    volatilityTrend: TrendDirection;
    highVolatilityPeriods: VolatilityPeriod[];
    volatilityFactors: VolatilityFactor[];
}
export interface CyclicalPattern {
    type: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'release_cycle';
    period: number;
    amplitude: number;
    phase: number;
    strength: number;
    metrics: QualityMetricType[];
    confidence: number;
}
export interface SeasonalComponent {
    period: 'daily' | 'weekly' | 'monthly' | 'quarterly';
    strength: number;
    pattern: number[];
}
export interface ChangePoint {
    timestamp: Date;
    type: 'level' | 'trend' | 'variance';
    magnitude: number;
    confidence: number;
    cause?: string;
    context: Record<string, any>;
}
export interface TrendForecast {
    horizon: number;
    predictions: PredictionData[];
    confidence: PredictionConfidence;
    assumptions: string[];
    factors: string[];
}
export interface TrendBreak {
    timestamp: Date;
    type: 'structural' | 'temporary' | 'seasonal';
    magnitude: number;
    duration: number;
    cause: string;
    impact: string;
}
export interface PatternSignature {
    shape: 'linear' | 'exponential' | 'logarithmic' | 'cyclical' | 'step' | 'spike';
    parameters: Record<string, number>;
    duration: number;
    amplitude: number;
    frequency?: number;
}
export interface QualityImpact {
    scope: 'local' | 'project' | 'team' | 'organization';
    severity: 'low' | 'medium' | 'high' | 'critical';
    categories: string[];
    estimatedCost: number;
    timeframe: string;
    affectedStakeholders: string[];
    businessImpact: string;
    technicalImpact: string;
}
export interface PatternContext {
    projectPhase: string;
    teamSize: number;
    technology: string[];
    domain: string;
    complexity: string;
    externalFactors: string[];
}
export interface PatternOccurrence {
    timestamp: Date;
    duration: number;
    context: PatternContext;
    outcome: 'positive' | 'negative' | 'neutral';
    resolution: string[];
}
export interface AnomalyContext {
    preceding_events: string[];
    concurrent_events: string[];
    environmental_factors: string[];
    process_changes: string[];
    team_changes: string[];
    technical_changes: string[];
}
export interface PossibleCause {
    cause: string;
    probability: number;
    evidence: string[];
    category: 'process' | 'technical' | 'human' | 'external';
    actionable: boolean;
    investigation_steps: string[];
}
export interface CausalityAnalysis {
    direction: 'unidirectional' | 'bidirectional' | 'complex';
    confidence: number;
    methodology: string;
    evidence: string[];
    confounding_factors: string[];
}
export interface CorrelationContext {
    timeframe: string;
    conditions: string[];
    moderating_factors: string[];
    stability_across_projects: number;
}
export interface InsightEvidence {
    type: 'statistical' | 'observational' | 'historical' | 'predictive';
    description: string;
    confidence: number;
    source: string;
    timestamp: Date;
}
export interface AlertContext {
    triggering_conditions: string[];
    environmental_context: Record<string, any>;
    related_metrics: QualityMetricType[];
    historical_occurrences: number;
    typical_resolution_time: number;
}
export interface AutomatedAction {
    action: string;
    trigger: string;
    implementation: string;
    rollback_procedure: string;
    approval_required: boolean;
    executed: boolean;
    execution_time?: Date;
    result?: string;
}
export interface ActionPlanPhase {
    name: string;
    description: string;
    duration: string;
    activities: ActionStep[];
    deliverables: string[];
    dependencies: string[];
    risks: Risk[];
    success_criteria: string[];
}
export interface SuccessCriterion {
    criterion: string;
    target: number;
    measurement: string;
    timeframe: string;
    critical: boolean;
}
export interface ActionPlanMilestone {
    name: string;
    date: Date;
    description: string;
    deliverables: string[];
    success_criteria: string[];
    status: 'pending' | 'in_progress' | 'completed' | 'missed';
}
export interface RequiredResource {
    type: 'human' | 'technical' | 'financial' | 'time';
    description: string;
    quantity: number;
    unit: string;
    availability: 'available' | 'limited' | 'unavailable';
    cost: number;
}
export interface BenchmarkValue {
    value: number;
    percentile: number;
    grade: 'excellent' | 'good' | 'average' | 'below_average' | 'poor';
    gap: number;
    improvement_potential: number;
}
export interface BenchmarkApplicability {
    project_size_match: number;
    domain_match: number;
    technology_match: number;
    maturity_match: number;
    overall_similarity: number;
}
export interface QualityGap {
    metric: QualityMetricType;
    current_value: number;
    benchmark_value: number;
    gap: number;
    relative_gap: number;
    priority: 'low' | 'medium' | 'high' | 'critical';
    effort_to_close: 'low' | 'medium' | 'high';
    recommendations: string[];
}
export interface PeerProject {
    id: string;
    name: string;
    similarity_score: number;
    metrics: Record<QualityMetricType, number>;
    characteristics: ProjectCharacteristics;
}
export interface ProjectCharacteristics {
    size: 'small' | 'medium' | 'large' | 'enterprise';
    domain: string;
    technology: string[];
    team_size: number;
    maturity: 'startup' | 'growth' | 'mature' | 'legacy';
    complexity: 'low' | 'medium' | 'high' | 'very_high';
}
export interface QualityComparison {
    relative_performance: Record<QualityMetricType, ComparisonResult>;
    overall_ranking: number;
    strengths: string[];
    weaknesses: string[];
    opportunities: string[];
}
export interface ComparisonResult {
    percentile: number;
    above_average: boolean;
    gap_to_leader: number;
    improvement_potential: number;
    trend_comparison: 'better' | 'similar' | 'worse';
}
export interface ComparativeInsight {
    type: 'strength' | 'weakness' | 'opportunity' | 'best_practice';
    description: string;
    evidence: string[];
    recommendations: string[];
    learning_opportunity: boolean;
}
export interface QualityRequirement {
    requirement: string;
    metric: QualityMetricType;
    threshold: number;
    mandatory: boolean;
    assessment_method: string;
}
export interface ComplianceAssessment {
    overall_score: number;
    grade: 'compliant' | 'mostly_compliant' | 'partially_compliant' | 'non_compliant';
    requirements_met: number;
    total_requirements: number;
    critical_gaps: number;
    assessment_date: Date;
}
export interface ComplianceGap {
    requirement: string;
    current_state: string;
    required_state: string;
    gap_severity: 'low' | 'medium' | 'high' | 'critical';
    remediation_effort: 'low' | 'medium' | 'high';
    remediation_timeline: string;
    remediation_cost: number;
}
export interface SeasonalPeriod {
    period: 'daily' | 'weekly' | 'monthly' | 'quarterly';
    strength: number;
    significance: number;
}
export interface SeasonalPattern {
    period: SeasonalPeriod;
    pattern: number[];
    metrics: QualityMetricType[];
    stability: number;
}
export interface VolatilityPeriod {
    start: Date;
    end: Date;
    intensity: number;
    affected_metrics: QualityMetricType[];
    causes: string[];
}
export interface VolatilityFactor {
    factor: string;
    contribution: number;
    controllable: boolean;
    mitigation: string[];
}
export interface QualityAnalysisMethodology {
    approach: string;
    algorithms: string[];
    data_sources: string[];
    feature_engineering: FeatureEngineeringDetails;
    model_ensemble: ModelEnsembleDetails;
    validation: ValidationMethodology;
    assumptions: string[];
    limitations: string[];
    confidence_calculation: string;
}
export interface FeatureEngineeringDetails {
    features_extracted: number;
    feature_selection_method: string;
    dimensionality_reduction: boolean;
    feature_importance: Record<string, number>;
    temporal_features: boolean;
    domain_features: boolean;
}
export interface ModelEnsembleDetails {
    models_used: string[];
    weighting_strategy: string;
    voting_mechanism: string;
    model_performance: Record<string, AccuracyMetrics>;
    ensemble_improvement: number;
}
export interface ValidationMethodology {
    method: string;
    cross_validation: boolean;
    holdout_percentage: number;
    temporal_validation: boolean;
    metrics: string[];
    baseline_comparison: boolean;
}
export interface QualityValidationResult {
    validation_type: 'statistical' | 'domain_expert' | 'historical' | 'cross_validation';
    passed: boolean;
    score: number;
    details: string;
    confidence: number;
    timestamp: Date;
    validator: string;
}
export interface DataQualityAssessment {
    completeness: number;
    accuracy: number;
    consistency: number;
    timeliness: number;
    validity: number;
    overall_score: number;
    issues: DataQualityIssue[];
    recommendations: string[];
}
export interface DataQualityIssue {
    type: 'missing' | 'inconsistent' | 'outdated' | 'invalid' | 'duplicate';
    description: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    affected_metrics: QualityMetricType[];
    impact: string;
    resolution: string;
}
export declare class QualityTrendAnalysisService {
    private readonly organizationalMemory;
    private readonly config;
    private readonly logger;
    private readonly qualityMetrics;
    private readonly trendAnalysisCache;
    private readonly predictionModels;
    private readonly alertSubscriptions;
    constructor(organizationalMemory: OrganizationalMemoryService, config: AgentConfig);
    analyzeQualityTrends(projectId: string, analysisConfig: QualityAnalysisConfig): Promise<QualityTrendAnalysis>;
    generateQualityPredictions(projectId: string, metrics: QualityMetric[], predictionHorizon: number): Promise<QualityPrediction[]>;
    assessQualityRisks(trends: QualityTrend[], predictions: QualityPrediction[]): Promise<QualityRisk[]>;
    generateRecommendations(trends: QualityTrend[], predictions: QualityPrediction[], risks: QualityRisk[]): Promise<QualityRecommendation[]>;
    setupQualityAlerts(projectId: string, alertConfig: QualityAlertConfig): Promise<void>;
    getQualityInsightsDashboard(projectId: string, timeRange: TimeRange): Promise<QualityInsightsDashboard>;
    private collectQualityMetrics;
    private analyzeTrends;
    private calculateTrend;
    private predictWithModel;
    private combineEnsemblePredictions;
    private assessTrendRisks;
    private initializePredictionModels;
    private getRelevantModels;
    private getUniqueMetricTypes;
    private groupMetricsByType;
    private calculateLinearSlope;
    private calculateCorrelation;
    private calculateVolatility;
    private detectSeasonality;
    private detectPeriodicPattern;
    private calculateAutocorrelation;
    private determineTrendDirection;
    private calculateTrendStrength;
    private calculateStatisticalSignificance;
    private detectAnomalies;
    private calculateTrendConfidence;
    private isCacheValid;
    private calculateOverallConfidence;
    private checkQualityAlerts;
    private assessPredictionRisks;
    private assessCorrelationRisks;
    private deduplicateAndPrioritizeRisks;
    private calculateRiskScore;
    private generateRiskMitigationRecommendations;
    private generateTrendBasedRecommendations;
    private generatePredictionBasedRecommendations;
    private generateBestPracticeRecommendations;
    private prioritizeRecommendations;
    private generateRiskId;
    private calculateTrendImpact;
    private generateSubscriptionId;
    private generateQualitySummary;
    private getActiveAlerts;
    private collectCodeQualityMetrics;
    private collectTestQualityMetrics;
    private collectPerformanceMetrics;
    private collectSecurityMetrics;
    private collectDocumentationMetrics;
    private collectDependencyMetrics;
    private predictLinearRegression;
    private predictExponentialSmoothing;
    private predictArima;
    private predictNeuralNetwork;
    private calculateAverageTimeInterval;
    private confidenceToNumber;
}
export default QualityTrendAnalysisService;
//# sourceMappingURL=quality-trend-analysis.d.ts.map