/**
 * Provider Registry
 *
 * Manages provider instances, allowing custom provider registration
 * and sharing providers across models.
 */
import { ILLMProvider, ProviderConfig, ILogger } from '../types';
/**
 * Factory function type for creating providers
 */
export type ProviderFactory = (config: ProviderConfig, logger?: ILogger) => ILLMProvider;
/**
 * Provider Registry
 *
 * Manages provider instances with support for:
 * - Built-in providers (OpenAI, Friendli)
 * - Custom provider factories
 * - Named provider instances for sharing across models
 */
export declare class ProviderRegistry {
    private providers;
    private factories;
    private logger?;
    constructor(logger?: ILogger);
    /**
     * Register a custom provider factory
     *
     * @example
     * ```typescript
     * registry.registerFactory('anthropic', (config, logger) => new AnthropicProvider(config, logger));
     * ```
     */
    registerFactory(type: string, factory: ProviderFactory): void;
    /**
     * Register a named provider instance
     *
     * @example
     * ```typescript
     * registry.register('openai-primary', new OpenAIProvider({ apiKey: '...' }));
     * registry.register('openai-backup', new OpenAIProvider({ apiKey: '...' }));
     * ```
     */
    register(name: string, provider: ILLMProvider, config?: ProviderConfig): void;
    /**
     * Create and register a provider by type
     *
     * @example
     * ```typescript
     * registry.create('my-openai', 'openai', { apiKey: '...', baseUrl: '...' });
     * ```
     */
    create(name: string, type: string, config: ProviderConfig): ILLMProvider;
    /**
     * Get a registered provider by name
     */
    get(name: string): ILLMProvider | undefined;
    /**
     * Get a provider or throw if not found
     */
    getOrThrow(name: string): ILLMProvider;
    /**
     * Get or create a provider
     * Creates with given config if not exists
     */
    getOrCreate(name: string, type: string, config: ProviderConfig): ILLMProvider;
    /**
     * Check if a provider is registered
     */
    has(name: string): boolean;
    /**
     * Check if a factory is registered
     */
    hasFactory(type: string): boolean;
    /**
     * Unregister a provider
     */
    unregister(name: string): boolean;
    /**
     * List all registered provider names
     */
    listProviders(): string[];
    /**
     * List all registered factory types
     */
    listFactories(): string[];
    /**
     * Clear all registered providers (but keep factories)
     */
    clear(): void;
    /**
     * Run health checks on all registered providers
     * Returns a map of provider name -> health status
     */
    healthCheckAll(): Promise<Map<string, boolean>>;
}
/**
 * Get the default provider registry singleton
 */
export declare function getProviderRegistry(): ProviderRegistry;
/**
 * Reset the default registry (useful for testing)
 */
export declare function resetProviderRegistry(): void;
//# sourceMappingURL=provider-registry.d.ts.map