import type { ProvidersConfig } from '../types/config.js';
import type { ProviderCallContext } from '../types/lifecycle.js';
import type { CompletionRequest } from '../types/messages.js';
import type { NexusResponse, NexusStream } from '../types/response.js';
import { BaseProvider, type ProviderInfo } from './base.js';
/**
 * A provider whose adapter module loads on its first call.
 *
 * The client registers one of these for every provider in its config, so importing the client
 * costs nothing for adapters a deployment never calls. `info` is known up front, which is all
 * routing reads before the first call.
 */
export declare class LazyProvider extends BaseProvider {
    private readonly load;
    /** The provider's name and locality, known before the adapter loads. */
    readonly info: ProviderInfo;
    private loading?;
    constructor(info: ProviderInfo, load: () => Promise<BaseProvider>);
    /** The adapter, loaded and constructed once. A failed load is retried on the next call. */
    provider(): Promise<BaseProvider>;
    /** Runs one completion on the loaded adapter. */
    complete(request: CompletionRequest, context?: ProviderCallContext): Promise<NexusResponse>;
    /** Streams one completion, loading the adapter when the stream is first read. */
    stream(request: CompletionRequest, context?: ProviderCallContext): NexusStream;
    /** The loaded adapter's health check. */
    healthCheck(): Promise<boolean>;
}
/**
 * One lazily loaded provider for every provider a config names, keyed as the client registers them.
 * Each loader imports only its own adapter module.
 */
export declare function configuredProviders(providers: ProvidersConfig): Array<[string, BaseProvider]>;