/**
 * Provider Loader Factory
 *
 * Generic factory for loading LLM providers from configuration.
 * Reduces duplication by providing a unified approach to provider loading.
 */
import type { LLMProvider, ServiceType } from '../providers/types.js';
import type { Logger } from '../llm_api/types.js';
import { type ParameterMapping } from './config_parser.js';
/**
 * Base configuration that all providers share
 */
export interface BaseProviderConfig {
    api_key: string;
    api_url?: string;
    capabilities?: ServiceType[];
    logger: Logger;
}
/**
 * Provider factory definition
 * Used to register how to load a specific provider type
 */
export interface ProviderFactory<TConfig extends BaseProviderConfig> {
    /** Provider name (lowercase) */
    name: string;
    /** INI section name (e.g., "llm_gemini") */
    config_section: string;
    /** Parameter mappings for text generation config */
    text_param_mappings: ParameterMapping[];
    /** Parameter mappings for image generation config */
    image_param_mappings: ParameterMapping[];
    /**
     * Build provider-specific config from INI section
     *
     * @param section - The parsed INI section
     * @param api_key - The API key loaded from environment
     * @param text_config - Parsed text generation config
     * @param image_config - Parsed image generation config
     * @param capabilities - Parsed capabilities
     * @param logger - Logger instance
     * @returns Provider-specific config object
     */
    build_config(section: Record<string, string>, api_key: string, text_config: unknown, image_config: unknown, capabilities: ServiceType[], logger: Logger): TConfig;
    /**
     * Create provider instance from config
     *
     * @param config - Provider-specific config object
     * @returns Provider instance
     */
    create_provider(config: TConfig): LLMProvider;
}
/**
 * Result of loading a provider
 */
export type ProviderLoadResult = {
    success: true;
    provider: LLMProvider;
} | {
    success: false;
    error: string;
};
/**
 * Register a provider factory
 *
 * @param factory - Provider factory to register
 *
 * @example
 * ```typescript
 * register_provider_factory({
 *   name: 'gemini',
 *   config_section: 'llm_gemini',
 *   text_param_mappings: GEMINI_PARAM_MAPPINGS,
 *   image_param_mappings: GEMINI_PARAM_MAPPINGS,
 *   build_config: (section, api_key, text_config, image_config, capabilities, logger) => ({
 *     api_key,
 *     api_url: section.api_url,
 *     // ... other gemini-specific fields
 *   }),
 *   create_provider: (config) => new GeminiProvider(config),
 * });
 * ```
 */
export declare function register_provider_factory<TConfig extends BaseProviderConfig>(factory: ProviderFactory<TConfig>): void;
/**
 * Get a registered provider factory by name
 *
 * @param name - Provider name (case-insensitive)
 * @returns Provider factory or undefined
 */
export declare function get_provider_factory(name: string): ProviderFactory<BaseProviderConfig> | undefined;
/**
 * Get all registered provider factory names
 *
 * @returns Array of provider names
 */
export declare function get_registered_factory_names(): string[];
/**
 * Load a provider from config using its registered factory
 *
 * @param provider_name - Name of the provider to load
 * @param logger - Logger instance
 * @returns Provider instance or error result
 */
export declare function load_provider_from_config(provider_name: string, logger: Logger): ProviderLoadResult;
/**
 * Load all enabled providers from config
 *
 * @param enabled_llms - List of enabled LLM names
 * @param logger - Logger instance
 * @returns Map of successfully loaded providers
 */
export declare function load_all_providers(enabled_llms: string[], logger: Logger): Map<string, LLMProvider>;
//# sourceMappingURL=provider_loader.d.ts.map