import { EventEmitter } from 'events';
import { UserProfile, ImprovementSuggestion, LearningMetrics, LearningOutcome, RuleCondition, RuleAction, ConversationMessage, UserFeedback } from '../types/memory';
import { MemoryManager } from './memory-manager';
import { KnowledgeGraphBuilder } from './knowledge-graph';
export interface LearningConfig {
    adaptationEnabled: boolean;
    learningRate: number;
    confidenceThreshold: number;
    feedbackWeight: number;
    maxRules: number;
    ruleEvaluationInterval: number;
    profileUpdateInterval: number;
    metricsCollectionInterval: number;
}
export interface AdaptationContext {
    userId: string;
    sessionId: string;
    projectPath?: string;
    messageHistory: ConversationMessage[];
    currentIntent: string;
    userFeedback?: UserFeedback;
    performanceMetrics: Record<string, number>;
}
export interface LearningEvent {
    type: 'feedback' | 'pattern' | 'outcome' | 'preference';
    userId: string;
    timestamp: Date;
    data: Record<string, unknown>;
    confidence: number;
    impact: 'low' | 'medium' | 'high';
}
export interface AdaptationDecision {
    ruleId: string;
    action: RuleAction;
    confidence: number;
    reasoning: string;
    expectedImpact: string;
    rollbackPlan?: string;
}
export declare class LearningAdaptationEngine extends EventEmitter {
    private logger;
    private memoryManager;
    private knowledgeGraph;
    private config;
    private learningSystem;
    private adaptationRules;
    private feedbackLoops;
    private userProfiles;
    private activeLearning;
    private ruleEvaluationTimer?;
    private profileUpdateTimer?;
    private metricsTimer?;
    constructor(memoryManager: MemoryManager, knowledgeGraph: KnowledgeGraphBuilder, config?: LearningConfig);
    getUserProfile(userId: string): Promise<UserProfile>;
    updateUserProfile(userId: string, updates: Partial<UserProfile>): Promise<boolean>;
    learnFromInteraction(context: AdaptationContext, outcome: LearningOutcome): Promise<void>;
    processFeedback(userId: string, messageId: string, feedback: UserFeedback): Promise<void>;
    createAdaptationRule(userId: string, condition: RuleCondition, action: RuleAction, priority?: number): Promise<string>;
    evaluateAdaptationRules(context: AdaptationContext): Promise<AdaptationDecision[]>;
    applyAdaptation(decision: AdaptationDecision, context: AdaptationContext): Promise<boolean>;
    generateImprovementSuggestions(userId: string): Promise<ImprovementSuggestion[]>;
    implementSuggestion(suggestionId: string, userId: string): Promise<boolean>;
    getLearningMetrics(userId?: string): Promise<LearningMetrics>;
    getAdaptationEffectiveness(): Promise<{
        ruleId: string;
        effectiveness: number;
    }[]>;
    private createUserProfile;
    private getDefaultPreferences;
    private getDefaultSkillAssessment;
    private getDefaultCodeStyle;
    private getDefaultCommunicationStyle;
    private getDefaultUserContext;
    private inferLearningMethod;
    private calculateRetention;
    private updateSkillAssessment;
    private extractSkillFromContext;
    private adjustSkillLevel;
    private updatePreferencesFromInteraction;
    private identifyWorkPatterns;
    private inferPatternType;
    private calculateSessionDuration;
    private generateAdaptationRules;
    private updateFeedbackLoops;
    private evaluateRuleCondition;
    private evaluatePatternMatch;
    private evaluateThreshold;
    private evaluateContext;
    private evaluateUserBehavior;
    private executeRuleAction;
    private adjustResponseStyle;
    private modifySuggestions;
    private updatePreferences;
    private calculateRuleEffectiveness;
    private calculateSuggestionScore;
    private startTimers;
    private evaluateAllRules;
    private updateAllProfiles;
    private performProfileMaintenance;
    private updateSkillTrajectory;
    private collectMetrics;
    private analyzeWorkflowPatterns;
    private analyzeSkillGaps;
    private analyzePreferenceConflicts;
    private executeSuggestionImplementation;
    private getUserSpecificMetrics;
    private predictRuleImpact;
    private generateRollbackPlan;
    private learnFromExplicitFeedback;
    private adjustAdaptationRules;
    private updatePreferencesFromFeedback;
    private generateRuleId;
    shutdown(): Promise<void>;
}
//# sourceMappingURL=learning-adaptation.d.ts.map