import { DataPoint } from './types';

export type OverflowStrategy = 'drop-oldest' | 'drop-newest' | 'pause' | 'sample' | 'block';
export interface BackpressureConfig {
    /** Maximum buffer size before triggering backpressure (default: 10000) */
    maxBuffer: number;
    /** Warning threshold as fraction of maxBuffer (default: 0.7) */
    warningThreshold?: number;
    /** Critical threshold as fraction of maxBuffer (default: 0.9) */
    criticalThreshold?: number;
    /** Overflow handling strategy (default: 'drop-oldest') */
    strategy: OverflowStrategy;
    /** For 'sample' strategy: keep every Nth point (default: 2) */
    sampleRate?: number;
    /** Callback when pressure level changes */
    onPressure?: (stats: PressureStats) => void;
    /** Callback when buffer overflows */
    onOverflow?: (droppedCount: number) => void;
    /** Callback when back to normal */
    onRecovery?: () => void;
}
export interface PressureStats {
    /** Current buffer fill level (0-1) */
    fillLevel: number;
    /** Pressure state */
    state: 'normal' | 'warning' | 'critical' | 'overflow';
    /** Current buffer size */
    bufferSize: number;
    /** Maximum buffer size */
    maxBuffer: number;
    /** Points dropped due to overflow */
    droppedCount: number;
    /** Points sampled/skipped */
    sampledCount: number;
    /** Incoming rate (points per second) */
    incomingRate: number;
    /** Outgoing rate (points per second) */
    outgoingRate: number;
    /** Whether stream is paused due to backpressure */
    isPaused: boolean;
}
export interface BufferHealth {
    /** Overall health score (0-100) */
    score: number;
    /** Health status */
    status: 'healthy' | 'degraded' | 'critical';
    /** Recommendations */
    recommendations: string[];
}
export declare class CircularBuffer<T> {
    private buffer;
    private head;
    private tail;
    private count;
    private readonly capacity;
    constructor(capacity: number);
    /**
     * Add item to buffer
     * @returns true if item was added, false if buffer was full
     */
    push(item: T): boolean;
    /**
     * Add item, overwriting oldest if full
     * @returns the overwritten item, or undefined
     */
    pushOverwrite(item: T): T | undefined;
    /**
     * Remove and return oldest item
     */
    shift(): T | undefined;
    /**
     * Remove and return multiple items
     */
    shiftMany(n: number): T[];
    /**
     * Peek at oldest item without removing
     */
    peek(): T | undefined;
    /**
     * Get all items as array
     */
    toArray(): T[];
    /**
     * Clear the buffer
     */
    clear(): void;
    /**
     * Get current size
     */
    size(): number;
    /**
     * Check if buffer is full
     */
    isFull(): boolean;
    /**
     * Check if buffer is empty
     */
    isEmpty(): boolean;
    /**
     * Get fill level (0-1)
     */
    fillLevel(): number;
    /**
     * Get capacity
     */
    getCapacity(): number;
}
export declare class BackpressureManager {
    private config;
    private buffers;
    private stats;
    private paused;
    private sampleCounter;
    private incomingHistory;
    private outgoingHistory;
    private lastRateUpdate;
    private currentIncoming;
    private currentOutgoing;
    constructor(config: BackpressureConfig);
    /**
     * Add points to the buffer with backpressure handling
     */
    push(seriesId: string, points: DataPoint[]): number;
    /**
     * Consume points from buffer
     */
    consume(seriesId: string, count?: number): DataPoint[];
    /**
     * Consume all points from buffer
     */
    consumeAll(seriesId: string): DataPoint[];
    /**
     * Get current pressure stats for a series
     */
    getPressureStats(seriesId: string): PressureStats;
    /**
     * Get aggregate stats for all series
     */
    getGlobalStats(): PressureStats;
    /**
     * Get buffer health assessment
     */
    getHealth(): BufferHealth;
    /**
     * Check if paused due to backpressure
     */
    isPaused(): boolean;
    /**
     * Resume if paused
     */
    resume(): void;
    /**
     * Clear all buffers
     */
    clear(seriesId?: string): void;
    /**
     * Update configuration
     */
    updateConfig(config: Partial<BackpressureConfig>): void;
    /**
     * Get current configuration
     */
    getConfig(): BackpressureConfig;
    private checkPressure;
    private updateRates;
    private getAverageRate;
}
/**
 * Create a backpressure manager with default settings
 */
export declare function createBackpressureManager(maxBuffer?: number, strategy?: OverflowStrategy): BackpressureManager;
/**
 * Create a high-performance backpressure manager optimized for real-time
 */
export declare function createRealtimeBackpressure(maxBuffer?: number): BackpressureManager;
/**
 * Create a lossless backpressure manager (for when data loss is unacceptable)
 */
export declare function createLosslessBackpressure(maxBuffer?: number): BackpressureManager;