/**
 * Timer Manager for background processing
 *
 * Features:
 * - Background timer processing
 * - Timer recovery on restart
 * - Automatic retry for missed timers
 * - Cancellation support
 * - Cleanup of old timers
 */
import type { TimerEntry, TimerStore } from '@cogitator-ai/types';
/**
 * Timer handler function
 */
export type TimerHandler = (entry: TimerEntry) => Promise<void> | void;
/**
 * Timer manager configuration
 */
export interface TimerManagerConfig {
    /**
     * Interval for checking overdue timers (ms)
     * @default 1000
     */
    pollInterval?: number;
    /**
     * Maximum number of timers to process per poll
     * @default 100
     */
    batchSize?: number;
    /**
     * Whether to process overdue timers on startup
     * @default true
     */
    processOverdueOnStart?: boolean;
    /**
     * Maximum age for cleanup (ms)
     * @default 7 days
     */
    cleanupMaxAge?: number;
    /**
     * Interval for cleanup (ms)
     * @default 1 hour
     */
    cleanupInterval?: number;
    /**
     * Whether to enable cleanup
     * @default true
     */
    enableCleanup?: boolean;
    /**
     * Handler for timer errors
     */
    onError?: (error: Error, entry?: TimerEntry) => void;
    /**
     * Handler for timer fired events
     */
    onTimerFired?: (entry: TimerEntry) => void;
    /**
     * Handler for timer missed events (overdue timers)
     */
    onTimerMissed?: (entry: TimerEntry, delayMs: number) => void;
    /**
     * Maximum consecutive handler errors before dead-lettering a timer.
     * Set to 0 for unlimited retries (previous behavior).
     * @default 5
     */
    maxRetries?: number;
    /**
     * Called when a timer is dead-lettered after exceeding maxRetries
     */
    onDeadLetter?: (entry: TimerEntry, error: Error) => void;
}
/**
 * Timer manager stats
 */
export interface TimerManagerStats {
    running: boolean;
    processedTotal: number;
    errorTotal: number;
    overdueProcessed: number;
    cleanedUpTotal: number;
    lastPollAt?: number;
    lastCleanupAt?: number;
    activeTimers: number;
}
/**
 * Timer Manager class
 */
export declare class TimerManager {
    private store;
    private config;
    private handlers;
    private defaultHandler?;
    private pollTimer?;
    private cleanupTimer?;
    private running;
    private processing;
    private processedTotal;
    private errorTotal;
    private overdueProcessed;
    private cleanedUpTotal;
    private lastPollAt?;
    private lastCleanupAt?;
    constructor(store: TimerStore, config?: TimerManagerConfig);
    /**
     * Register a handler for a specific workflow
     */
    registerHandler(workflowId: string, handler: TimerHandler): () => void;
    /**
     * Set default handler for all timers without specific handler
     */
    setDefaultHandler(handler: TimerHandler): void;
    /**
     * Start the timer manager
     */
    start(): Promise<void>;
    /**
     * Stop the timer manager
     */
    stop(): Promise<void>;
    /**
     * Poll for overdue timers and process them
     */
    private poll;
    /**
     * Process overdue timers (for recovery)
     */
    private processOverdueTimers;
    /**
     * Process a single timer
     */
    private processTimer;
    /**
     * Run cleanup
     */
    private cleanup;
    /**
     * Schedule a timer
     */
    schedule(entry: Omit<TimerEntry, 'id' | 'cancelled' | 'fired' | 'createdAt'>): Promise<string>;
    /**
     * Cancel a timer
     */
    cancel(timerId: string): Promise<void>;
    /**
     * Cancel all timers for a workflow run
     */
    cancelRun(runId: string): Promise<number>;
    /**
     * Cancel all timers for a workflow
     */
    cancelWorkflow(workflowId: string): Promise<number>;
    /**
     * Get timer by ID
     */
    getTimer(timerId: string): Promise<TimerEntry | null>;
    /**
     * Get all pending timers
     */
    getPendingTimers(): Promise<TimerEntry[]>;
    /**
     * Get timers for a workflow
     */
    getWorkflowTimers(workflowId: string): Promise<TimerEntry[]>;
    /**
     * Get timers for a run
     */
    getRunTimers(runId: string): Promise<TimerEntry[]>;
    /**
     * Get manager stats
     */
    getStats(): Promise<TimerManagerStats>;
    /**
     * Force process overdue timers now
     */
    processNow(): Promise<number>;
    /**
     * Force cleanup now
     */
    cleanupNow(): Promise<number>;
    /**
     * Check if manager is running
     */
    isRunning(): boolean;
}
/**
 * Create a timer manager
 */
export declare function createTimerManager(store: TimerStore, config?: TimerManagerConfig): TimerManager;
/**
 * Timer scheduler for recurring timers
 */
export declare class RecurringTimerScheduler {
    private manager;
    private recurring;
    constructor(manager: TimerManager);
    /**
     * Schedule a recurring timer
     */
    scheduleRecurring(id: string, config: {
        workflowId: string;
        runId: string;
        nodeId: string;
        interval: number;
        metadata?: Record<string, unknown>;
        startImmediately?: boolean;
    }): Promise<void>;
    /**
     * Cancel a recurring timer
     */
    cancelRecurring(id: string): Promise<void>;
    /**
     * Schedule next occurrence (called after timer fires)
     */
    scheduleNext(id: string, runId: string): Promise<string | null>;
    /**
     * Check if recurring timer exists
     */
    hasRecurring(id: string): boolean;
    /**
     * Get all recurring timer IDs
     */
    getRecurringIds(): string[];
}
/**
 * Create a recurring timer scheduler
 */
export declare function createRecurringScheduler(manager: TimerManager): RecurringTimerScheduler;
//# sourceMappingURL=timer-manager.d.ts.map