import { EventEmitter } from 'events';
import { PredictionResult, AIToolType, ToolExecutionContext } from '../types';
export interface DeveloperProfile {
    id: string;
    preferences: DeveloperPreferences;
    workPatterns: WorkPattern[];
    skillLevel: SkillLevel;
    domainExpertise: DomainExpertise[];
    learningStyle: LearningStyle;
    productivityMetrics: ProductivityMetrics;
    feedbackHistory: FeedbackHistory[];
}
export interface DeveloperPreferences {
    preferredTools: AIToolType[];
    toolPriorities: Record<AIToolType, number>;
    responseTimePreference: 'fast' | 'balanced' | 'comprehensive';
    qualityVsSpeedTrade: number;
    explainabilityRequirement: 'low' | 'medium' | 'high';
    automationLevel: 'minimal' | 'moderate' | 'aggressive';
    interactionStyle: 'hands_on' | 'guided' | 'autonomous';
    learningOrientation: 'exploration' | 'efficiency' | 'mastery';
}
export interface WorkPattern {
    pattern: string;
    frequency: number;
    timeOfDay: string[];
    dayOfWeek: string[];
    sessionDuration: number;
    taskComplexity: 'simple' | 'moderate' | 'complex';
    multitaskingLevel: number;
    focusLevel: number;
    collaborationLevel: number;
}
export interface SkillLevel {
    overall: 'beginner' | 'intermediate' | 'advanced' | 'expert';
    domains: Record<string, 'beginner' | 'intermediate' | 'advanced' | 'expert'>;
    tools: Record<AIToolType, 'beginner' | 'intermediate' | 'advanced' | 'expert'>;
    improvementRate: number;
    adaptabilityScore: number;
}
export interface DomainExpertise {
    domain: string;
    level: 'novice' | 'competent' | 'proficient' | 'expert' | 'master';
    experienceYears: number;
    projectsCompleted: number;
    certifications: string[];
    specializations: string[];
}
export interface LearningStyle {
    preferredApproach: 'visual' | 'auditory' | 'kinesthetic' | 'reading';
    pace: 'fast' | 'moderate' | 'slow';
    depth: 'surface' | 'deep' | 'strategic';
    feedback: 'immediate' | 'periodic' | 'delayed';
    structure: 'structured' | 'flexible' | 'self_directed';
}
export interface ProductivityMetrics {
    tasksPerHour: number;
    errorRate: number;
    revisionCycles: number;
    timeToCompletion: Record<string, number>;
    qualityScore: number;
    learningVelocity: number;
    toolEfficiency: Record<AIToolType, number>;
    collaborationEffectiveness: number;
}
export interface FeedbackHistory {
    timestamp: Date;
    toolUsed: AIToolType;
    taskType: string;
    satisfaction: number;
    effectiveness: number;
    suggestions: string[];
    issuesReported: string[];
    improvementObserved: boolean;
}
export interface SessionContext {
    sessionId: string;
    startTime: Date;
    currentDuration: number;
    tasksCompleted: number;
    toolsUsed: AIToolType[];
    focusLevel: number;
    interruptionCount: number;
    energyLevel: 'low' | 'medium' | 'high';
    progressTowardsGoals: number;
    challengesEncountered: string[];
}
export interface EnvironmentalContext {
    timeOfDay: string;
    dayOfWeek: string;
    workLocation: 'office' | 'home' | 'remote' | 'mobile';
    teammates: number;
    meetingsScheduled: number;
    deadlinePressure: 'low' | 'medium' | 'high' | 'critical';
    resourceAvailability: ResourceAvailability;
    externalFactors: ExternalFactor[];
}
export interface ResourceAvailability {
    computationalResources: number;
    networkBandwidth: number;
    timeAvailable: number;
    attentionCapacity: number;
    mentalEnergy: number;
}
export interface ExternalFactor {
    type: 'deadline' | 'meeting' | 'interruption' | 'collaboration' | 'learning' | 'research';
    impact: number;
    duration: number;
    description: string;
}
export interface PredictionModel {
    name: string;
    type: 'neural_network' | 'decision_tree' | 'ensemble' | 'bayesian' | 'hybrid';
    accuracy: number;
    precision: number;
    recall: number;
    f1Score: number;
    trainingDataSize: number;
    features: ModelFeature[];
    lastTraining: Date;
    version: string;
    confidenceThreshold: number;
}
export interface ModelFeature {
    name: string;
    type: 'categorical' | 'numerical' | 'boolean' | 'text' | 'temporal';
    importance: number;
    distribution: any;
    correlations: Record<string, number>;
    engineered: boolean;
    description: string;
}
export interface PredictionScenario {
    scenario: string;
    probability: number;
    tools: AIToolType[];
    reasoning: string;
    confidence: number;
    expectedOutcome: ScenarioOutcome;
    riskFactors: string[];
    successIndicators: string[];
}
export interface ScenarioOutcome {
    taskCompletionTime: number;
    qualityScore: number;
    userSatisfaction: number;
    learningValue: number;
    resourceEfficiency: number;
    skillImprovement: number;
}
export interface ToolRecommendation {
    tool: AIToolType;
    confidence: number;
    reasoning: string;
    expectedBenefit: ExpectedBenefit;
    usage: RecommendedUsage;
    alternatives: ToolAlternative[];
    personalizations: Personalization[];
}
export interface ExpectedBenefit {
    efficiency: number;
    quality: number;
    learning: number;
    satisfaction: number;
    timeToValue: number;
    skillDevelopment: string[];
}
export interface RecommendedUsage {
    sequence: number;
    timing: 'immediate' | 'after_analysis' | 'for_validation' | 'as_needed';
    duration: number;
    parameters: Record<string, any>;
    interactions: ToolInteraction[];
}
export interface ToolInteraction {
    withTool: AIToolType;
    type: 'sequential' | 'parallel' | 'validation' | 'enhancement';
    timing: 'before' | 'during' | 'after';
    dataExchange: string[];
}
export interface ToolAlternative {
    tool: AIToolType;
    similarity: number;
    tradeoffs: string[];
    whenToUse: string[];
}
export interface Personalization {
    aspect: 'interface' | 'timing' | 'depth' | 'interaction' | 'output';
    adjustment: string;
    reasoning: string;
    impact: number;
}
export interface LearningInsight {
    pattern: string;
    confidence: number;
    impact: number;
    frequency: number;
    contexts: string[];
    recommendations: string[];
    validationNeeded: boolean;
}
export declare class PredictiveToolSelectionService extends EventEmitter {
    private readonly logger;
    private developerProfiles;
    private sessionContexts;
    private predictionModels;
    private learningInsights;
    private usageHistory;
    private performanceHistory;
    private feedbackData;
    private predictionCache;
    private cacheTimeout;
    private predictionAccuracy;
    private modelPerformance;
    constructor();
    predictOptimalTools(context: ToolExecutionContext, userProfile?: DeveloperProfile): Promise<PredictionResult>;
    private buildPredictiveContext;
    private extractBasePredictiveContext;
    private extractSessionId;
    private getDeveloperProfile;
    private createDefaultDeveloperProfile;
    private getSessionContext;
    private buildEnvironmentalContext;
    private categorizeTimeOfDay;
    private getRecentActions;
    private calculateSessionDuration;
    private getSuccessfulPatterns;
    private getProjectHistory;
    private generatePredictionScenarios;
    private generateEfficiencyScenario;
    private generateQualityScenario;
    private generateLearningScenario;
    private generateExplorationScenario;
    private generatePersonalizedScenario;
    private calculateScenarioProbability;
    private getUnfamiliarTools;
    private applyPredictionModels;
    private generateToolRecommendation;
    private calculateExpectedBenefit;
    private getSkillMultiplier;
    private determineRecommendedUsage;
    private generateToolInteractions;
    private findToolAlternatives;
    private generatePersonalizations;
    private calculateToolConfidence;
    private getHistoricalSuccessRate;
    private getFamiliarityBoost;
    private calculateScenarioAlignment;
    private assessContextAppropriateness;
    private generateToolReasoning;
    private rankToolRecommendations;
    private calculateRankingScore;
    private calculatePreferenceAlignment;
    private synthesizePredictionResult;
    private calculateOverallConfidence;
    private calculateConsistencyBonus;
    private generateOverallReasoning;
    private generateSuggestedPreparation;
    private generateAlternativeScenarios;
    private generatePredictionId;
    private getCachedPrediction;
    private cachePrediction;
    private generateFallbackPrediction;
    private recordPredictionForLearning;
    recordPredictionOutcome(predictionId: string, actualTools: AIToolType[], userSatisfaction: number, taskCompletion: boolean): Promise<void>;
    private updatePredictionAccuracy;
    private extractLearningInsights;
    private initializePredictionModels;
    private setupLearningPipeline;
    private performPeriodicLearning;
    private updateDeveloperProfiles;
    private updateSingleDeveloperProfile;
    private calculateToolUsageFrequency;
    private updatePredictionModels;
    private cleanupOldData;
    private startCacheCleanup;
    updateDeveloperPreferences(developerId: string, preferences: Partial<DeveloperPreferences>): Promise<void>;
    getPredictionStatistics(): Promise<{
        totalPredictions: number;
        accuracy: number;
        cacheHitRate: number;
        averageConfidence: number;
    }>;
    getLearningInsights(): Promise<LearningInsight[]>;
    getModelPerformance(): Promise<Record<string, any>>;
}
//# sourceMappingURL=predictive-tool-selection.d.ts.map