/**
 * Provider Registry - Extensible provider registration system
 *
 * Fixes Issue #1095: Allows users to register custom providers
 * that can be resolved by name via createProvider().
 */
import type { LLMProvider, ProviderConfig } from './types';
/**
 * Provider constructor type
 */
export type ProviderConstructor = new (modelId: string, config?: ProviderConfig) => LLMProvider;
/**
 * Lazy loader function that returns a provider constructor
 * Used for tree-shaking and lazy loading of provider implementations
 */
export type ProviderLoader = () => ProviderConstructor;
/**
 * Options for registering a provider
 */
export interface RegisterOptions {
    /** Allow overwriting an existing registration */
    override?: boolean;
    /** Additional names that resolve to this provider */
    aliases?: string[];
}
/**
 * Provider Registry Interface
 */
export interface IProviderRegistry {
    register(name: string, provider: ProviderConstructor | ProviderLoader, options?: RegisterOptions): void;
    unregister(name: string): boolean;
    has(name: string): boolean;
    list(): string[];
    resolve(name: string, modelId: string, config?: ProviderConfig): LLMProvider;
    get(name: string): ProviderConstructor | ProviderLoader | undefined;
}
/**
 * Provider Registry Implementation
 *
 * Manages registration and resolution of LLM providers by name.
 * Supports lazy loading, aliases, and isolated instances.
 */
export declare class ProviderRegistry implements IProviderRegistry {
    private entries;
    private aliases;
    /**
     * Register a provider by name
     *
     * @param name - Provider name (e.g., 'cloudflare', 'ollama')
     * @param provider - Provider constructor or lazy loader function
     * @param options - Registration options
     * @throws Error if name is already registered (unless override: true)
     */
    register(name: string, provider: ProviderConstructor | ProviderLoader, options?: RegisterOptions): void;
    /**
     * Unregister a provider by name
     *
     * @param name - Provider name to unregister
     * @returns true if provider was unregistered, false if not found
     */
    unregister(name: string): boolean;
    /**
     * Check if a provider is registered
     *
     * @param name - Provider name to check
     * @returns true if provider is registered
     */
    has(name: string): boolean;
    /**
     * List all registered provider names (canonical names only)
     *
     * @returns Array of provider names
     */
    list(): string[];
    /**
     * List all names including aliases
     *
     * @returns Array of all registered names and aliases
     */
    listAll(): string[];
    /**
     * Resolve a provider by name, creating an instance
     *
     * @param name - Provider name
     * @param modelId - Model ID to pass to constructor
     * @param config - Optional provider config
     * @returns Provider instance
     * @throws Error if provider not found
     */
    resolve(name: string, modelId: string, config?: ProviderConfig): LLMProvider;
    /**
     * Get the provider constructor/loader without instantiating
     *
     * @param name - Provider name
     * @returns Provider constructor/loader or undefined
     */
    get(name: string): ProviderConstructor | ProviderLoader | undefined;
    /**
     * Get the resolved constructor for an entry
     */
    private getConstructor;
    /**
     * Determine if a value is a loader function vs a constructor
     * Loaders are arrow functions or regular functions that return a class
     * Constructors have a prototype with constructor
     */
    private isLoaderFunction;
}
/**
 * Get the default global provider registry
 *
 * This is the registry used by createProvider() when no custom registry is specified.
 * Built-in providers (OpenAI, Anthropic, Google) are registered here.
 */
export declare function getDefaultRegistry(): ProviderRegistry;
/**
 * Create a new isolated provider registry
 *
 * Use this when you need a separate registry that doesn't share
 * registrations with the default global registry.
 */
export declare function createProviderRegistry(): ProviderRegistry;
/**
 * Register a provider to the default global registry
 *
 * @example
 * ```typescript
 * import { registerProvider } from 'praisonai';
 * import { CloudflareProvider } from './my-cloudflare-provider';
 *
 * registerProvider('cloudflare', CloudflareProvider);
 *
 * // Now works:
 * const agent = new Agent({ llm: 'cloudflare/workers-ai' });
 * ```
 */
export declare function registerProvider(name: string, provider: ProviderConstructor | ProviderLoader, options?: RegisterOptions): void;
/**
 * Unregister a provider from the default global registry
 */
export declare function unregisterProvider(name: string): boolean;
/**
 * Check if a provider is registered in the default registry
 */
export declare function hasProvider(name: string): boolean;
/**
 * List all providers in the default registry
 */
export declare function listProviders(): string[];
/**
 * Register built-in providers to a registry
 * Uses lazy loaders to avoid importing all providers at module load time
 */
export declare function registerBuiltinProviders(registry: ProviderRegistry): void;
/**
 * Reset the default registry (mainly for testing)
 * @internal
 */
export declare function _resetDefaultRegistry(): void;