import { type LifecycleHook, type ProcedureManifest } from "@aotter/mantle-spec";
import type { EntryRow } from "../../domain/model/EntryRow.js";
import type { HandlerContext } from "../../domain/model/HandlerContext.js";
import type { TriggerIndex } from "../../domain/service/TriggerIndex.js";
import type { InvokeProcedureRequest, InvokeProcedureResponse } from "../dto/procedure/index.js";
export type InvokeProcedureFn = (request: InvokeProcedureRequest) => Promise<InvokeProcedureResponse>;
export interface RunLifecycleHookRequest {
    /** One event id is shared by every captured Trigger. */
    readonly eventId: string;
    /** Ordered Trigger names captured before dispatch. */
    readonly triggerNames: readonly string[];
    readonly delivery: "inline" | "deferred";
    readonly hook: LifecycleHook;
    readonly schema: string;
    /** Pre-mutation row for `before_*`; persisted row for `after_*`.
     *  `null` only on `before_create`. */
    readonly entry: EntryRow | null;
    readonly ctx: HandlerContext;
    /** Pre-projection caller input. Used only by `before_*` hooks. */
    readonly originalInput?: unknown;
}
/**
 * Runs one captured lifecycle event. Inline `continue` failures are
 * logged and swallowed so the mutation result stands. Deferred runs
 * still execute every captured Trigger, then throw an aggregate so
 * the delivery adapter retries the event.
 */
export declare class RunLifecycleHooksUseCase {
    private readonly triggers;
    private readonly proceduresByName;
    private readonly invoke;
    constructor(triggers: TriggerIndex, proceduresByName: ReadonlyMap<string, ProcedureManifest>, invoke: InvokeProcedureFn);
    run(request: RunLifecycleHookRequest): Promise<void>;
    private resolveCapturedTriggers;
    private runOne;
}
//# sourceMappingURL=RunLifecycleHooksUseCase.d.ts.map