import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
import Redis from 'ioredis';
import { PublisherOptions, Publisher, PublisherSubscribeListenerOptions } from '../index.mjs';
import '@orpc/shared';

interface IORedisPublisherOptions extends PublisherOptions, StandardRPCJsonSerializerOptions {
    /**
     * Redis commander instance (used for execute short-lived commands)
     */
    commander: Redis;
    /**
     * redis listener instance (used for listening to events)
     *
     * @remark
     * - `lazyConnect: true` option is supported
     */
    listener: Redis;
    /**
     * How long (in seconds) to retain events for replay.
     *
     * @remark
     * This allows new subscribers to "catch up" on missed events using `lastEventId`.
     * Note that event cleanup is deferred for performance reasons — meaning some
     * expired events may still be available for a short period of time, and listeners
     * might still receive them.
     *
     * @default NaN (disabled)
     */
    resumeRetentionSeconds?: number;
    /**
     * The prefix to use for Redis keys.
     *
     * @default orpc:publisher:
     */
    prefix?: string;
}
declare class IORedisPublisher<T extends Record<string, object>> extends Publisher<T> {
    private readonly commander;
    private readonly listener;
    private readonly prefix;
    private readonly serializer;
    private readonly retentionSeconds;
    private readonly subscriptionPromiseMap;
    private readonly listenersMap;
    private readonly onErrorsMap;
    private redisListenerAndOnError;
    private get isResumeEnabled();
    /**
     * The exactness of the `XTRIM` command.
     *
     * @internal
     */
    xtrimExactness: '~' | '=';
    /**
     * Useful for measuring memory usage.
     *
     * @internal
     *
     */
    get size(): number;
    constructor({ commander, listener, resumeRetentionSeconds, prefix, ...options }: IORedisPublisherOptions);
    private lastCleanupTimeMap;
    publish<K extends keyof T & string>(event: K, payload: T[K]): Promise<void>;
    protected subscribeListener<K extends keyof T & string>(event: K, originalListener: (payload: T[K]) => void, { lastEventId, onError }?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
    private prefixKey;
    private serializePayload;
    private deserializePayload;
}

export { IORedisPublisher };
export type { IORedisPublisherOptions };