import { EventEmitter } from 'events';
import { ProjectContext, ToolOrchestrationRequest, OrchestrationResult, AIToolType, ToolExecutionContext } from '../types';
export type ProjectDomain = 'web_frontend' | 'web_backend' | 'fullstack_web' | 'mobile_native' | 'mobile_cross_platform' | 'data_science' | 'machine_learning' | 'desktop_application' | 'embedded_systems' | 'devops_infrastructure' | 'game_development' | 'blockchain' | 'api_microservices' | 'cli_tools' | 'library_framework' | 'unknown';
export interface ProjectCharacteristics {
    domain: ProjectDomain;
    confidence: number;
    frameworks: string[];
    languages: string[];
    dependencies: string[];
    architecturalPatterns: string[];
    complexity: 'simple' | 'moderate' | 'complex' | 'enterprise';
    teamSize: 'solo' | 'small' | 'medium' | 'large';
    developmentStage: 'prototype' | 'development' | 'production' | 'maintenance';
    performanceRequirements: 'low' | 'medium' | 'high' | 'critical';
    securityRequirements: 'low' | 'medium' | 'high' | 'critical';
    scalabilityRequirements: 'low' | 'medium' | 'high' | 'critical';
}
export interface DomainOrchestrationStrategy {
    domain: ProjectDomain;
    name: string;
    description: string;
    preferredTools: AIToolType[];
    toolPriorities: Record<AIToolType, number>;
    workflowPatterns: DomainWorkflowPattern[];
    triggerMappings: Record<string, DomainTriggerMapping>;
    optimizationGoals: DomainOptimizationGoal[];
    conflictResolutionRules: DomainConflictRule[];
    performanceExpectations: PerformanceExpectations;
}
export interface DomainWorkflowPattern {
    name: string;
    trigger: string;
    description: string;
    toolSequence: DomainToolStep[];
    parallelizable: boolean;
    estimatedDuration: number;
    successCriteria: string[];
    fallbackStrategies: string[];
}
export interface DomainToolStep {
    toolType: AIToolType;
    capability: string;
    inputPreparation: (context: ToolExecutionContext) => Record<string, any>;
    outputProcessing: (output: any) => any;
    dependencies: string[];
    optional: boolean;
    timeout: number;
}
export interface DomainTriggerMapping {
    originalTrigger: string;
    domainSpecificTrigger: string;
    toolSelectionStrategy: string;
    contextEnhancement: Record<string, any>;
    priorityAdjustment: number;
}
export interface DomainOptimizationGoal {
    name: string;
    description: string;
    metric: string;
    target: number;
    weight: number;
    measurementStrategy: string;
}
export interface DomainConflictRule {
    id: string;
    domain: ProjectDomain;
    conflictType: string;
    participants: AIToolType[];
    resolutionStrategy: string;
    domainKnowledge: Record<string, any>;
    priority: number;
}
export interface PerformanceExpectations {
    responseTime: {
        target: number;
        max: number;
    };
    accuracy: {
        target: number;
        min: number;
    };
    resourceUsage: {
        memory: number;
        cpu: number;
    };
    cacheEfficiency: {
        target: number;
        min: number;
    };
}
export interface PredictiveContext {
    recentActions: string[];
    currentFocus: string;
    timeOfDay: string;
    dayOfWeek: string;
    sessionDuration: number;
    previousSuccessfulPatterns: string[];
    developerPreferences: Record<string, any>;
    projectHistory: string[];
}
export interface PredictionResult {
    predictedTools: AIToolType[];
    confidence: number;
    reasoning: string;
    suggestedPreparation: Record<string, any>;
    alternativeScenarios: AlternativeScenario[];
}
export interface AlternativeScenario {
    scenario: string;
    probability: number;
    tools: AIToolType[];
    reasoning: string;
}
export interface ConflictResolutionContext {
    conflictType: string;
    participants: AIToolType[];
    domainContext: ProjectCharacteristics;
    historicalResolutions: ConflictResolutionHistory[];
    currentPriorities: Record<string, number>;
    userPreferences: Record<string, any>;
}
export interface ConflictResolutionHistory {
    conflictType: string;
    participants: AIToolType[];
    resolutionStrategy: string;
    outcome: 'successful' | 'failed' | 'partial';
    userSatisfaction: number;
    timestamp: Date;
    context: Record<string, any>;
}
export interface SemanticInformation {
    type: 'documentation' | 'pattern' | 'analysis' | 'reasoning';
    content: any;
    metadata: {
        source: AIToolType;
        timestamp: Date;
        confidence: number;
        relevance: number;
        freshness: number;
    };
    relationships: SemanticRelationship[];
    applicability: {
        domains: ProjectDomain[];
        contexts: string[];
        limitations: string[];
    };
}
export interface SemanticRelationship {
    type: 'supports' | 'contradicts' | 'enhances' | 'requires' | 'alternative_to';
    target: string;
    strength: number;
    description: string;
}
export declare class DomainSpecificOrchestrationService extends EventEmitter {
    private readonly logger;
    private domainStrategies;
    private projectCharacteristics;
    private semanticInformationStore;
    private conflictResolutionHistory;
    private usagePatterns;
    private predictionModels;
    private adaptationRules;
    private performanceBaseline;
    private baseOrchestrator;
    constructor(baseOrchestrator: any);
    analyzeProject(projectContext: ProjectContext): Promise<ProjectCharacteristics>;
    private detectProjectDomain;
    private gatherDomainIndicators;
    private extractFileTypes;
    private extractDirectories;
    private extractFileNames;
    private analyzeProjectComplexity;
    private calculateDirectoryDepth;
    private detectComplexArchitecturalPatterns;
    private analyzeProjectRequirements;
    private analyzeArchitecturalPatterns;
    private extractFrameworks;
    private extractLanguages;
    private inferTeamSize;
    private inferDevelopmentStage;
    orchestrateForDomain(request: ToolOrchestrationRequest, projectCharacteristics?: ProjectCharacteristics): Promise<OrchestrationResult>;
    private getDomainStrategy;
    private enhanceRequestForDomain;
    predictOptimalTools(request: ToolOrchestrationRequest, predictiveContext: PredictiveContext): Promise<PredictionResult>;
    private buildPredictiveContext;
    private analyzeCurrentContext;
    private applyPredictionModels;
    private generateAlternativeScenarios;
    private assessObjectiveComplexity;
    resolveAdvancedConflict(context: ConflictResolutionContext): Promise<any>;
    private getDomainConflictRules;
    private analyzeHistoricalResolutions;
    private generateMLBasedResolution;
    private combineResolutionStrategies;
    private getStrategyType;
    private recordConflictResolution;
    storeSemanticInformation(result: OrchestrationResult, characteristics: ProjectCharacteristics): Promise<void>;
    getRelevantSemanticInformation(domain: ProjectDomain, context: string): Promise<SemanticInformation[]>;
    private calculateSemanticRelevance;
    private learnFromExecution;
    private adaptDomainStrategy;
    private adjustPriority;
    private adjustCriticality;
    private enhanceExpectedOutput;
    private integratePredicitionWithStrategy;
    private executeEnhancedOrchestration;
    private setupEventHandlers;
    private handleProjectAnalyzed;
    private handleStrategyAdapted;
    private initializeDomainStrategies;
    private initializeAdditionalDomainStrategies;
    getDomainCharacteristics(): Promise<ProjectCharacteristics | null>;
    getAvailableDomains(): Promise<ProjectDomain[]>;
    getStrategyForDomain(domain: ProjectDomain): Promise<DomainOrchestrationStrategy | null>;
    getUsageStatistics(): Promise<Record<string, any>>;
    getSemanticInformationSummary(): Promise<{
        totalEntries: number;
        byDomain: Record<ProjectDomain, number>;
        averageRelevance: number;
    }>;
}
//# sourceMappingURL=domain-specific-orchestration.d.ts.map