/**
 * Base Cross-Domain Expert
 *
 * Abstract base class for cross-domain experts that orchestrate
 * multi-turn dialogues with module experts to find root causes.
 *
 * Key capabilities:
 * 1. Dialogue Loop - Multi-turn questioning of module experts
 * 2. Hypothesis Management - Track and verify root cause hypotheses
 * 3. Early Termination - Stop when confident or request user input
 * 4. Event Emission - Real-time updates for UI
 *
 * Subclasses must implement:
 * - generateInitialQueries(): First questions based on user query
 * - analyzeAndDecide(): Analyze responses and decide next action
 * - synthesizeConclusion(): Build final conclusion from evidence
 */
import { EventEmitter } from 'events';
import { CrossDomainExpertConfig, CrossDomainInput, CrossDomainOutput, ModuleQuery, ModuleResponse, ModuleFinding, ModuleSuggestion, Hypothesis, AnalysisDecision, ExpertConclusion, DialogueContext, AIService } from './types';
import { ModuleExpertInvoker } from './moduleExpertInvoker';
import { DialogueSession } from './dialogueProtocol';
import { HypothesisManager } from './hypothesisManager';
import { ModuleCatalog } from './moduleCatalog';
/**
 * Abstract base class for cross-domain experts
 */
export declare abstract class BaseCrossDomainExpert extends EventEmitter {
    readonly config: CrossDomainExpertConfig;
    protected invoker: ModuleExpertInvoker | null;
    protected catalog: ModuleCatalog;
    protected hypothesisManager: HypothesisManager;
    /** AI service for analysis and synthesis - set during analyze() */
    protected aiService: AIService | null;
    constructor(config: CrossDomainExpertConfig);
    /**
     * Generate initial queries based on user input
     * Called at the start of analysis to determine entry points
     */
    protected abstract generateInitialQueries(input: CrossDomainInput, context: DialogueContext): Promise<ModuleQuery[]>;
    /**
     * Analyze responses and decide next action
     * Called after each round of module responses
     */
    protected abstract analyzeAndDecide(session: DialogueSession, responses: ModuleResponse[]): Promise<AnalysisDecision>;
    /**
     * Synthesize final conclusion from all collected evidence
     * Called when analysis is complete
     */
    protected abstract synthesizeConclusion(session: DialogueSession): Promise<ExpertConclusion>;
    /**
     * Main analysis method - orchestrates the dialogue loop
     */
    analyze(input: CrossDomainInput): Promise<CrossDomainOutput>;
    /**
     * Create a module query
     */
    protected createQuery(targetModule: string, questionId: string, params: Record<string, any>, context: DialogueContext): ModuleQuery;
    /**
     * Create queries from module suggestions
     */
    protected createQueriesFromSuggestions(suggestions: ModuleSuggestion[], context: DialogueContext, maxQueries?: number): ModuleQuery[];
    /**
     * Create a new hypothesis
     */
    protected createHypothesis(title: string, description: string, category: Hypothesis['category'], component: string, initialConfidence?: number): Hypothesis;
    /**
     * Add evidence to a hypothesis
     */
    protected addEvidenceToHypothesis(hypothesis: Hypothesis, finding: ModuleFinding, weight: number): void;
    /**
     * Get all findings from responses
     */
    protected collectFindings(responses: ModuleResponse[]): ModuleFinding[];
    /**
     * Get all suggestions from responses
     */
    protected collectSuggestions(responses: ModuleResponse[]): ModuleSuggestion[];
    /**
     * Check if a module is available
     */
    protected isModuleAvailable(moduleName: string): boolean;
    /**
     * Get related modules for a given module
     */
    protected getRelatedModules(moduleName: string): string[];
    /**
     * Update hypotheses based on new responses
     */
    private updateHypotheses;
    /**
     * Calculate how relevant a finding is to a hypothesis
     * Returns -1 to 1 (negative = contradicts, positive = supports)
     */
    private calculateFindingRelevance;
    /**
     * Build final output
     */
    private buildOutput;
    /**
     * Create failure output
     */
    private createFailureOutput;
    /**
     * Emit event - sends to both 'expert_event' and 'event' channels
     * The 'event' channel is used by masterOrchestrator for SSE streaming
     */
    private emitEvent;
    /**
     * Log message
     */
    protected log(message: string): void;
}
//# sourceMappingURL=baseCrossDomainExpert.d.ts.map