import { EventEmitter } from 'events';
import type { ProjectContext } from '../types/index.js';
import { ExaPatternDiscoveryService, type DiscoveredPattern, type PatternCategory } from './exa-pattern-discovery.js';
import { AIToolIntegrationPlaybookService } from './ai-tool-integration-playbook.js';
import { MCPManager } from './mcp-client.js';
import type { PatternAnalysisResult } from '../types/exa-pattern-discovery.js';
import type { TDDPhase, AIToolType } from '../types/ai-tool-integration.js';
export interface PatternDiscoveryIntegrationConfig {
    enableTDDIntegration: boolean;
    enableRealTimeGuidance: boolean;
    enableAutomaticValidation: boolean;
    cacheValidatedPatterns: boolean;
    maxConcurrentAnalyses: number;
    patternApplicationTimeout: number;
}
export interface TDDPatternRequest {
    phase: TDDPhase;
    objective: string;
    context: ProjectContext;
    preferredPatterns?: PatternCategory[];
    constraints?: string[];
}
export interface TDDPatternResponse {
    patterns: DiscoveredPattern[];
    phaseGuidance: PhaseSpecificGuidance;
    integrationSteps: IntegrationStep[];
    validationResults: ValidationResult[];
    nextPhaseRecommendations: NextPhaseRecommendation[];
}
export interface PhaseSpecificGuidance {
    phase: TDDPhase;
    primaryPatterns: DiscoveredPattern[];
    supportingPatterns: DiscoveredPattern[];
    implementationStrategy: string;
    toolRecommendations: ToolRecommendation[];
    qualityChecks: QualityCheck[];
}
export interface IntegrationStep {
    order: number;
    title: string;
    description: string;
    toolsInvolved: AIToolType[];
    estimatedDuration: string;
    dependencies: string[];
    validationCriteria: string[];
    codeSnippets?: CodeSnippet[];
}
export interface ValidationResult {
    patternId: string;
    validationType: 'semantic' | 'documentation' | 'logical' | 'practical';
    status: 'valid' | 'warning' | 'invalid';
    confidence: number;
    issues: ValidationIssue[];
    recommendations: string[];
}
export interface ValidationIssue {
    severity: 'low' | 'medium' | 'high' | 'critical';
    category: 'compatibility' | 'performance' | 'security' | 'maintainability';
    description: string;
    suggestion: string;
}
export interface NextPhaseRecommendation {
    targetPhase: TDDPhase;
    recommendedPatterns: string[];
    preparationSteps: string[];
    successCriteria: string[];
}
export interface ToolRecommendation {
    tool: AIToolType;
    purpose: string;
    priority: 'required' | 'recommended' | 'optional';
    configuration?: Record<string, any>;
}
export interface QualityCheck {
    name: string;
    description: string;
    automatable: boolean;
    tools: AIToolType[];
    criteria: string[];
}
export interface CodeSnippet {
    language: string;
    framework?: string;
    purpose: string;
    code: string;
    explanation: string;
    testable: boolean;
}
export interface PatternApplicationRequest {
    pattern: DiscoveredPattern;
    targetContext: ProjectContext;
    applicationScope: 'function' | 'class' | 'module' | 'project';
    customization?: PatternCustomization;
}
export interface PatternCustomization {
    parameters: Record<string, any>;
    adaptations: string[];
    constraints: string[];
    testingRequirements: string[];
}
export interface PatternApplicationResult {
    success: boolean;
    generatedCode: GeneratedCode[];
    tests: GeneratedTest[];
    documentation: string;
    integrationNotes: string[];
    performanceAnalysis: PerformanceAnalysis;
    refactoringOpportunities: RefactoringOpportunity[];
}
export interface GeneratedCode {
    filePath: string;
    content: string;
    language: string;
    framework?: string;
    dependencies: string[];
    patterns: string[];
}
export interface GeneratedTest {
    testType: 'unit' | 'integration' | 'e2e';
    filePath: string;
    content: string;
    coverage: TestCoverage;
    dependencies: string[];
}
export interface TestCoverage {
    lines: number;
    functions: number;
    branches: number;
    statements: number;
}
export interface PerformanceAnalysis {
    estimatedImpact: 'positive' | 'neutral' | 'negative';
    metrics: PerformanceMetric[];
    optimizationSuggestions: string[];
}
export interface PerformanceMetric {
    name: string;
    baseline: number;
    projected: number;
    unit: string;
    confidence: number;
}
export interface RefactoringOpportunity {
    location: string;
    type: 'simplification' | 'optimization' | 'modernization';
    description: string;
    impact: 'low' | 'medium' | 'high';
    effort: 'low' | 'medium' | 'high';
}
export declare class PatternDiscoveryIntegrationService extends EventEmitter {
    private readonly logger;
    private patternDiscovery;
    private aiToolIntegration;
    private mcpManager;
    private config;
    private activeAnalyses;
    private tddPhaseCache;
    private validationCache;
    private integrationStats;
    constructor(patternDiscovery: ExaPatternDiscoveryService, aiToolIntegration: AIToolIntegrationPlaybookService, mcpManager: MCPManager, config?: Partial<PatternDiscoveryIntegrationConfig>);
    discoverPatternsForTDDPhase(request: TDDPatternRequest): Promise<TDDPatternResponse>;
    applyPatternToTDDPhase(pattern: DiscoveredPattern, phase: TDDPhase, context: ProjectContext): Promise<PatternApplicationResult>;
    performComprehensivePatternAnalysis(pattern: DiscoveredPattern, context: ProjectContext): Promise<PatternAnalysisResult>;
    enhancePatternWithCrossToolInsights(pattern: DiscoveredPattern, context: ProjectContext): Promise<DiscoveredPattern>;
    provideRealTimeGuidance(currentCode: string, context: ProjectContext, objective: string): Promise<PatternApplicationResult>;
    private createTDDPhaseQueries;
    private filterPatternsForTDDPhase;
    private generatePhaseGuidance;
    private createTDDIntegrationSteps;
    private validatePatternsForTDD;
    private generateNextPhaseRecommendations;
    private mergeWithDefaultConfig;
    private setupEventHandlers;
    private initializeIntegration;
    private setupTDDIntegration;
    private setupCacheManagement;
    private cleanupCaches;
    private generateTDDCacheKey;
    private updateProcessingTimeStats;
    private handleTDDPatternsDiscovered;
    private handlePatternAppliedToTDD;
    private handlePatternAnalysisCompleted;
    private handleRealTimeGuidanceProvided;
    private createEmptyPhaseGuidance;
    private determineApplicationScope;
    private createTDDCustomization;
    private executePatternApplication;
    private enhanceWithTDDAnalysis;
    private createFailedApplicationResult;
    private createEmptyApplicationResult;
    private structureAnalysisResults;
    private createFailedAnalysisResult;
    private extractLibraryFromPattern;
    private inferComplexityFromContext;
    private extractTechnologiesFromContext;
    private isPatternApplicableToContext;
    private generateImplementationStrategy;
    private createTDDToolRecommendations;
    private createTDDQualityChecks;
    private validateTDDCompatibility;
    private validateTechnicalFeasibility;
    private isPatternRelevantToPhase;
    private generatePreparationSteps;
    private generateSuccessCriteria;
    private analyzeCurrentCode;
    private discoverRelevantPatterns;
    private selectBestPatternForContext;
    private applyPatternInRealTime;
    private getDocumentationInsights;
    private getSemanticInsights;
    private getLogicalInsights;
    getIntegrationStatistics(): typeof this.integrationStats;
    clearCaches(): Promise<void>;
}
//# sourceMappingURL=pattern-discovery-integration.d.ts.map