import { EventEmitter } from 'events';
import { ConflictResolutionContext, ConflictResolutionHistory, ProjectDomain, AIToolType } from '../types';
export interface ConflictAnalysis {
    conflictId: string;
    type: ConflictType;
    severity: ConflictSeverity;
    participants: AIToolType[];
    rootCause: string;
    impactAssessment: ConflictImpact;
    contextualFactors: ContextualFactor[];
    historicalPrecedents: ConflictResolutionHistory[];
    timeConstraints: TimeConstraints;
}
export type ConflictType = 'tool_priority_conflict' | 'resource_contention' | 'output_contradiction' | 'timing_conflict' | 'capability_overlap' | 'quality_vs_speed' | 'comprehensive_vs_focused' | 'accuracy_vs_innovation' | 'domain_preference_mismatch' | 'cache_invalidation_conflict';
export type ConflictSeverity = 'low' | 'medium' | 'high' | 'critical';
export interface ConflictImpact {
    performanceImpact: number;
    qualityImpact: number;
    userExperienceImpact: number;
    resourceUsageImpact: number;
    projectTimelineImpact: number;
    estimatedCost: number;
}
export interface ContextualFactor {
    type: 'domain' | 'urgency' | 'complexity' | 'user_preference' | 'historical' | 'resource' | 'quality_requirement';
    value: any;
    weight: number;
    description: string;
}
export interface TimeConstraints {
    maxResolutionTime: number;
    urgencyLevel: 'low' | 'medium' | 'high' | 'critical';
    deadline?: Date;
    cascadingEffects: boolean;
}
export interface ResolutionStrategy {
    name: string;
    type: ResolutionType;
    description: string;
    confidence: number;
    expectedOutcome: ExpectedOutcome;
    implementationSteps: ResolutionStep[];
    fallbackStrategies: string[];
    monitoringMetrics: string[];
    adaptationTriggers: AdaptationTrigger[];
    strategy?: string;
    reasoning?: string;
}
export type ResolutionType = 'priority_based' | 'consensus_driven' | 'domain_optimized' | 'ml_recommended' | 'hybrid_approach' | 'user_guided' | 'performance_optimized' | 'quality_focused' | 'time_constrained';
export interface ExpectedOutcome {
    resolutionTime: number;
    qualityScore: number;
    performanceScore: number;
    userSatisfactionScore: number;
    resourceEfficiency: number;
    conflictRecurrenceProbability: number;
}
export interface ResolutionStep {
    order: number;
    action: string;
    target: AIToolType | 'orchestrator';
    parameters: Record<string, any>;
    expectedDuration: number;
    successCriteria: string[];
    rollbackProcedure?: string;
}
export interface AdaptationTrigger {
    condition: string;
    threshold: number;
    adaptationAction: string;
    description: string;
}
export interface ConflictLearning {
    patternRecognition: LearnedPattern[];
    successFactors: SuccessFactor[];
    failureAnalysis: FailurePattern[];
    domainSpecificInsights: Record<ProjectDomain, DomainInsight[]>;
    userBehaviorPatterns: UserPattern[];
    optimizationRecommendations: OptimizationRecommendation[];
}
export interface LearnedPattern {
    pattern: string;
    frequency: number;
    successRate: number;
    applicableContexts: string[];
    averageResolutionTime: number;
    qualityImpact: number;
}
export interface SuccessFactor {
    factor: string;
    importance: number;
    conditions: string[];
    measurements: Record<string, number>;
}
export interface FailurePattern {
    pattern: string;
    frequency: number;
    rootCauses: string[];
    preventionStrategies: string[];
    earlyWarningSignals: string[];
}
export interface DomainInsight {
    insight: string;
    applicability: string[];
    confidence: number;
    sourceData: string[];
}
export interface UserPattern {
    pattern: string;
    frequency: number;
    preferredResolutions: string[];
    satisfactionCorrelation: number;
}
export interface OptimizationRecommendation {
    recommendation: string;
    expectedImprovement: number;
    implementationComplexity: 'low' | 'medium' | 'high';
    priority: number;
}
export interface MachineLearningModel {
    name: string;
    type: 'classification' | 'regression' | 'clustering' | 'recommendation';
    accuracy: number;
    trainingData: number;
    lastUpdated: Date;
    features: ModelFeature[];
    predictions: ModelPrediction[];
}
export interface ModelFeature {
    name: string;
    type: 'categorical' | 'numerical' | 'boolean' | 'text';
    importance: number;
    description: string;
}
export interface ModelPrediction {
    input: Record<string, any>;
    output: any;
    confidence: number;
    timestamp: Date;
    actualOutcome?: any;
    accuracy?: number;
}
export declare class AdvancedConflictResolutionService extends EventEmitter {
    private readonly logger;
    private activeConflicts;
    private resolutionHistory;
    private conflictLearning;
    private mlModels;
    private resolutionStrategies;
    private adaptationRules;
    private performanceMetrics;
    private qualityMetrics;
    constructor();
    resolveConflict(context: ConflictResolutionContext): Promise<ResolutionStrategy>;
    private analyzeConflict;
    private assessConflictSeverity;
    private identifyRootCause;
    private assessConflictImpact;
    private extractContextualFactors;
    private findHistoricalPrecedents;
    private determineTimeConstraints;
    private generateResolutionCandidates;
    private generatePriorityBasedStrategy;
    private generateDomainOptimizedStrategy;
    private generatePerformanceOptimizedStrategy;
    private generateQualityFocusedStrategy;
    private generateConsensusDrivenStrategy;
    private generateHybridStrategy;
    private applyMLRecommendations;
    private extractMLFeatures;
    private predictConflictClassification;
    private predictOptimalStrategies;
    private enhanceCandidatesWithML;
    private generateHeuristicMLRecommendations;
    private evaluateAndRankStrategies;
    private calculateStrategyScore;
    private calculateTimeAlignmentScore;
    private calculateSeverityAlignmentScore;
    private calculateHistoricalSuccessScore;
    private selectOptimalStrategy;
    private setupAdaptiveMonitoring;
    private scheduleAdaptationCheck;
    private schedulePerformanceMonitoring;
    private learnFromResolution;
    private updateLearnedPatterns;
    private updateMLModels;
    private generateConflictId;
    private getFallbackStrategy;
    private initializeConflictLearning;
    private initializePerformanceMetrics;
    private initializeQualityMetrics;
    private initializeResolutionStrategies;
    private initializeMLModels;
    private setupEventHandlers;
    private handleConflictAnalyzed;
    private handleStrategySelected;
    private handleResolutionCompleted;
    getConflictStatistics(): Promise<{
        totalConflicts: number;
        resolutionSuccessRate: number;
        averageResolutionTime: number;
        mostCommonConflictTypes: string[];
        bestPerformingStrategies: string[];
    }>;
    getLearnedPatterns(): Promise<ConflictLearning>;
    getMLModelStatus(): Promise<Record<string, any>>;
}
//# sourceMappingURL=advanced-conflict-resolution.d.ts.map