import type { Capabilities, ProviderError, Request, StreamEvent } from '@wrongstack/core/types';
import { type HeadersLike } from './error-parse.js';
import type { GoogleStreamState } from './presets/google.js';
import type { WireAdapterStreamOptions } from './wire-adapter.js';
import { WireFormatProvider } from './wire-format.js';
export interface GoogleProviderOptions {
    apiKey: string;
    baseUrl?: string | undefined;
    fetchImpl?: typeof fetch | undefined;
    id?: string | undefined;
    capabilities?: Partial<Capabilities> | undefined;
    /** Raw stream debugging and hang-detection options. */
    streamOpts?: WireAdapterStreamOptions | undefined;
    /**
     * Maximum number of tool definitions the provider accepts per request.
     * When set, lower-priority tools are filtered out centrally by
     * `WireAdapter.stream()` before the request body is built.
     */
    maxTools?: number | undefined;
}
export declare class GoogleProvider extends WireFormatProvider<GoogleStreamState> {
    readonly id: string;
    readonly capabilities: Capabilities;
    constructor(opts: GoogleProviderOptions);
    protected translateError(status: number, text: string, headers?: HeadersLike): ProviderError;
    /**
     * Prefix-hash → live cached-content resource. Entries carry a client-side
     * expiry a minute before the server TTL, so a just-expired name is never
     * reused; Gemini deletes the resource server-side when its TTL lapses, so no
     * explicit dispose is needed (which is why this works despite the provider
     * being rebuilt on every model switch).
     */
    private readonly explicitCache;
    stream(req: Request, opts: {
        signal: AbortSignal;
    }): AsyncIterable<StreamEvent>;
    private resolveCachedContent;
}
//# sourceMappingURL=google.d.ts.map