export type Provider = import("../types").Provider;
export type Message = import("../types").Message;
export type ToolDef = import("../types").ToolDef;
export type GenerateResult = import("../types").GenerateResult;
export type FallbackOptions = {
    /**
     * - Return false to stop.
     */
    shouldFallback?: ((error: any, index: number) => boolean) | undefined;
    /**
     * - Callback.
     */
    onFallback?: ((error: any, fromIndex: number, toIndex: number) => void) | undefined;
};
/** @typedef {import('../types').Provider} Provider */
/** @typedef {import('../types').Message} Message */
/** @typedef {import('../types').ToolDef} ToolDef */
/** @typedef {import('../types').GenerateResult} GenerateResult */
/**
 * @typedef {object} FallbackOptions
 * @property {(error: any, index: number) => boolean} [shouldFallback] - Return false to stop.
 * @property {(error: any, fromIndex: number, toIndex: number) => void} [onFallback] - Callback.
 */
/**
 * NOTE: per-call `generate()` options (incl. `thinking`, `toolChoice`) are forwarded UNCHANGED to EVERY provider in the chain. For a
 * mixed-vendor chain (e.g. OpenAI-compat DeepSeek + Anthropic) set `thinking` on each provider's CONSTRUCTOR instead of per-call,
 * or a value shaped for one vendor lands in another's `body.thinking` on fallback.
 * The normalized `thinkingMode: 'on'|'off'` is the exception: reaching every provider is CORRECT for it (each maps it to its own
 * request shape); a provider that cannot honor it (CLIPipe, a measured non-switchable model) throws `ValidationError`, which the chain
 * treats like any failure.
 */
export class FallbackProvider {
    /**
     * Provider that tries multiple providers in order.
     * @param {Provider[]} providers - Ordered list of providers with generate().
     * @param {FallbackOptions} [options={}]
     * @throws {Error} `[FallbackProvider] requires at least one provider` — when providers is empty.
     * @when you want to try several providers in order, failing over to the next when one errors — resilience across tiers or vendors
     * @fails throws if given no providers; returns the first provider's success, else propagates the last provider's error.
     * @example
     *   const provider = new FallbackProvider([primary, backup]);
     */
    constructor(providers: Provider[], options?: FallbackOptions);
    providers: import("../types").Provider[];
    shouldFallback: (error: any, index: number) => boolean;
    onFallback: ((error: any, fromIndex: number, toIndex: number) => void) | null;
    /**
     * Generate using first available provider.
     * @param {Message[]} messages
     * @param {ToolDef[]} [tools=[]]
     * @param {Record<string, any>} [options={}]
     * @returns {Promise<GenerateResult>}
     * @throws {AggregateError} When all providers fail.
     */
    generate(messages: Message[], tools?: ToolDef[], options?: Record<string, any>): Promise<GenerateResult>;
}