/**
 * Módulo orquestador principal del sistema de mercado
 * Coordina todos los módulos para aplicar la lógica de negocio principal
 */
import { MarketConditionResult } from '../conditions';
import { ProcessedRate } from '../processors';
import { TimeInfo } from '../time';
export interface MarketOrchestrationResult {
    finalRate: string;
    marketCondition: MarketConditionResult;
    processedRate: ProcessedRate;
    timeInfo: TimeInfo;
    orchestrationMetadata: {
        executionTime: number;
        cacheHit: boolean;
        fallbackUsed: boolean;
        errors: string[];
        warnings: string[];
    };
}
export interface ExternalRateProviders {
    fetchSeticapSpotRate: () => Promise<number | null>;
    fetchSeticapNextDayRate: () => Promise<number | null>;
    fetchYahooRate: () => Promise<number | null>;
}
export interface OrchestrationConfig {
    enableCaching: boolean;
    enableFallback: boolean;
    maxRetries: number;
    timeoutMs: number;
    enableCleanup: boolean;
    cleanupIntervalMs: number;
}
/**
 * Clase para manejo de errores y advertencias durante la orquestación
 */
export declare class OrchestrationErrorHandler {
    private errors;
    private warnings;
    /**
     * Registra un error
     */
    addError(error: string): void;
    /**
     * Registra una advertencia
     */
    addWarning(warning: string): void;
    /**
     * Obtiene todos los errores
     */
    getErrors(): string[];
    /**
     * Obtiene todas las advertencias
     */
    getWarnings(): string[];
    /**
     * Verifica si hay errores
     */
    hasErrors(): boolean;
    /**
     * Verifica si hay advertencias
     */
    hasWarnings(): boolean;
    /**
     * Limpia errores y advertencias
     */
    clear(): void;
}
/**
 * Clase para obtener tasas de fuentes externas con manejo de errores
 */
export declare class ExternalRateFetcher {
    private providers;
    private config;
    private errorHandler;
    constructor(providers: ExternalRateProviders, config: OrchestrationConfig, errorHandler: OrchestrationErrorHandler);
    /**
     * Obtiene tasa spot de SET ICAP con reintentos
     */
    fetchSeticapSpotWithRetry(): Promise<number | null>;
    /**
     * Obtiene tasa del día siguiente de SET ICAP con reintentos
     */
    fetchSeticapNextDayWithRetry(): Promise<number | null>;
    /**
     * Obtiene tasa de Yahoo con reintentos
     */
    fetchYahooWithRetry(): Promise<number | null>;
    /**
     * Método genérico para obtener tasas con reintentos
     */
    private fetchWithRetry;
    /**
     * Obtiene todas las tasas en paralelo
     */
    fetchAllRates(): Promise<{
        seticapSpot: number | null;
        seticapNextDay: number | null;
        yahoo: number | null;
    }>;
}
/**
 * Clase principal del orquestador de mercado
 */
export declare class MarketOrchestrator {
    private config;
    private cleanupInterval;
    constructor(config?: Partial<OrchestrationConfig>);
    /**
     * Orquesta el proceso completo de obtención y procesamiento de tasas
     */
    orchestrateRateProcessing(providers: ExternalRateProviders, date?: Date): Promise<MarketOrchestrationResult>;
    /**
     * Recuperación de emergencia cuando falla la orquestación principal
     */
    private emergencyRecovery;
    /**
     * Formatea la tasa final como string
     */
    private formatFinalRate;
    /**
     * Inicia el intervalo de limpieza de caché
     */
    private startCleanupInterval;
    /**
     * Detiene el intervalo de limpieza
     */
    stopCleanupInterval(): void;
    /**
     * Obtiene información de debugging completa
     */
    getDebugInfo(providers: ExternalRateProviders, date?: Date): Promise<{
        orchestrationResult: MarketOrchestrationResult;
        systemStatus: {
            cacheStats: any;
            configStatus: OrchestrationConfig;
            systemTime: string;
        };
    }>;
    /**
     * Actualiza la configuración del orquestador
     */
    updateConfig(newConfig: Partial<OrchestrationConfig>): void;
    /**
     * Limpia recursos al destruir el orquestador
     */
    destroy(): void;
}
/**
 * Instancia global del orquestador
 */
export declare const globalMarketOrchestrator: MarketOrchestrator;
/**
 * Función de conveniencia para orquestación rápida
 */
export declare const orchestrateMarketRates: (providers: ExternalRateProviders, date?: Date) => Promise<MarketOrchestrationResult>;
/**
 * Función de conveniencia para obtener solo la tasa final
 */
export declare const getFinalRate: (providers: ExternalRateProviders, date?: Date) => Promise<string>;
/**
 * Función de conveniencia para debugging
 */
export declare const getMarketDebugInfo: (providers: ExternalRateProviders, date?: Date) => Promise<{
    orchestrationResult: MarketOrchestrationResult;
    systemStatus: {
        cacheStats: any;
        configStatus: OrchestrationConfig;
        systemTime: string;
    };
}>;
//# sourceMappingURL=market-orchestrator.d.ts.map