import type { EffectLifecycleObserver } from "./effect-lifecycle.js";
import type { ReconciliationPage, ReconciliationScanOptions, ReconciliationScanPage, SagaDefinition, SagaRecord, SagaState, SagaStore } from "./internal/durable-types.js";
export declare function defineSaga<I, C extends Record<string, unknown>>(definition: SagaDefinition<I, C>): SagaDefinition<I, C>;
export declare class SagaConcurrencyError extends Error {
    readonly sagaId: string;
    constructor(sagaId: string);
}
export declare class SagaAmbiguousStepError extends Error {
    readonly sagaId: string;
    readonly step: string;
    readonly effectId: string;
    constructor(sagaId: string, step: string, effectId: string);
}
export declare class SagaResolutionError extends Error {
    readonly sagaId: string;
    readonly step: string;
    constructor(sagaId: string, step: string, message: string);
}
/** Throw this only when a provider conclusively proves that no effect committed. */
export declare class SagaStepNotCommittedError extends Error {
    readonly code: string;
    constructor(code?: string);
}
export interface SagaEngineOptions {
    readonly store: SagaStore;
    readonly now?: () => number;
    readonly observer?: EffectLifecycleObserver;
    /** Tests/local development only. Production sagas require a durable store. */
    readonly allowMemoryStore?: boolean;
}
export type SagaAmbiguityResolution = {
    readonly kind: "execution";
    readonly step: string;
    readonly effectId: string;
    readonly outcome: "committed";
    /** Provider-confirmed result required by later saga steps. */
    readonly result: unknown;
} | {
    readonly kind: "execution";
    readonly step: string;
    readonly effectId: string;
    readonly outcome: "not-committed";
    readonly errorCode?: string;
} | {
    readonly kind: "compensation";
    readonly step: string;
    readonly effectId: string;
    readonly outcome: "compensated" | "not-compensated";
};
export interface SagaEngine {
    execute<I, C extends Record<string, unknown>>(definition: SagaDefinition<I, C>, sagaId: string, input: I, options?: {
        readonly signal?: AbortSignal;
    }): Promise<SagaRecord>;
    resume<I, C extends Record<string, unknown>>(definition: SagaDefinition<I, C>, sagaId: string, options?: {
        readonly signal?: AbortSignal;
    }): Promise<SagaRecord>;
    compensate<I, C extends Record<string, unknown>>(definition: SagaDefinition<I, C>, sagaId: string, options?: {
        readonly signal?: AbortSignal;
    }): Promise<SagaRecord>;
    /**
     * Apply a provider/operator-confirmed outcome to an ambiguous durable transition. The supplied
     * effect id must match the stored execution/compensation id, preventing a stale review from
     * resolving a later operation. The caller remains responsible for authenticating and authorizing
     * the operator. Call `resume` or `compensate` after the resolution.
     */
    resolveAmbiguity<I, C extends Record<string, unknown>>(definition: SagaDefinition<I, C>, sagaId: string, resolution: SagaAmbiguityResolution): Promise<SagaRecord>;
}
export declare function createSagaEngine(options: SagaEngineOptions): SagaEngine;
export declare class MemorySagaStore implements SagaStore {
    readonly durability: "memory";
    private readonly records;
    private readonly byState;
    create(record: SagaRecord): boolean;
    get(sagaId: string): SagaRecord | undefined;
    compareAndSet(input: Parameters<SagaStore["compareAndSet"]>[0]): boolean;
    list(): readonly SagaRecord[];
    scan(input: ReconciliationScanOptions<SagaState>): ReconciliationScanPage<SagaRecord>;
}
export interface SagaReconciliationFinding {
    readonly sagaId: string;
    readonly state: SagaState;
    readonly step?: string;
    readonly effectId?: string;
    readonly reason: "stale-running" | "ambiguous-execution" | "ambiguous-compensation" | "manual-review";
}
export declare function reconcileSagasPage(store: SagaStore, options: {
    readonly staleBefore: number;
    readonly cursor?: string;
    readonly limit?: number;
}): Promise<ReconciliationPage<SagaReconciliationFinding>>;
export declare function reconcileSagas(store: SagaStore, options: {
    readonly staleBefore: number;
}): Promise<readonly SagaReconciliationFinding[]>;
//# sourceMappingURL=durable-saga.d.ts.map