import type { ActionCaller, ActionRunContext } from "./action.js";
export declare const ACTION_RECEIPT_SCHEMA_VERSION: "1";
export declare const DOMAIN_EVENT_SPEC_VERSION: "1.0";
export declare const DOMAIN_EVENT_CONTENT_TYPE: "application/json";
export type ActionJsonPrimitive = string | number | boolean | null;
export type ActionJsonValue = ActionJsonPrimitive | ActionJsonValue[] | {
    [key: string]: ActionJsonValue;
};
/** A CloudEvents 1.0-compatible event owned by the action that changed data. */
export interface ActionDomainEvent<TData extends ActionJsonValue = ActionJsonValue> {
    specversion: typeof DOMAIN_EVENT_SPEC_VERSION;
    id: string;
    source: string;
    type: string;
    time: string;
    subject?: string;
    datacontenttype: typeof DOMAIN_EVENT_CONTENT_TYPE;
    data: TData;
}
export interface ActionDomainEventDraft<TData extends ActionJsonValue = ActionJsonValue> {
    type: string;
    data: TData;
    source?: string;
    subject?: string;
    id?: string;
    time?: string;
}
export interface ActionDomainEventReference {
    id: string;
    source: string;
    type: string;
    time: string;
    subject?: string;
}
export interface ActionReceiptProvenance {
    caller: ActionCaller;
    appId?: string;
    orgId?: string;
    runId?: string;
    threadId?: string;
    turnId?: string;
    toolCallId?: string;
    correlationId?: string;
    causationId?: string;
    idempotencyKey?: string;
}
/**
 * Proof that an action mutation and its staged domain events committed together.
 * A failed or rolled-back transaction throws and must never produce this shape.
 */
export interface ActionReceipt<TResult extends ActionJsonValue = ActionJsonValue> {
    schemaVersion: typeof ACTION_RECEIPT_SCHEMA_VERSION;
    receiptId: string;
    action: string;
    status: "committed";
    committedAt: string;
    provenance: ActionReceiptProvenance;
    result: TResult;
    events: ActionDomainEventReference[];
}
export interface ActionAtomicAdapter<TTransaction> {
    transaction<T>(operation: (transaction: TTransaction) => Promise<T>): Promise<T>;
    /** Stage the receipt and events durably using this transaction. Do not publish here. */
    stageActionOutcome(transaction: TTransaction, outcome: ActionAtomicOutcome): Promise<void>;
}
export interface ActionAtomicOutcome<TResult extends ActionJsonValue = ActionJsonValue> {
    receipt: ActionReceipt<TResult>;
    events: readonly ActionDomainEvent[];
}
export interface ActionAtomicContext<TTransaction, TEventData extends ActionJsonValue = ActionJsonValue> {
    transaction: TTransaction;
    emit(event: ActionDomainEventDraft<TEventData>): void;
}
export interface CommitActionOptions<TTransaction, TResult extends ActionJsonValue, TEventData extends ActionJsonValue = ActionJsonValue> {
    adapter: ActionAtomicAdapter<TTransaction>;
    action: string;
    source: string;
    context?: ActionRunContext;
    correlationId?: string;
    causationId?: string;
    idempotencyKey?: string;
    now?: () => Date;
    idFactory?: () => string;
    mutate(context: ActionAtomicContext<TTransaction, TEventData>): Promise<TResult> | TResult;
}
export declare class ActionReceiptValidationError extends TypeError {
    constructor(message: string);
}
/**
 * Execute one mutation and stage all emitted events in the same transaction.
 * The committed receipt is returned only after the adapter confirms commit.
 */
export declare function commitAction<TTransaction, TResult extends ActionJsonValue, TEventData extends ActionJsonValue = ActionJsonValue>(options: CommitActionOptions<TTransaction, TResult, TEventData>): Promise<ActionReceipt<TResult>>;
export declare function createActionDomainEvent<TData extends ActionJsonValue>(draft: ActionDomainEventDraft<TData>, options: {
    source: string;
    now?: () => Date;
    idFactory?: () => string;
}): ActionDomainEvent<TData>;
export declare function assertActionDomainEvent(value: unknown): asserts value is ActionDomainEvent;
export declare function assertActionReceipt(value: unknown): asserts value is ActionReceipt;
export declare function serializeActionReceipt(receipt: ActionReceipt): string;
export declare function parseActionReceipt(serialized: string): ActionReceipt;
export declare function serializeActionDomainEvent(event: ActionDomainEvent): string;
export declare function parseActionDomainEvent(serialized: string): ActionDomainEvent;