import type { z } from "zod";
import type { L0Result } from "./l0";
import type { StructuredResult } from "./structured";
export interface ConsensusOptions<T extends z.ZodTypeAny = z.ZodTypeAny> {
    streams: Array<() => Promise<any> | any>;
    schema?: T;
    strategy?: ConsensusStrategy;
    threshold?: number;
    resolveConflicts?: ConflictResolution;
    weights?: number[];
    minimumAgreement?: number;
    timeout?: number;
    signal?: AbortSignal;
    detectZeroTokens?: boolean;
    monitoring?: {
        enabled?: boolean;
        metadata?: Record<string, any>;
    };
    onComplete?: (outputs: ConsensusOutput[]) => void | Promise<void>;
    onConsensus?: (result: ConsensusResult<any>) => void | Promise<void>;
    metadata?: Record<string, any>;
}
export type ConsensusStrategy = "majority" | "unanimous" | "weighted" | "best";
export type ConflictResolution = "vote" | "merge" | "fail" | "best";
export interface ConsensusResult<T = any> {
    consensus: T;
    confidence: number;
    outputs: ConsensusOutput[];
    agreements: Agreement[];
    disagreements: Disagreement[];
    analysis: ConsensusAnalysis;
    type: "text" | "structured";
    fieldConsensus?: FieldConsensus;
    status: "success" | "partial" | "failed";
    error?: Error;
    metadata?: Record<string, any>;
}
export interface ConsensusOutput {
    index: number;
    text: string;
    data?: any;
    l0Result?: L0Result;
    structuredResult?: StructuredResult<any>;
    status: "success" | "error";
    error?: Error;
    duration: number;
    weight: number;
    similarities?: number[];
}
export interface Agreement {
    content: string | any;
    path?: string;
    count: number;
    ratio: number;
    indices: number[];
    type: AgreementType;
}
export type AgreementType = "exact" | "similar" | "structural" | "semantic";
export interface Disagreement {
    path?: string;
    values: Array<{
        value: any;
        count: number;
        indices: number[];
    }>;
    severity: DisagreementSeverity;
    resolution?: string;
    resolutionConfidence?: number;
}
export type DisagreementSeverity = "minor" | "moderate" | "major" | "critical";
export interface ConsensusAnalysis {
    totalOutputs: number;
    successfulOutputs: number;
    failedOutputs: number;
    identicalOutputs: number;
    similarityMatrix: number[][];
    averageSimilarity: number;
    minSimilarity: number;
    maxSimilarity: number;
    totalAgreements: number;
    totalDisagreements: number;
    strategy: ConsensusStrategy;
    conflictResolution: ConflictResolution;
    duration: number;
}
export interface FieldConsensus {
    fields: Record<string, FieldAgreement>;
    overallAgreement: number;
    agreedFields: string[];
    disagreedFields: string[];
}
export interface FieldAgreement {
    path: string;
    value: any;
    agreement: number;
    votes: Record<string, number>;
    values: any[];
    unanimous: boolean;
    confidence: number;
}
export interface TextConsensusOptions {
    threshold: number;
    strategy: ConsensusStrategy;
    resolveConflicts: ConflictResolution;
    weights: number[];
}
export interface StructuredConsensusOptions {
    schema: z.ZodTypeAny;
    strategy: ConsensusStrategy;
    resolveConflicts: ConflictResolution;
    weights: number[];
    minimumAgreement: number;
}
export interface ConsensusPreset {
    name: string;
    strategy: ConsensusStrategy;
    threshold: number;
    resolveConflicts: ConflictResolution;
    minimumAgreement: number;
}
export declare const strictConsensus: Partial<ConsensusOptions>;
export declare const standardConsensus: Partial<ConsensusOptions>;
export declare const lenientConsensus: Partial<ConsensusOptions>;
export declare const bestConsensus: Partial<ConsensusOptions>;
//# sourceMappingURL=consensus.d.ts.map