/**
 * Base provider entry for tracking provider state
 */
export interface IBaseProviderEntry<TProvider> {
    provider: TProvider;
    config: IBaseProviderConfig;
    lastError?: Error;
    lastErrorTime?: Date;
    successCount: number;
    errorCount: number;
}
/**
 * Base provider configuration
 */
export interface IBaseProviderConfig {
    enabled: boolean;
    priority: number;
    timeout?: number;
    retryAttempts?: number;
    retryDelay?: number;
    cacheTTL?: number;
}
/**
 * Base provider interface
 */
export interface IBaseProvider {
    name: string;
    priority: number;
    isAvailable(): Promise<boolean>;
    readonly requiresAuth: boolean;
    readonly rateLimit?: {
        requestsPerMinute: number;
        requestsPerDay?: number;
    };
}
/**
 * Cache entry for any data type
 */
export interface IBaseCacheEntry<TData> {
    data: TData;
    timestamp: Date;
    ttl: number;
}
/**
 * Base service for managing data providers with caching
 * Shared logic extracted from StockPriceService and FundamentalsService
 */
export declare abstract class BaseProviderService<TProvider extends IBaseProvider, TData> {
    protected providers: Map<string, IBaseProviderEntry<TProvider>>;
    protected cache: Map<string, IBaseCacheEntry<TData>>;
    protected logger: Console;
    protected cacheConfig: {
        ttl: number;
        maxEntries: number;
    };
    constructor(cacheConfig?: {
        ttl?: number;
        maxEntries?: number;
    });
    /**
     * Register a provider
     */
    register(provider: TProvider, config?: Partial<IBaseProviderConfig>): void;
    /**
     * Unregister a provider
     */
    unregister(providerName: string): void;
    /**
     * Get a specific provider by name
     */
    getProvider(name: string): TProvider | undefined;
    /**
     * Get all registered providers
     */
    getAllProviders(): TProvider[];
    /**
     * Get enabled providers sorted by priority
     */
    getEnabledProviders(): TProvider[];
    /**
     * Check health of all providers
     */
    checkProvidersHealth(): Promise<Map<string, boolean>>;
    /**
     * Get provider statistics
     */
    getProviderStats(): Map<string, {
        successCount: number;
        errorCount: number;
        lastError?: string;
        lastErrorTime?: Date;
    }>;
    /**
     * Clear all cached data
     */
    clearCache(): void;
    /**
     * Set cache TTL
     */
    setCacheTTL(ttl: number): void;
    /**
     * Get cache statistics
     */
    getCacheStats(): {
        size: number;
        maxEntries: number;
        ttl: number;
    };
    /**
     * Fetch with retry logic
     */
    protected fetchWithRetry<T>(fetchFn: () => Promise<T>, config: IBaseProviderConfig): Promise<T>;
    /**
     * Get from cache if not expired
     */
    protected getFromCache(key: string): TData | null;
    /**
     * Add to cache with TTL
     */
    protected addToCache(key: string, data: TData, ttl?: number): void;
    /**
     * Track successful fetch for provider
     */
    protected trackSuccess(providerName: string): void;
    /**
     * Track failed fetch for provider
     */
    protected trackError(providerName: string, error: Error): void;
}