/**
 * Enhanced configuration management system for POLARIS
 * Provides better validation, type safety, and default value handling
 */
import { Result } from "./result";
import { ConfigurationError } from "../errors/base";
/**
 * Configuration source types
 */
export declare enum ConfigSource {
    ENVIRONMENT = "environment",
    FILE = "file",
    RUNTIME = "runtime",
    DEFAULT = "default"
}
/**
 * Configuration value with metadata
 */
export interface ConfigValue<T> {
    value: T;
    source: ConfigSource;
    validated: boolean;
    defaultValue?: T;
}
/**
 * Configuration registry for centralized config management
 */
declare class ConfigRegistry {
    private values;
    private logger;
    /**
     * Set a configuration value
     */
    set<T>(key: string, value: T, source?: ConfigSource): void;
    /**
     * Get a configuration value
     */
    get<T>(key: string): ConfigValue<T> | undefined;
    /**
     * Get a configuration value with validation
     */
    getValidated<T>(key: string, validator: (value: any) => Result<T, ConfigurationError>, defaultValue?: T): Result<T, ConfigurationError>;
    /**
     * Check if a key exists
     */
    has(key: string): boolean;
    /**
     * Get all configuration keys
     */
    keys(): string[];
    /**
     * Clear all configuration values
     */
    clear(): void;
    /**
     * Get configuration summary (for debugging)
     */
    getSummary(): Record<string, {
        source: ConfigSource;
        hasValue: boolean;
    }>;
    private sanitizeValue;
}
declare const configRegistry: ConfigRegistry;
/**
 * Enhanced environment configuration with validation
 */
export declare class EnhancedEnvironmentConfig {
    private static logger;
    /**
     * Load configuration from environment variables with validation
     */
    static load(): Result<void, ConfigurationError>;
    /**
     * Get validated API configuration
     */
    static getAPIConfig(provider: string): Result<APIConfig, ConfigurationError>;
    /**
     * Get validated POLARIS configuration
     */
    static getPolarisConfig(): Result<PolarisRuntimeConfig, ConfigurationError>;
    /**
     * Get validated search configuration
     */
    static getSearchConfig(): Result<SearchRuntimeConfig, ConfigurationError>;
    /**
     * Validate all required API keys
     */
    static validateAPIKeys(): Result<APIKeyValidation, ConfigurationError>;
    private static loadAPIConfigs;
    private static loadPolarisConfigs;
    private static loadPerformanceConfigs;
    private static buildAPIConfig;
    private static validateAPIConfig;
    private static validatePolarisConfig;
    private static validateSearchConfig;
    private static getDefaultAPIConfig;
    private static getDefaultPolarisConfig;
    private static getDefaultSearchConfig;
    private static getDefaultBaseURL;
    private static getEnvVar;
    private static getEnvVarAsNumber;
    private static getEnvVarAsBoolean;
}
/**
 * Configuration interfaces
 */
export interface APIConfig {
    apiKey: string;
    baseURL: string;
    timeout: number;
    maxRetries: number;
    retryDelay: number;
}
export interface PolarisRuntimeConfig {
    logLevel: string;
    enableDebug: boolean;
    enableMetrics: boolean;
    maxConcurrentAgents: number;
    defaultTimeout: number;
}
export interface SearchRuntimeConfig {
    simulationsPerNode: number;
    explorationConstant: number;
    maxDepth: number;
    timeLimit?: number;
    progressiveWidening: boolean;
    earlyTermination?: {
        minSimulations: number;
        confidenceThreshold?: number;
        scoreDifference?: number;
    };
}
export interface APIKeyValidation {
    valid: boolean;
    results: Record<string, boolean>;
    missing: string[];
}
/**
 * Configuration builder for programmatic config creation
 */
export declare class ConfigBuilder {
    private config;
    /**
     * Set API configuration
     */
    withAPI(provider: string, config: Partial<APIConfig>): this;
    /**
     * Set POLARIS configuration
     */
    withPolaris(config: Partial<PolarisRuntimeConfig>): this;
    /**
     * Set search configuration
     */
    withSearch(config: Partial<SearchRuntimeConfig>): this;
    /**
     * Build and apply configuration
     */
    build(): Result<void, ConfigurationError>;
    private getDefaultAPIConfig;
    private getDefaultPolarisConfig;
    private getDefaultSearchConfig;
}
/**
 * Create a configuration builder
 */
export declare function createConfigBuilder(): ConfigBuilder;
export { configRegistry };
//# sourceMappingURL=enhanced-config.d.ts.map