/**
 * Fake LLMClient for tests.
 *
 * Returns canned responses in insertion order and records each call so
 * consumers' tests can assert on prompts, models, and telemetry context.
 *
 * Exported alongside the real adapters so consuming-feature tests can
 * stub the LLM cleanly without a network round-trip.
 */
import type { LLMClient, LLMCompleteArgs, LLMCompleteStructuredArgs, LLMCompletion, LLMStructuredCompletion } from "../../_vendor/ailf-core/index.d.ts";
export interface FakeCallRecord {
    kind: "complete" | "completeStructured";
    model: string;
    prompt: string;
    context?: {
        feature: string;
        runId?: string;
        cardId?: string;
    };
}
export interface FakeCompletionResponse {
    text: string;
    promptTokens?: number;
    completionTokens?: number;
    cost?: number;
}
export interface FakeStructuredResponse {
    /**
     * Value returned to the consumer. Run through the consumer-supplied Zod
     * schema in `completeStructured` so consumers exercise their parse-don't-
     * validate path even with the fake; supply a value that matches the
     * schema's shape (or supply a deliberately malformed one to test failure).
     */
    value: unknown;
    promptTokens?: number;
    completionTokens?: number;
    cost?: number;
}
export declare class FakeLLMClient implements LLMClient {
    readonly calls: FakeCallRecord[];
    private readonly completeQueue;
    private readonly structuredQueue;
    /**
     * Per-cardId keyed responses. A single-value entry is returned on every
     * call for that cardId (repeated calls always get the same response). An
     * array-value entry is consumed in order; once exhausted, calls for that
     * cardId fall back to the FIFO structuredQueue.
     *
     * This is the substrate Plan 07's 17-fixture eval matrix uses to wire
     * deterministic responses to specific LLM cards.
     */
    private readonly keyedResponses;
    constructor(args?: {
        completeResponses?: FakeCompletionResponse[];
        structuredResponses?: FakeStructuredResponse[];
        /**
         * Optional keyed-response map. Keys are `cardId` values from
         * `args.context.cardId`. When a call matches a key the keyed entry is
         * used instead of the FIFO queue.
         *
         * - Single-value entry: same response on every call for this cardId.
         * - Array-value entry: entries consumed in insertion order; falls back
         *   to FIFO (or throws) when the array is exhausted.
         */
        keyedResponses?: Record<string, FakeStructuredResponse | FakeStructuredResponse[]>;
    });
    complete(args: LLMCompleteArgs): Promise<LLMCompletion>;
    completeStructured<T>(args: LLMCompleteStructuredArgs<T>): Promise<LLMStructuredCompletion<T>>;
}
