import type { JudgeLLM } from './adapters';
type AnthropicClient = {
    messages: {
        create(params: {
            model: string;
            temperature: number;
            max_tokens: number;
            system: string;
            messages: Array<{
                role: 'user' | 'assistant';
                content: string;
            }>;
        }): Promise<{
            content: Array<{
                type: string;
                text?: string;
            }>;
            usage: {
                input_tokens: number;
                output_tokens: number;
            };
        }>;
    };
};
export declare function anthropicJudge(client: AnthropicClient): JudgeLLM;
type OpenAIClient = {
    chat: {
        completions: {
            create(params: {
                model: string;
                temperature: number;
                max_tokens: number;
                messages: Array<{
                    role: 'system' | 'user' | 'assistant';
                    content: string;
                }>;
            }): Promise<{
                choices: Array<{
                    message: {
                        content: string | null;
                    };
                }>;
                usage?: {
                    prompt_tokens: number;
                    completion_tokens: number;
                };
            }>;
        };
    };
};
export declare function openaiJudge(client: OpenAIClient): JudgeLLM;
type GeminiModel = {
    generateContent(req: {
        contents: Array<{
            role: string;
            parts: Array<{
                text: string;
            }>;
        }>;
        generationConfig?: {
            temperature?: number;
            maxOutputTokens?: number;
        };
        systemInstruction?: {
            parts: Array<{
                text: string;
            }>;
        };
    }): Promise<{
        response: {
            text(): string;
            usageMetadata?: {
                promptTokenCount?: number;
                candidatesTokenCount?: number;
            };
        };
    }>;
};
export declare function geminiJudge(model: GeminiModel): JudgeLLM;
type ChatCompletionsFetch = (request: {
    model: string;
    temperature: number;
    max_tokens: number;
    messages: Array<{
        role: string;
        content: string;
    }>;
}) => Promise<{
    text: string;
    inputTokens?: number;
    outputTokens?: number;
}>;
export declare function genericChatJudge(call: ChatCompletionsFetch): JudgeLLM;
export {};