import type { LanguageModelV4, LanguageModelV4CallOptions, LanguageModelV4StreamPart } from "@ai-sdk/provider";
import { MockLanguageModelV4 } from "ai/test";
import { type FallbackStreamArgs, type ResolvedEntry } from "../stream.js";
import type { ClassifyFailure, OnRouterAttempt, OnRouterError } from "../types.js";
export declare const usage: {
    inputTokens: {
        total: number;
        noCache: number;
        cacheRead: number;
        cacheWrite: number;
    };
    outputTokens: {
        total: number;
        text: number;
        reasoning: number;
    };
};
export declare const finishReason: {
    unified: "stop";
    raw: string;
};
export declare const callOptions: LanguageModelV4CallOptions;
/** A model whose stream emits exactly the given parts (in-band, closes normally). */
export declare function chunkModel(chunks: LanguageModelV4StreamPart[]): MockLanguageModelV4;
/** A model that creates each part only when the consumer requests it. */
export declare function lazyChunkModel(factories: (() => LanguageModelV4StreamPart)[]): MockLanguageModelV4;
/** A normal text stream emitting `parts` as deltas. */
export declare function textModel(parts: string[]): MockLanguageModelV4;
/** Emits stream-start, then optional text deltas, then an in-band error part. */
export declare function errorPartModel(error: unknown, beforeText?: string[]): MockLanguageModelV4;
/** A model whose stream rejects on the next read after stream-start (transport drop). */
export declare function transportRejectModel(error: unknown): MockLanguageModelV4;
export declare function resolved(model: LanguageModelV4, fullIndex?: number): ResolvedEntry;
export interface DriveResult {
    error: unknown;
    parts: LanguageModelV4StreamPart[];
    text: string;
}
export declare function drive(stream: ReadableStream<LanguageModelV4StreamPart>): Promise<DriveResult>;
export declare function runFallback(models: MockLanguageModelV4[], opts?: {
    abortSignal?: AbortSignal;
    acquireCandidate?: FallbackStreamArgs["acquireCandidate"];
    candidateAvailable?: FallbackStreamArgs["candidateAvailable"];
    candidateInFlight?: FallbackStreamArgs["candidateInFlight"];
    classifyFailure?: ClassifyFailure;
    concurrencyLimit?: FallbackStreamArgs["concurrencyLimit"];
    firstContentTimeout?: FallbackStreamArgs["firstContentTimeout"];
    isBudgetFailure?: FallbackStreamArgs["isBudgetFailure"];
    maxAttempts?: FallbackStreamArgs["maxAttempts"];
    onAttempt?: OnRouterAttempt;
    onRequestOutcome?: FallbackStreamArgs["onRequestOutcome"];
    prepareCandidate?: FallbackStreamArgs["prepareCandidate"];
    retryAfterOutput?: boolean;
    shouldRetry?: (e: unknown) => boolean;
    startAttemptStartedAt?: number;
    onError?: OnRouterError;
    releaseCandidate?: FallbackStreamArgs["releaseCandidate"];
    releaseProbeCandidate?: FallbackStreamArgs["releaseProbeCandidate"];
    strictStreamValidation?: boolean;
    waitForCandidate?: FallbackStreamArgs["waitForCandidate"];
}): Promise<DriveResult>;