import { SQLiteDatabase, DeveloperPattern } from '../storage/sqlite-db.js';
import { FileChange } from '../watchers/file-watcher.js';
export interface PatternExtractionResult {
    type: string;
    description: string;
    frequency: number;
}
export interface PatternAnalysisResult {
    detected: string[];
    violations: string[];
    recommendations: string[];
    learned?: Array<{
        id: string;
        type: string;
        content: Record<string, any>;
        frequency: number;
        confidence: number;
    }>;
}
export interface RelevantPattern {
    patternId: string;
    patternType: string;
    patternContent: Record<string, any>;
    frequency: number;
    contexts: string[];
    examples: Array<{
        code: string;
    }>;
    confidence: number;
}
export declare class PatternEngine {
    private database;
    private rustLearner;
    private rustCircuitBreaker;
    constructor(database: SQLiteDatabase);
    extractPatterns(path: string): Promise<PatternExtractionResult[]>;
    analyzeFilePatterns(filePath: string, content: string): Promise<Array<{
        type: string;
        description: string;
        confidence: number;
    }>>;
    private detectLanguage;
    private generateContentHash;
    private getPatternByType;
    private fallbackFilePatternAnalysis;
    learnFromCodebase(path: string, progressCallback?: (current: number, total: number, message: string) => void): Promise<Array<{
        id: string;
        type: string;
        content: Record<string, any>;
        frequency: number;
        confidence: number;
        contexts: string[];
        examples: Array<{
            code: string;
        }>;
    }>>;
    analyzeFileChange(change: FileChange): Promise<PatternAnalysisResult>;
    findRelevantPatterns(problemDescription: string, currentFile?: string, selectedCode?: string): Promise<RelevantPattern[]>;
    private extractKeywords;
    predictApproach(problemDescription: string, context: Record<string, any>): Promise<{
        approach: string;
        confidence: number;
        reasoning: string;
        patterns: string[];
        complexity: 'low' | 'medium' | 'high';
    }>;
    learnFromAnalysis(analysisData: any): Promise<void>;
    updateFromChange(change: FileChange): Promise<void>;
    getPatternsByType(patternType: string, limit?: number): Promise<DeveloperPattern[]>;
    getAllPatterns(limit?: number): Promise<DeveloperPattern[]>;
    getPatternStatistics(): Promise<{
        totalPatterns: number;
        byType: Record<string, number>;
        mostUsed: DeveloperPattern[];
        recentlyUsed: DeveloperPattern[];
    }>;
    private fallbackPatternExtraction;
    private fallbackChangeAnalysis;
    private fallbackRelevantPatterns;
    private fallbackApproachPrediction;
    private updatePatternUsageStats;
    private isPatternUsedInContent;
    /**
     * Build feature map using Rust analyzer with TypeScript fallback
     * Uses CircuitBreaker pattern for graceful degradation
     */
    buildFeatureMap(projectPath: string): Promise<Array<{
        id: string;
        featureName: string;
        primaryFiles: string[];
        relatedFiles: string[];
        dependencies: string[];
    }>>;
    /**
     * Collect files from directory (async with depth limit)
     * @param dirPath - Directory to collect files from
     * @param projectPath - Project root path (for relative path calculation)
     * @param maxDepth - Maximum recursion depth
     * @param currentDepth - Current depth (for internal recursion tracking)
     */
    private collectFilesInDirectory;
    /**
     * Route request to files with confidence scoring
     * Returns files ranked by relevance with confidence indicators
     */
    routeRequestToFiles(problemDescription: string, projectPath: string): Promise<{
        intendedFeature: string;
        targetFiles: string[];
        workType: 'feature' | 'bugfix' | 'refactor' | 'test';
        suggestedStartPoint: string;
        confidence: number;
        reasoning: string;
    } | null>;
    findFilesUsingPatterns(patterns: RelevantPattern[], projectPath: string): Promise<string[]>;
}
//# sourceMappingURL=pattern-engine.d.ts.map