import type { DatabaseSync } from 'node:sqlite';
import { type ActivationStatus, type SceneActivation, type ScenePrincipal, type SceneTemplate } from './contracts.js';
export interface SceneEventInput {
    source: string;
    sourceEventId: string;
    eventType: string;
    subjectId: string;
    occurredAt: number;
    accountId?: string;
}
export interface SceneRunClaim {
    id: string;
    intentId: string;
    activationId: string;
    activationRevision: number;
    leaseOwner: string;
    leaseEpoch: number;
    attempt: number;
}
export interface SceneWorkItem {
    id: string;
    activationId: string;
    subjectId: string;
    accountId: string;
    dueAt: number;
    revision: number;
    status: 'watching' | 'paused' | 'completed';
}
export declare class SceneConflictError extends Error {
}
export declare class SceneNotFoundError extends Error {
}
export declare class SceneInputError extends Error {
}
/** The caller supplies the database; storage is initialized by the normal database upgrade. */
export declare class SceneRepository {
    private readonly db;
    constructor(db: DatabaseSync);
    get database(): DatabaseSync;
    private transaction;
    installTemplate(value: unknown): SceneTemplate;
    getTemplate(key: string, version: string): SceneTemplate;
    listTemplates(): SceneTemplate[];
    listRuns(principal: ScenePrincipal, activationId: string, limit?: number, afterId?: string): Record<string, import("node:sqlite").SQLOutputValue>[];
    createActivation(principal: ScenePrincipal, value: unknown, requestId?: string): SceneActivation;
    listActivations(principal: ScenePrincipal, limit?: number, afterId?: string): SceneActivation[];
    getActivation(principal: ScenePrincipal, id: string): SceneActivation;
    recordSourceHealth(activation: SceneActivation, reason: string | null, now: number, retryAt?: number | null): void;
    getSourceHealth(activationId: string): Record<string, import("node:sqlite").SQLOutputValue>;
    reuseUnchangedResult(claim: SceneRunClaim, hash: string, now: number, inspectOnly?: boolean): boolean;
    /** Configuration edits require a fresh preflight before any execution resumes. */
    configureActivation(principal: ScenePrincipal, id: string, revision: number, value: unknown): SceneActivation;
    writeNotes(principal: ScenePrincipal, id: string, value: unknown, now: number): number;
    readNotes(principal: ScenePrincipal, id: string): Record<string, import("node:sqlite").SQLOutputValue>;
    listWorkItems(principal: ScenePrincipal, activationId: string, limit?: number, afterId?: string): Record<string, import("node:sqlite").SQLOutputValue>[];
    listSchedules(principal: ScenePrincipal, activationId: string): {
        triggerKey: string;
        schedule: {
            weekdays: number[];
            hour: number;
            minute: number;
            timeZone: string;
        };
        revision: number;
        nextDueAt: number;
    }[];
    createWorkItem(principal: ScenePrincipal, activationId: string, input: {
        subjectId: string;
        accountId: string;
        dueAt: number;
    }, now: number): SceneWorkItem;
    listMailObservationItems(afterId?: string, now?: number): Array<{
        principal: ScenePrincipal;
        item: SceneWorkItem;
    }>;
    isMailObservationCurrent(activation: SceneActivation, item: SceneWorkItem, now?: number): boolean;
    observeMailWorkItem(principal: ScenePrincipal, item: SceneWorkItem, fingerprint: string, now: number): boolean;
    /** Revision changes invalidate only this item's pending work and visible results. */
    updateWorkItem(principal: ScenePrincipal, id: string, input: {
        expectedRevision: number;
        status?: SceneWorkItem['status'];
        dueAt?: number;
    }, now: number): SceneWorkItem;
    /** Due dates are durable; restarting cannot generate a second occurrence. */
    enqueueDueWorkItems(now: number): number;
    transitionActivation(principal: ScenePrincipal, id: string, revision: number, status: ActivationStatus, now?: number): SceneActivation;
    setSchedule(principal: ScenePrincipal, activationId: string, triggerKey: string, expectedRevision: number, value: unknown, now: number): number;
    /** Coalesces missed occurrences into at most one bounded catch-up per schedule. */
    enqueueDueSchedules(now: number): number;
    /** Called by an authorized producer inside its domain transaction when applicable. */
    acceptTrigger(principal: ScenePrincipal, activationId: string, input: {
        event: SceneEventInput;
        triggerKey: string;
        occurrenceKey: string;
        dueAt: number;
    }, now: number): string;
    acceptManualCheck(principal: ScenePrincipal, activationId: string, triggerKey: string, requestId: string, now: number): string;
    claimNext(worker: string, now: number, leaseMs?: number): SceneRunClaim | null;
    claimIntentForAdapter(principal: ScenePrincipal, activationId: string, intentId: string, adapterId: string, worker: string, now: number, leaseMs: number): SceneRunClaim;
    renewLease(claim: SceneRunClaim, now: number, leaseMs: number): boolean;
    reserveModelCall(claim: SceneRunClaim, now: number, limits?: {
        activation: number;
        owner: number;
    }): boolean;
    deferRun(claim: SceneRunClaim, now: number, reason: 'source_not_ready' | 'daily_budget', retryAt: number): 'deferred' | 'failed' | 'discarded';
    getRunInput(claim: SceneRunClaim, now: number): {
        activation: SceneActivation;
        subjectId: string;
        accountId?: string;
        notBefore?: number;
    } | null;
    saveSnapshot(claim: SceneRunClaim, hash: string, evidenceIds: string[], now: number): boolean;
    finishReadOnlyRun(claim: SceneRunClaim, result: {
        kind: 'no_change' | 'observation' | 'artifact' | 'decision';
        summary: string;
        evidenceIds: string[];
    }, now: number): boolean;
    finishAdapterRun(claim: SceneRunClaim, result: {
        kind: 'artifact' | 'decision' | 'receipt';
        summary: string;
        [key: string]: unknown;
    }, now: number): boolean;
    listInbox(principal: ScenePrincipal, limit?: number, afterId?: string, activationId?: string | null): {
        createdAt: number;
        sources: {
            kind: string;
            title: string;
            sender: string;
            href: string;
        }[];
        sourceHealth: Record<string, import("node:sqlite").SQLOutputValue>;
        id: string;
        activationId: string;
        outcomeId: string;
        content: unknown;
        status: string;
        readOnly: boolean;
    }[];
    getPresentation(principal: ScenePrincipal, id: string): {
        createdAt: number;
        sources: {
            kind: string;
            title: string;
            sender: string;
            href: string;
        }[];
        sourceHealth: Record<string, import("node:sqlite").SQLOutputValue>;
        id: string;
        activationId: string;
        outcomeId: string;
        content: unknown;
        status: string;
        readOnly: boolean;
    };
    listDigestResults(principal: ScenePrincipal, digestId: string, limit?: number, afterId?: string): {
        outcomes: {
            createdAt: number;
            sources: {
                kind: string;
                title: string;
                sender: string;
                href: string;
            }[];
            sourceHealth: Record<string, import("node:sqlite").SQLOutputValue>;
            id: string;
            activationId: string;
            outcomeId: string;
            content: unknown;
            status: string;
            readOnly: boolean;
        }[];
        nextCursor: string;
    };
    failRun(claim: SceneRunClaim, now: number, reason: string, retryAt?: number): boolean;
    private isCurrentClaim;
    private readClaim;
    private assertPrincipal;
}