/**
 * Automatic Downsampling and Retention Manager
 *
 * Manages the lifecycle of time series data through automatic downsampling
 * and retention policies to optimize storage and query performance.
 *
 * Features:
 * - Configurable downsampling rules per metric
 * - Multiple aggregation functions (avg, max, min, p95, etc.)
 * - Automatic retention policy enforcement
 * - Background processing with minimal impact
 * - Configurable processing schedules
 */
import type { TimeSeriesSchema, AggregationFunction, TimeRange } from '../../../types/timeseries';
import type { TimeSeriesStorageAdapter } from '../interfaces';
export interface DownsamplingConfig {
    enabled: boolean;
    processingIntervalMs: number;
    maxConcurrentJobs: number;
    batchSize: number;
    defaultRetentionDays: number;
}
export interface RetentionPolicy {
    metric: string;
    rules: Array<{
        interval: string;
        retention: string;
        aggregations: AggregationFunction[];
    }>;
    enabled: boolean;
    lastProcessed?: number;
}
export declare class DownsamplingManager {
    private config;
    private storageAdapter;
    private retentionPolicies;
    private processingQueue;
    private isProcessing;
    private processingTimer;
    constructor(config: DownsamplingConfig, storageAdapter: TimeSeriesStorageAdapter);
    addRetentionPolicy(policy: RetentionPolicy): Promise<void>;
    updateRetentionPolicy(metric: string, policy: Partial<RetentionPolicy>): Promise<void>;
    removeRetentionPolicy(metric: string): Promise<void>;
    getRetentionPolicy(metric: string): Promise<RetentionPolicy | null>;
    listRetentionPolicies(): Promise<RetentionPolicy[]>;
    createDefaultPolicy(schema: TimeSeriesSchema): Promise<RetentionPolicy>;
    processDownsampling(metric?: string): Promise<void>;
    forceDownsampling(metric: string, timeRange?: TimeRange): Promise<void>;
    getDownsamplingStats(): Promise<DownsamplingStats>;
    private startProcessing;
    private processQueue;
    private processJob;
    private processMetricDownsampling;
    private processDownsamplingChunk;
    private generateTimeBuckets;
    private generateDownsampledPoints;
    private groupPointsByTags;
    private generateTagsKey;
    private calculateAggregation;
    private calculatePercentile;
    private storeDownsampledData;
    private isBucketProcessed;
    private markBucketProcessed;
    private scheduleDownsampling;
    private cleanupOldData;
    private parseInterval;
    private parseRelativeTime;
    private getDefaultDownsamplingRules;
    private generateJobId;
    close(): Promise<void>;
}
export interface DownsamplingStats {
    totalPolicies: number;
    enabledPolicies: number;
    queueSize: number;
    processingJobs: number;
    totalPointsProcessed: number;
    totalPointsGenerated: number;
    avgCompressionRatio: number;
    isProcessing: boolean;
    lastProcessingTime: number;
}
//# sourceMappingURL=downsampling-manager.d.ts.map