import { Redis } from 'ioredis';
import { Middleware } from './middleware.js';
import { RotifConfig, RotifMessage, Subscription, PublishOptions, SubscribeOptions } from './types.js';
import { createRetryDelayFn } from '@omnitron-dev/titan/utils';
import { type DLQCleanupConfig } from './dlq-manager.js';
interface HealthStatus {
    connected: boolean;
    lastPingMs: number;
    lastCheckTime: number;
    consecutiveFailures: number;
}
export declare class NotificationManager {
    redis: Redis;
    config: RotifConfig;
    private logger;
    private middleware;
    private subscriptions;
    private active;
    private delayTimeoutId?;
    private activePatterns;
    private initializationDefer;
    private subClient?;
    private dlqClient?;
    private consumerLoops;
    private luaScripts;
    private roundRobinIndices;
    private dlqSubscriptionPromise?;
    private dlqManager;
    private dlqKey;
    private healthCheckTimer?;
    private healthStatus;
    private backpressureStates;
    private patternMatcherCache;
    private enableFieldPooling;
    constructor(config: RotifConfig);
    private startHealthCheck;
    getHealthStatus(): HealthStatus;
    private shouldApplyBackpressure;
    private updateBackpressure;
    loadLuaScripts(): Promise<void>;
    runLuaScript<T = any>(scriptName: string, keys: string[], args: (string | number)[]): Promise<T>;
    use(mw: Middleware): void;
    waitUntilReady(): Promise<void>;
    destroy(): Promise<void>;
    publish(channel: string, payload: any, options?: PublishOptions): Promise<string[] | string | null>;
    publishBatch(messages: Array<{
        channel: string;
        payload: any;
        options?: PublishOptions;
    }>): Promise<Array<string[] | string | null>>;
    subscribe(pattern: string, handler: (msg: RotifMessage) => Promise<void>, options?: SubscribeOptions): Promise<Subscription>;
    private startDelayScheduler;
    stopAll(): Promise<void>;
    subscribeToDLQ(handler: (msg: RotifMessage) => Promise<void>): Promise<void>;
    requeueFromDLQ(count?: number): Promise<number>;
    private subscribeToPatternUpdates;
    private startSharedConsumerLoop;
    private syncPatterns;
    private ensureStreamGroup;
    private getRoundRobinIndex;
    getDLQStats(): Promise<import("./dlq-manager.js").DLQStats>;
    getDLQMessages(options?: {
        channel?: string;
        limit?: number;
        offset?: number;
        maxAge?: number;
    }): Promise<import("./dlq-manager.js").DLQMessageInfo[]>;
    cleanupDLQ(): Promise<number>;
    clearDLQ(): Promise<void>;
    updateDLQConfig(config: Partial<DLQCleanupConfig>): void;
    static RetryStrategies: {
        readonly aggressive: <TContext = unknown>() => import("@omnitron-dev/titan/utils").RetryStrategyConfig<TContext>;
        readonly conservative: <TContext = unknown>() => import("@omnitron-dev/titan/utils").RetryStrategyConfig<TContext>;
        readonly immediate: <TContext = unknown>() => import("@omnitron-dev/titan/utils").RetryStrategyConfig<TContext>;
        readonly linear: <TContext = unknown>(baseDelay?: number) => import("@omnitron-dev/titan/utils").RetryStrategyConfig<TContext>;
        readonly fibonacci: <TContext = unknown>(baseDelay?: number) => import("@omnitron-dev/titan/utils").RetryStrategyConfig<TContext>;
        readonly none: <TContext = unknown>() => import("@omnitron-dev/titan/utils").RetryStrategyConfig<TContext>;
        readonly exponential: <TContext = unknown>(baseDelay?: number, multiplier?: number, maxDelay?: number, jitter?: number) => import("@omnitron-dev/titan/utils").RetryStrategyConfig<TContext>;
    };
    static createRetryDelayFn: typeof createRetryDelayFn;
    getSubscriptionStats(): {
        count: number;
        active: number;
        paused: number;
    };
}
export {};
//# sourceMappingURL=rotif.d.ts.map