import { EventPayload } from './types';
import { HttpClient } from './http-client';
interface QueueConfig {
    maxQueueSize: number;
    batchSize: number;
    flushInterval: number;
    maxRetryCount: number;
}
export declare class EventQueue {
    private config;
    private httpClient;
    private queue;
    private flushTimer;
    private isProcessing;
    private isOnline;
    private destroyed;
    constructor(httpClient: HttpClient, config: QueueConfig);
    /**
     * Initialize the queue by loading persisted events
     */
    private initializeQueue;
    /**
     * Re-enqueue dead-lettered events for another delivery attempt. Called on init and on
     * offline→online reconnect. Each replay resets retryCount and increments replayCount;
     * events that exhaust MAX_REPLAYS or exceed MAX_DEAD_LETTER_AGE_MS are dropped for good
     * (genuinely undeliverable), so this can't loop a permanently-bad event forever.
     */
    private replayDeadLetter;
    /**
     * Connectivity-class failures (aborted/timed-out/offline) are NOT the event's fault — a
     * sustained outage shouldn't burn the retry budget and dead-letter a perfectly-good
     * event. Only definitive server rejections consume retryCount.
     */
    private isConnectivityError;
    /**
     * Add an event to the queue
     */
    enqueue(payload: EventPayload): Promise<void>;
    /**
     * Process the queue and send events
     */
    private processQueue;
    /**
     * Park a permanently-failed event in a capped dead-letter store instead of silently
     * dropping it — surfaced (errorLog) and recoverable for replay/inspection.
     */
    private deadLetter;
    /**
     * Remove an event from the queue
     */
    private removeFromQueue;
    /**
     * Persist queue to storage
     */
    private persistQueue;
    /**
     * Start the periodic flush timer
     */
    private startFlushTimer;
    /**
     * Stop the flush timer
     */
    private stopFlushTimer;
    /**
     * Manually flush the queue
     */
    flush(): Promise<void>;
    /**
     * Set online/offline status
     */
    setOnlineStatus(isOnline: boolean): void;
    /**
     * Get queue statistics
     */
    getStats(): {
        queueSize: number;
        isProcessing: boolean;
        isOnline: boolean;
        oldestEventAge: number | null;
    };
    /**
     * Clear all events from the queue
     */
    clear(): Promise<void>;
    /**
     * Update configuration
     */
    updateConfig(config: Partial<QueueConfig>): void;
    /**
     * Destroy the queue and cleanup
     */
    destroy(): void;
}
/**
 * Default event queue factory
 */
export declare const createEventQueue: (httpClient: HttpClient, config?: Partial<QueueConfig>) => EventQueue;
export {};