import type { Stop } from './types.js';
export type EventCatalog<State> = Record<string, (draft: State, payload: any) => void>;
type EventPayload<Handler> = Handler extends (draft: any, payload: infer Payload) => void ? Payload : never;
export interface RecordedEvent {
    readonly sequence: number;
    readonly type: string;
    readonly payload: unknown;
    readonly eventId: string;
    readonly occurredAt: number;
    readonly actor?: string;
    readonly schemaVersion: number;
    readonly previousHash: string;
    readonly hash: string;
}
export interface EventDomain<State, Events extends EventCatalog<State>> {
    read(): Readonly<State>;
    emit<Name extends keyof Events & string>(name: Name, payload: EventPayload<Events[Name]>, meta?: {
        actor?: string;
        eventId?: string;
    }): Promise<RecordedEvent>;
    replay(events: readonly RecordedEvent[]): void;
    log(): readonly RecordedEvent[];
    watch(listener: (event: RecordedEvent, state: Readonly<State>) => void): Stop;
    compact(): {
        state: State;
        sequence: number;
        hash: string;
    };
}
export declare function forgeEventDomain<State extends object, Events extends EventCatalog<State>>(seed: State | (() => State), events: Events, options?: {
    readonly schemaVersion?: number;
    readonly validate?: (state: unknown) => state is State;
    readonly migrateEvent?: (event: RecordedEvent, targetVersion: number) => RecordedEvent;
    readonly clock?: () => number;
    readonly identify?: () => string;
}): EventDomain<State, Events>;
export {};
//# sourceMappingURL=events.d.ts.map