import type { InboxItem } from '../../shared/inbox.js';
import { WakeQueueStore, type TakeNextRunnableInput } from '../storage/schema/wake-queue.store.js';
export type { InboxItem };
export interface WakeQueueEnqueueResult {
    duplicate: boolean;
    item: InboxItem;
    queued: boolean;
    /** True when the item is durable but not yet claimable (preflight publish path). */
    staged?: boolean;
}
export interface WakeQueueMessageRecorder {
    hasInboxItem?(itemId: string): Promise<boolean>;
    recordInboxItem(item: InboxItem): Promise<{
        inserted: boolean;
    } | undefined>;
}
interface WakeQueueLogger {
    warn(message: string): void;
}
export declare const wakeQueueServiceForAgent: (agentId: string) => WakeQueueService;
export declare class WakeQueueService {
    readonly agentId: string;
    private readonly store;
    private readonly messages;
    private readonly logger;
    constructor(agentId: string, store?: WakeQueueStore, messages?: WakeQueueMessageRecorder, logger?: WakeQueueLogger);
    /**
     * Enqueue with the wake-queue file as the dedupe authority: the insert
     * atomically checks active items plus settled seen markers, so a crash
     * between steps can no longer drop a wake. The message ledger is written
     * after the item is safely queued — it is conversation history, not dedupe
     * state — with one legacy exception: ids settled before seen markers
     * existed are only known to the ledger, so a ledger hit withdraws the
     * just-queued item (or, if a worker already claimed it, lets it run once).
     */
    enqueue(event: InboxItem): Promise<WakeQueueEnqueueResult>;
    /**
     * Durable insert that workers cannot claim yet (`handling.stagedAt` set).
     * No wake signal and no message-ledger write (uncommitted stages must not
     * create phantom history or seen tombstones). Pair with `publishQueued`
     * after CAS, or `abandonStaged` to drop without tombstoning. Reuses an
     * existing still-staged row for the same id (crash recovery mid path).
     */
    enqueueStaged(event: InboxItem): Promise<WakeQueueEnqueueResult>;
    /**
     * Publish a staged row for claim: clear stagedAt, write message ledger, signal.
     * Returns false when the item is missing, already published, or no longer queued.
     */
    publishQueued(itemId: string): Promise<boolean>;
    /**
     * Remove a still-queued (unclaimed) item and mark it seen (true settle/dedupe).
     */
    withdrawQueued(itemId: string): Promise<InboxItem | undefined>;
    /**
     * Atomically settle multiple still-claimable queued items to seen (one store
     * update). Cursor-delivery coalescing uses this so the selected same-surface
     * set cannot partially land.
     */
    withdrawQueuedBatch(itemIds: string[]): Promise<InboxItem[]>;
    /**
     * Drop an uncommitted staged wake without a seen tombstone so the same fire
     * id remains reusable after cancel/snooze CAS miss.
     */
    abandonStaged(itemId: string): Promise<InboxItem | undefined>;
    hasSeen(itemId: string): Promise<boolean>;
    find(itemId: string): Promise<InboxItem | undefined>;
    replaceItem(item: InboxItem): Promise<InboxItem>;
    replaceQueuedItem(item: InboxItem): Promise<boolean>;
    list(): Promise<InboxItem[]>;
    takeNextRunnable(input: TakeNextRunnableInput): Promise<InboxItem | undefined>;
    takeFollowupBatch(input: {
        activeItemId: string;
        excludedItemIds?: Iterable<string>;
        limit: number;
        workerId: string;
    }): Promise<InboxItem[]>;
    complete(itemId: string): Promise<void>;
    completeAppendedTo(parentItemId: string): Promise<InboxItem[]>;
    fail(itemId: string): Promise<void>;
    failAppendedTo(parentItemId: string): Promise<InboxItem[]>;
    requeue(itemId: string, options?: {
        resumeReason?: 'runtime_restart';
    }): Promise<void>;
    /**
     * Requeue without signalWake. Used when cursor-delivery prepare fails closed
     * mid-drain: a wake would set pendingWake and immediately reclaim the same
     * item in a hot loop. The regular poll timer retries later.
     */
    requeueQuiet(itemId: string, options?: {
        resumeReason?: 'runtime_restart';
    }): Promise<void>;
    requeueBatch(itemIds: string[]): Promise<InboxItem[]>;
    requeueAppendedTo(parentItemId: string, options?: {
        resumeReason?: 'runtime_restart';
    }): Promise<InboxItem[]>;
    requestStop(itemId: string): Promise<InboxItem>;
    requestDrain(input: {
        itemId: string;
        timeoutMs: number;
    }): Promise<InboxItem>;
    clearDrainRequest(itemId: string): Promise<InboxItem>;
    markRunning(input: {
        itemId: string;
        startedAt?: string;
        workerId: string;
    }): Promise<InboxItem>;
    markAppended(input: {
        itemId: string;
        parentItemId: string;
        workerId: string;
    }): Promise<InboxItem>;
    markAppendedBatch(input: {
        itemIds: string[];
        parentItemId: string;
        workerId: string;
    }): Promise<InboxItem[]>;
    markSettled(input: {
        itemId: string;
        workerId: string;
    }): Promise<InboxItem | undefined>;
    private recordMessage;
}
//# sourceMappingURL=wake-queue.service.d.ts.map