/**
 * Consensus Engine - Shadow Consensus v3.0
 *
 * Orchestrates multi-model debates to achieve mathematical consensus
 * and eliminate hallucinations. Forces disparate AI models to debate
 * internally until agreement is reached.
 *
 * Features:
 * - Multi-model parallel routing
 * - Structured debate rounds
 * - Multiple consensus algorithms
 * - Convergence detection
 */
import { EventEmitter } from 'events';
export interface ConsensusRequest {
    id: string;
    taskType: string;
    context: string;
    prompt: string;
    minAgreement?: number;
    maxRounds?: number;
    timeout?: number;
}
export interface ModelResponse {
    modelId: string;
    response: string;
    confidence: number;
    reasoning: string;
    timestamp: number;
}
export interface DebateRound {
    roundNumber: number;
    responses: ModelResponse[];
    agreement: number;
    converged: boolean;
    timestamp: number;
}
export interface ConsensusResult {
    requestId: string;
    finalResponse: string;
    confidence: number;
    agreement: number;
    rounds: DebateRound[];
    totalTime: number;
    modelsUsed: string[];
    algorithm: string;
    success: boolean;
}
export interface ConsensusEngineConfig {
    minModels?: number;
    maxModels?: number;
    defaultAlgorithm?: 'majority' | 'weighted' | 'iterative' | 'proof';
    minAgreement?: number;
    maxRounds?: number;
    timeout?: number;
}
export interface ConsensusMetrics {
    totalRequests: number;
    successfulConsensus: number;
    failedConsensus: number;
    successRate: number;
    averageRounds: number;
    averageAgreement: number;
    averageTime: number;
    hallucinationReduction: number;
}
export declare class ConsensusEngine extends EventEmitter {
    private config;
    private activeRequests;
    private metrics;
    private roundTimes;
    private agreementScores;
    constructor(config?: ConsensusEngineConfig);
    /**
     * Request consensus from multiple models
     */
    requestConsensus(request: ConsensusRequest, modelPool: any): Promise<ConsensusResult>;
    /**
     * Execute a single debate round
     */
    private executeRound;
    /**
     * Build prompts for each model in a round
     */
    private buildRoundPrompts;
    /**
     * Calculate agreement score between responses
     */
    private calculateAgreement;
    /**
     * Weighted consensus algorithm
     */
    private weightedConsensus;
    /**
     * Calculate text similarity using word overlap
     */
    private calculateTextSimilarity;
    /**
     * Extract consensus response from a round
     */
    private extractConsensusResponse;
    /**
     * Calculate average confidence from a round
     */
    private calculateAverageConfidence;
    /**
     * Update metrics
     */
    private updateMetrics;
    /**
     * Get current metrics
     */
    getMetrics(): ConsensusMetrics;
    /**
     * Get active requests
     */
    getActiveRequests(): ConsensusRequest[];
}
//# sourceMappingURL=ConsensusEngine.d.ts.map