/**
 * Parallel Model Executor
 *
 * Executes prompts across multiple models in parallel and aggregates results.
 * Implements various strategies including ensemble, debate, and routing.
 *
 * Based on research:
 * - Mixture of Experts (Shazeer et al., 2017)
 * - Self-consistency (Wang et al., 2022)
 * - LLM Debates (Du et al., 2023)
 */
import { EventEmitter } from "events";
import { ModelConfig, ParallelConfig, ParallelExecutionResult, ExecutionStrategy, RoutingRule } from "./types.js";
/**
 * Parallel Model Executor
 */
export declare class ParallelExecutor extends EventEmitter {
    private config;
    private clients;
    private cache;
    private routingRules;
    private modelStats;
    constructor(config?: Partial<ParallelConfig>);
    /**
     * Initialize clients for each model
     */
    private initializeClients;
    /**
     * Execute a prompt across models based on strategy
     */
    execute(prompt: string, systemPrompt?: string, strategy?: ExecutionStrategy): Promise<ParallelExecutionResult>;
    /**
     * Execute all models in parallel
     */
    private executeAll;
    /**
     * Execute and return fastest response
     */
    private executeFastest;
    /**
     * Execute models in cascade (try each until success)
     */
    private executeCascade;
    /**
     * Route to best model for the task
     */
    private executeRouted;
    /**
     * Execute with consensus requirement
     */
    private executeConsensus;
    /**
     * Execute debate between models
     */
    private executeDebate;
    /**
     * Execute ensemble aggregation
     */
    private executeEnsemble;
    /**
     * Execute a single model
     */
    private executeModel;
    /**
     * Run a debate round
     */
    private runDebateRound;
    /**
     * Synthesize multiple responses into one
     */
    private synthesizeResponses;
    /**
     * Check consensus among responses
     */
    private checkConsensus;
    /**
     * Select best response based on confidence and quality
     */
    private selectBestResponse;
    /**
     * Aggregate responses using specified method
     */
    private aggregateResponses;
    /**
     * Analyze task for routing
     */
    private analyzeTask;
    /**
     * Route task to best model
     */
    private routeTask;
    /**
     * Calculate simple text similarity
     */
    private calculateSimilarity;
    /**
     * Estimate confidence from response
     */
    private estimateConfidence;
    /**
     * Update model statistics
     */
    private updateModelStats;
    /**
     * Add a model
     */
    addModel(model: ModelConfig): void;
    /**
     * Remove a model
     */
    removeModel(modelId: string): void;
    /**
     * Add a routing rule
     */
    addRoutingRule(rule: RoutingRule): void;
    /**
     * Get statistics
     */
    getStatistics(): Map<string, {
        successes: number;
        failures: number;
        avgLatency: number;
    }>;
    /**
     * Clear cache
     */
    clearCache(): void;
    /**
     * Get/set config
     */
    getConfig(): ParallelConfig;
    updateConfig(config: Partial<ParallelConfig>): void;
    /**
     * Format result for display
     */
    formatResult(result: ParallelExecutionResult): string;
}
/**
 * Create a parallel executor
 */
export declare function createParallelExecutor(config?: Partial<ParallelConfig>): ParallelExecutor;
export declare function getParallelExecutor(): ParallelExecutor;
export declare function resetParallelExecutor(): void;
