import type { Task, TaskEvent, TaskStatus, BroadcastProvider, ShortTermStore, EventQueryOptions, TaskFilter, Worker, WorkerFilter, WorkerAssignment, TaskArchiveImportOptions, TaskArchiveRestoreData, StorageLease, TaskMutationSnapshot, TaskWriteFence, ClosedWriteFence, HotWriteToken, SeriesResult, ArchiveSourcePage, RehydrateSnapshot, TaskStoragePresence, StorageWriterRegistration, StorageReleaseRequest, LongTermStore, ArchiveBatch, ArchiveBatchReceipt, ArchiveGeneration, DurableSeriesState, TaskStorageMetadata, TaskStorageMetadataCas, WorkerAuditEvent, TerminalProjection, TerminalProjectionResult, TtlClaim } from './types.js';
export declare class MemoryBroadcastProvider implements BroadcastProvider {
    private listeners;
    publish(channel: string, event: TaskEvent): Promise<void>;
    subscribe(channel: string, handler: (event: TaskEvent) => void): () => void;
}
export declare class MemoryShortTermStore implements ShortTermStore {
    readonly supportsHotColdRelease = true;
    private tasks;
    private taskRevisions;
    private events;
    private seriesLatest;
    private indexCounters;
    private workers;
    private assignments;
    private storageLocks;
    private writeFences;
    private storageWriters;
    saveTask(task: Task): Promise<void>;
    getTask(taskId: string): Promise<Task | null>;
    getTaskMutationSnapshot(taskId: string): Promise<TaskMutationSnapshot | null>;
    nextIndex(taskId: string): Promise<number>;
    appendEvent(taskId: string, event: TaskEvent): Promise<void>;
    validateTaskArchiveRestore(data: TaskArchiveRestoreData, options?: TaskArchiveImportOptions): Promise<void>;
    restoreTaskArchive(data: TaskArchiveRestoreData, options?: TaskArchiveImportOptions): Promise<{
        overwritten: boolean;
    }>;
    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[]>;
    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>;
    private accumulateSeriesSync;
    replaceLastSeriesEvent(taskId: string, seriesId: string, event: TaskEvent): Promise<void>;
    private replaceLastSeriesEventSync;
    private appendEventSync;
    private getOwnedStorageLock;
    private assertOwnedStorageLock;
    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>;
    claimTask(taskId: string, workerId: string, cost: number): Promise<boolean>;
    private bumpTaskRevision;
    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[]>;
}
export declare class MemoryLongTermStore implements LongTermStore {
    readonly supportsHotColdRelease = true;
    readonly supportsDurableTtl = true;
    private tasks;
    private events;
    private metadata;
    private generations;
    private batches;
    private series;
    private workerEvents;
    private releaseRequests;
    private ttlClaims;
    private durableAssignments;
    private terminalProjections;
    private creationClaims;
    saveTask(task: Task): Promise<void>;
    createTaskIfAbsent(task: Task): Promise<boolean>;
    claimTaskCreation(task: Task, creationToken: string, claimTtlMs: number): Promise<boolean>;
    completeTaskCreation(taskId: string, creationToken: string): Promise<boolean>;
    abortTaskCreation(taskId: string, creationToken: string): Promise<boolean>;
    private isPristineCreationClaim;
    getTask(taskId: string): Promise<Task | null>;
    saveEvent(event: TaskEvent): Promise<void>;
    replaceLastSeriesEvent(taskId: string, seriesId: string, event: TaskEvent): Promise<void>;
    accumulateSeries(taskId: string, seriesId: string, event: TaskEvent, field: string): Promise<TaskEvent>;
    getEvents(taskId: string, opts?: EventQueryOptions): Promise<TaskEvent[]>;
    getTaskStorageMetadata(taskId: string): Promise<TaskStorageMetadata | null>;
    persistStorageReleaseRequest(request: StorageReleaseRequest): Promise<boolean>;
    clearStorageReleaseRequest(request: StorageReleaseRequest): Promise<boolean>;
    listStorageReleaseRequests(limit: number): Promise<StorageReleaseRequest[]>;
    compareAndSetTaskStorageMetadata(update: TaskStorageMetadataCas): Promise<boolean>;
    beginArchive(generation: ArchiveGeneration): Promise<ArchiveGeneration>;
    archiveBatch(taskId: string, generation: string, batch: ArchiveBatch): Promise<ArchiveBatchReceipt>;
    finalizeArchive(taskId: string, generation: string, task: Task, seriesLatest: DurableSeriesState[]): Promise<number>;
    getArchiveWatermark(taskId: string): Promise<number>;
    getLastEventIndex(taskId: string): Promise<number>;
    getRecentEvents(taskId: string, limit: number): Promise<TaskEvent[]>;
    getDurableSeriesState(taskId: string): Promise<DurableSeriesState[]>;
    claimOverdueTasks(limit: number, claimTtlMs: number): Promise<TtlClaim[]>;
    terminalizeTtlClaim(claim: TtlClaim, task: Task, event: TaskEvent, assignment: WorkerAssignment | null): Promise<TerminalProjection | null>;
    claimTerminalProjections(limit: number, claimToken: string, claimTtlMs: number): Promise<TerminalProjection[]>;
    completeTerminalProjection(projection: TerminalProjection): Promise<void>;
    saveDurableAssignment(assignment: WorkerAssignment): Promise<void>;
    deleteDurableAssignment(taskId: string, assignmentId?: string): Promise<void>;
    saveWorkerEvent(event: WorkerAuditEvent): Promise<void>;
    getWorkerEvents(workerId: string, opts?: EventQueryOptions): Promise<WorkerAuditEvent[]>;
    private upsertEvent;
    private upsertSeriesState;
    private archiveKey;
}
//# sourceMappingURL=memory-adapters.d.ts.map