import { z } from 'zod';
import type { EffectPreparationJournal, EffectReceiptJournal } from './effectJournal.ts';
import type { EffectReceipt, EffectReceiptObservation } from './effectModel.ts';
import type { PreparedEffectRecord } from './effectPreparation.ts';
type OmitObservationSequence<T> = T extends EffectReceiptObservation ? Omit<T, 'sequence'> : never;
export type EffectReceiptObservationInput = OmitObservationSequence<EffectReceiptObservation>;
export declare const EffectExecutionMaxAdvancesZod: z.ZodNumber;
export interface EffectReconciliationAdvance {
    readonly observation: EffectReceiptObservationInput;
    readonly state: 'advance';
}
export interface EffectReconciliationPending {
    readonly reasonCode: string;
    readonly state: 'pending';
}
export type EffectReconciliationResult = EffectReconciliationAdvance | EffectReconciliationPending;
export interface EffectReconciler {
    /** Observe canonical evidence before retrying an incomplete external stage. */
    reconcile(receipt: EffectReceipt): Promise<EffectReconciliationResult>;
}
export interface ExecuteEffectOptions {
    readonly isCancellationRequested?: () => boolean;
    readonly journal: EffectReceiptJournal;
    readonly maxAdvances: number;
    readonly reconciler: EffectReconciler;
}
export interface ExecutePreparedEffectOptions extends Omit<ExecuteEffectOptions, 'journal'> {
    readonly journal: EffectPreparationJournal;
}
export declare const EffectExecutionOutcomeStates: readonly ["abandoned", "advance-limit", "cancelled", "complete", "pending"];
export declare const EffectExecutionOutcomeStateZod: z.ZodEnum<{
    pending: "pending";
    abandoned: "abandoned";
    "advance-limit": "advance-limit";
    cancelled: "cancelled";
    complete: "complete";
}>;
export type EffectExecutionOutcomeState = z.infer<typeof EffectExecutionOutcomeStateZod>;
export interface EffectExecutionOutcome {
    readonly advances: number;
    readonly reasonCode?: string;
    readonly receipt: EffectReceipt;
    readonly state: EffectExecutionOutcomeState;
}
export declare function executeEffect(preparedValue: EffectReceipt, options: ExecuteEffectOptions): Promise<EffectExecutionOutcome>;
/** Atomically admits a new effect before delegating ordinary append-only execution. */
export declare function executePreparedEffect(recordValue: PreparedEffectRecord, options: ExecutePreparedEffectOptions): Promise<EffectExecutionOutcome>;
export {};
//# sourceMappingURL=effectExecution.d.ts.map