import { Table, DataType } from "apache-arrow";
export interface DataRange {
    from: number;
    to: number;
}
export interface DataCacheEntry {
    data: Table<Record<string | number | symbol, DataType>>;
    loadedRanges: DataRange[];
    absoluteBounds?: DataRange;
    fullDataLoaded: boolean;
    timestamp: number;
    size: number;
    accessCount: number;
    lastAccessed: number;
}
export interface DataFetchRequest {
    strategyId: string;
    assetId: string;
    timeframe: string;
    from_ms?: number;
    to_ms?: number;
    pivot?: number;
    pad_front?: number;
    pad_back?: number;
}
export declare class DataCacheManager {
    private cache;
    private readonly maxCacheSize;
    private readonly maxCacheEntries;
    private totalSize;
    /**
     * Generates a cache key for a data request
     * Single cache entry per strategy/asset/timeframe combination
     */
    private getCacheKey;
    /**
     * Merges overlapping or adjacent ranges and sorts them
     */
    private mergeRanges;
    /**
     * Checks if a target range is fully covered by loaded ranges
     */
    private isRangeCovered;
    /**
     * Finds missing ranges that need to be fetched
     */
    private findMissingRanges;
    /**
     * Merges two Arrow tables by combining rows and sorting by index column
     */
    private mergeArrowTables;
    /**
     * Estimates the memory footprint of Apache Arrow table data
     */
    private estimateDataSize;
    /**
     * Evicts least recently used entries to make space
     */
    private evictLRUEntries;
    /**
     * Checks if we can cache a new entry
     */
    private canCacheNewEntry;
    /**
     * Caches data from a successful fetch, merging with existing data if present
     */
    cacheData(request: DataFetchRequest, data: Table<Record<string | number | symbol, DataType>>): void;
    /**
     * Retrieves cached data if available
     * Returns null if no data exists or if entry is just a placeholder
     */
    getCachedData(request: DataFetchRequest): Table<Record<string | number | symbol, DataType>> | null;
    /**
     * Gets the loaded ranges for a cached entry
     */
    getLoadedRanges(request: DataFetchRequest): DataRange[];
    /**
     * Determines if we need to fetch new data for a request
     * Returns true if we have no cached data at all
     */
    needsFetch(request: DataFetchRequest): boolean;
    /**
     * Checks if a target range needs data to be fetched (range expansion)
     * Returns the missing ranges that need to be fetched
     */
    needsRangeExpansion(request: DataFetchRequest, targetRange: DataRange): DataRange[];
    /**
     * Sets the absolute bounds for a cached entry (from backend metadata)
     * Creates a placeholder cache entry if one doesn't exist yet
     */
    setAbsoluteBounds(request: DataFetchRequest, bounds: DataRange): void;
    /**
     * Gets the absolute bounds for a cached entry
     */
    getAbsoluteBounds(request: DataFetchRequest): DataRange | undefined;
    /**
     * Marks a cache entry as having all available data loaded
     * This prevents further backend fetches for this key
     */
    setFullDataLoaded(request: DataFetchRequest): void;
    /**
     * Checks if all available data has been loaded for a cache entry
     */
    isFullDataLoaded(request: DataFetchRequest): boolean;
    /**
     * Gets cache statistics for debugging
     */
    getCacheStats(): {
        totalEntries: number;
        totalSize: number;
        maxSize: number;
        hitRate: number;
    };
    /**
     * Clears all cached data
     */
    clearCache(): void;
    /**
     * Removes cached data for a specific strategy
     */
    clearStrategyCache(strategyId: string): void;
    /**
     * Removes cached data for a specific asset within a strategy
     */
    clearAssetCache(strategyId: string, assetId: string): void;
}
export declare const globalDataCacheManager: DataCacheManager;
//# sourceMappingURL=DataCacheManager.d.ts.map