/**
 * Multi-agent collaboration patterns
 * @module core/collaboration
 */
import type { BaseAgent } from './agent';
import type { Message } from './types';
export interface DebateArgument {
    agent: string;
    round: number;
    argument: string;
}
export interface DebateResult {
    topic: string;
    rounds: DebateArgument[];
    summary: string;
    judge?: string;
}
export interface VoteEntry {
    agent: string;
    choice: string;
    confidence: number;
}
export interface VoteResult {
    question: string;
    votes: VoteEntry[];
    winner: string;
    tally: Record<string, number>;
}
export interface PipelineStageResult {
    agent: string;
    input: string;
    output: string;
    durationMs: number;
}
export interface PipelineResult {
    stages: PipelineStageResult[];
    finalOutput: string;
    totalDurationMs: number;
}
export interface WorkerResult {
    agent: string;
    subtask: string;
    result: string;
}
export interface HierarchyResult {
    task: string;
    subtasks: WorkerResult[];
    synthesis: string;
}
export declare class DebatePattern {
    private agents;
    private rounds;
    constructor(agents: BaseAgent[], rounds?: number);
    debate(topic: string, judgeAgent?: BaseAgent): Promise<DebateResult>;
}
export declare class VotingPattern {
    private agents;
    constructor(agents: BaseAgent[]);
    vote(question: string, options: string[]): Promise<VoteResult>;
    weightedVote(question: string, options: string[]): Promise<VoteResult>;
    private tallyVotes;
}
export declare class PipelinePattern {
    private stages;
    constructor(stages: {
        agent: BaseAgent;
        transform?: (input: string) => string;
    }[]);
    process(input: string): Promise<PipelineResult>;
}
export declare class HierarchyPattern {
    private leader;
    private workers;
    constructor(leader: BaseAgent, workers: BaseAgent[]);
    execute(task: string): Promise<HierarchyResult>;
}
export declare class SharedContext {
    private store;
    private listeners;
    set(key: string, value: any): void;
    get<T>(key: string): T | undefined;
    getAll(): Record<string, any>;
    onChange(key: string, callback: (value: any) => void): void;
}
export declare class ConversationProtocol {
    roundRobin(agents: BaseAgent[], topic: string, rounds: number): Promise<Message[]>;
    moderated(agents: BaseAgent[], moderator: BaseAgent, topic: string): Promise<Message[]>;
}
//# sourceMappingURL=collaboration.d.ts.map