import type { Redis } from 'ioredis';
import type { ArchiveSourcePage, ClosedWriteFence, HotWriteToken, RehydrateSnapshot, SeriesResult, StorageLease, StorageWriterRegistration, Task, TaskEvent, TaskMutationSnapshot, TaskStatus, ShortTermStore, TaskStoragePresence, TaskWriteFence, EventQueryOptions, TaskArchiveImportOptions, TaskArchiveRestoreData, TaskFilter, Worker, WorkerFilter, WorkerAssignment, TerminalProjection, TerminalProjectionResult } from '@taskcast/core';
import { type RedisOperationOptions } from './connectivity.js';
export declare class RedisShortTermStore implements ShortTermStore {
    private redis;
    private options;
    readonly supportsHotColdRelease = true;
    private KEY;
    private legacySeriesWrites;
    constructor(redis: Redis, options?: {
        prefix?: string;
        legacySeriesWrites?: boolean;
    } & RedisOperationOptions);
    saveTask(task: Task): Promise<void>;
    getTask(taskId: string): Promise<Task | null>;
    getTaskMutationSnapshot(taskId: string): Promise<TaskMutationSnapshot | null>;
    acquireStorageLock(taskId: string, lockToken: string, generation: string, ttlMs: number): Promise<StorageLease | null>;
    renewStorageLock(lease: StorageLease, ttlMs: number): Promise<boolean>;
    releaseStorageLock(lease: StorageLease): Promise<boolean>;
    getWriteFence(taskId: string): Promise<TaskWriteFence | null>;
    closeWriteFence(lease: StorageLease, expectedEpoch: number): Promise<ClosedWriteFence>;
    reopenWriteFence(lease: StorageLease, expectedEpoch: number): Promise<HotWriteToken>;
    commitEventFenced(taskId: string, event: Omit<TaskEvent, 'index'>, token: HotWriteToken): Promise<SeriesResult>;
    saveTaskFenced(task: Task, token: HotWriteToken): Promise<void>;
    commitTaskEventsFenced(task: Task, expectedRevision: string, events: Omit<TaskEvent, 'index'>[], token: HotWriteToken): Promise<TaskEvent[] | null>;
    readArchiveSourcePage(taskId: string, watermark: number, cursor: string | null, limit: number): Promise<ArchiveSourcePage>;
    deleteTaskStorageFenced(lease: StorageLease, expectedEpoch: number): Promise<void>;
    restoreHotTaskFenced(snapshot: RehydrateSnapshot, lease: StorageLease, nextEpoch: number): Promise<HotWriteToken>;
    projectTerminalFenced(projection: TerminalProjection, lease: StorageLease, expectedEpoch: number, nextEpoch: number): Promise<TerminalProjectionResult>;
    getTaskStoragePresence(taskId: string): Promise<TaskStoragePresence>;
    registerStorageWriter(registration: StorageWriterRegistration, ttlMs: number): Promise<void>;
    listStorageWriters(): Promise<StorageWriterRegistration[]>;
    nextIndex(taskId: string): Promise<number>;
    appendEvent(taskId: string, event: TaskEvent): Promise<void>;
    validateTaskArchiveRestore(data: TaskArchiveRestoreData, options?: TaskArchiveImportOptions): Promise<void>;
    private assertRedisType;
    restoreTaskArchive(data: TaskArchiveRestoreData, options?: TaskArchiveImportOptions): Promise<{
        overwritten: boolean;
    }>;
    private execPipelineOrThrow;
    getEvents(taskId: string, opts?: EventQueryOptions): Promise<TaskEvent[]>;
    setTTL(taskId: string, ttlSeconds: number): Promise<void>;
    getSeriesLatest(taskId: string, seriesId: string): Promise<TaskEvent | null>;
    setSeriesLatest(taskId: string, seriesId: string, event: TaskEvent): Promise<void>;
    accumulateSeries(taskId: string, seriesId: string, event: TaskEvent, field: string): Promise<TaskEvent>;
    replaceLastSeriesEvent(taskId: string, seriesId: string, event: TaskEvent): Promise<void>;
    listTasks(filter: TaskFilter): Promise<Task[]>;
    saveWorker(worker: Worker): Promise<void>;
    getWorker(workerId: string): Promise<Worker | null>;
    listWorkers(filter?: WorkerFilter): Promise<Worker[]>;
    deleteWorker(workerId: string): Promise<void>;
    private makeIndexedEventTemplate;
    private parseSeriesState;
    private selectSeriesState;
    private parseEventListHead;
    private accumulateEvent;
    private scanSeriesKeys;
    private evalFenced;
    private encodeArchiveCursor;
    private decodeArchiveCursor;
    private validateRehydrateSnapshot;
    private static SAVE_TASK_LUA;
    private static ACQUIRE_STORAGE_LOCK_LUA;
    private static RENEW_STORAGE_LOCK_LUA;
    private static RELEASE_STORAGE_LOCK_LUA;
    private static CLOSE_WRITE_FENCE_LUA;
    private static REOPEN_WRITE_FENCE_LUA;
    private static COMMIT_EVENT_FENCED_LUA;
    private static SAVE_TASK_FENCED_LUA;
    private static COMMIT_TASK_EVENTS_FENCED_LUA;
    private static DELETE_TASK_STORAGE_LUA;
    private static RESTORE_HOT_TASK_LUA;
    private static PROJECT_TERMINAL_FENCED_LUA;
    private static REGISTER_STORAGE_WRITER_LUA;
    private static SET_SERIES_LATEST_LUA;
    private static ACCUMULATE_LUA;
    private static CLAIM_LUA;
    claimTask(taskId: string, workerId: string, cost: number): Promise<boolean>;
    addAssignment(assignment: WorkerAssignment): Promise<void>;
    removeAssignment(taskId: string): Promise<void>;
    getWorkerAssignments(workerId: string): Promise<WorkerAssignment[]>;
    getTaskAssignment(taskId: string): Promise<WorkerAssignment | null>;
    clearTTL(taskId: string): Promise<void>;
    listByStatus(statuses: TaskStatus[]): Promise<Task[]>;
    private inspectPipelineForConnectionErrors;
}
//# sourceMappingURL=short-term.d.ts.map