import type { StatePatch } from './patches.js';
export type Awaitable<T> = T | Promise<T>;
export type Equality<T> = (left: T, right: T) => boolean;
export type Recipe<State> = (draft: State) => void;
export type Stop = () => void;
export type NotificationPriority = 'immediate' | 'interactive' | 'background';
export interface CommandContext<State> {
    readonly signal: AbortSignal;
    readonly commandId: string;
    readonly actor?: string;
    readonly tags: Readonly<Record<string, string>>;
    read(): Readonly<State>;
    edit(recipe: Recipe<State>): void;
}
export type CommandHandler<State, Payload = void, Result = void> = (context: CommandContext<State>, payload: Payload) => Awaitable<Result>;
export type CommandCatalog<State> = Record<string, CommandHandler<State, any, any>>;
export type PayloadOf<Handler> = Handler extends CommandHandler<any, infer Payload, any> ? Payload : never;
export type ResultOf<Handler> = Handler extends CommandHandler<any, any, infer Result> ? Awaited<Result> : never;
export interface RunMeta {
    actor?: string;
    tags?: Readonly<Record<string, string>>;
    signal?: AbortSignal;
    priority?: NotificationPriority;
    deadlineMs?: number;
    idempotencyKey?: string;
}
export interface DomainEvent<State> {
    readonly revision: number;
    readonly command: string;
    readonly commandId: string;
    readonly actor?: string;
    readonly tags: Readonly<Record<string, string>>;
    readonly startedAt: number;
    readonly finishedAt: number;
    readonly previous: Readonly<State>;
    readonly current: Readonly<State>;
    readonly patches: readonly StatePatch[];
}
export interface AuditEntry {
    readonly revision: number;
    readonly command: string;
    readonly commandId: string;
    readonly actor?: string;
    readonly startedAt: number;
    readonly finishedAt: number;
    readonly durationMs: number;
    readonly status: 'committed' | 'rejected';
    readonly message?: string;
    readonly tags: Readonly<Record<string, string>>;
    readonly patchCount: number;
    readonly previousHash: string;
    readonly hash: string;
}
export interface CommandEnvelope {
    readonly name: string;
    readonly payload: unknown;
    readonly commandId: string;
    readonly actor?: string;
    readonly tags: Readonly<Record<string, string>>;
    readonly startedAt: number;
}
export interface DomainModule<State> {
    before?(envelope: CommandEnvelope, state: Readonly<State>): Awaitable<void>;
    after?(entry: AuditEntry, state: Readonly<State>): Awaitable<void>;
    fault?(entry: AuditEntry, error: unknown, state: Readonly<State>): Awaitable<void>;
}
export interface PolicyInput<State> {
    readonly command: string;
    readonly payload: unknown;
    readonly actor?: string;
    readonly tags: Readonly<Record<string, string>>;
    readonly state: Readonly<State>;
}
export type AccessPolicy<State> = (input: PolicyInput<State>) => Awaitable<boolean>;
export interface DomainOptions<State, Commands extends CommandCatalog<State>> {
    readonly name: string;
    readonly seed: State | (() => State);
    readonly commands: Commands;
    readonly modules?: readonly DomainModule<State>[];
    readonly policy?: AccessPolicy<State>;
    readonly invariants?: readonly ((state: Readonly<State>) => void)[];
    readonly historyLimit?: number;
    readonly auditLimit?: number;
    readonly clone?: (state: State) => State;
    readonly freeze?: boolean;
    readonly clock?: () => number;
    readonly identify?: () => string;
    readonly validate?: (state: unknown) => state is State;
    readonly onModuleFault?: (error: unknown, entry: AuditEntry) => void;
    readonly scheduleNotification?: (notify: () => void, priority: NotificationPriority) => void;
    readonly idempotencyLimit?: number;
}
export interface Checkpoint<State> {
    readonly domain: string;
    readonly revision: number;
    readonly createdAt: number;
    readonly state: State;
}
export interface CommandPreview<State, Result = unknown> {
    readonly ok: boolean;
    readonly command: string;
    readonly commandId: string;
    readonly actor?: string;
    readonly tags: Readonly<Record<string, string>>;
    readonly revision: number;
    readonly startedAt: number;
    readonly finishedAt: number;
    readonly previous: Readonly<State>;
    readonly current: Readonly<State>;
    readonly patches: readonly StatePatch[];
    readonly inversePatches: readonly StatePatch[];
    readonly result?: Result;
    readonly error?: unknown;
}
export interface AtomicScope<State, Commands extends CommandCatalog<State>> {
    read(): Readonly<State>;
    edit(recipe: Recipe<State>): void;
    invoke<Name extends keyof Commands & string>(name: Name, payload: PayloadOf<Commands[Name]>, meta?: RunMeta): Promise<ResultOf<Commands[Name]>>;
}
export interface Domain<State, Commands extends CommandCatalog<State>> {
    readonly name: string;
    read(): Readonly<State>;
    initial(): Readonly<State>;
    revision(): number;
    run<Name extends keyof Commands & string>(name: Name, payload: PayloadOf<Commands[Name]>, meta?: RunMeta): Promise<ResultOf<Commands[Name]>>;
    preview<Name extends keyof Commands & string>(name: Name, payload: PayloadOf<Commands[Name]>, meta?: RunMeta): Promise<CommandPreview<State, ResultOf<Commands[Name]>>>;
    atomic<Result>(label: string, operation: (scope: AtomicScope<State, Commands>) => Awaitable<Result>, meta?: RunMeta): Promise<Result>;
    watch(listener: (event: DomainEvent<State>) => void): Stop;
    watchSlice<Slice>(select: (state: Readonly<State>) => Slice, listener: (slice: Slice, previous: Slice, event: DomainEvent<State>) => void, equality?: Equality<Slice>, fireImmediately?: boolean): Stop;
    checkpoint(): Checkpoint<State>;
    restore(checkpoint: Checkpoint<State>, meta?: RunMeta): Promise<void>;
    rewind(steps?: number, meta?: RunMeta): Promise<void>;
    replace(next: State, label?: string, meta?: RunMeta): Promise<void>;
    speculate<Result>(label: string, recipe: Recipe<State>, effect: (signal: AbortSignal) => Awaitable<Result>, meta?: RunMeta): Promise<Result>;
    addModule(module: DomainModule<State>): Stop;
    injectCommand(name: string, handler: CommandHandler<State, unknown, unknown>): Stop;
    inspect(): DomainInspection;
    audit(): readonly AuditEntry[];
    dispose(): void;
}
export interface DerivedView<State, Value> {
    read(state: Readonly<State>): Value;
    clear(): void;
}
export interface DomainInspection {
    readonly revision: number;
    readonly queueDepth: number;
    readonly activeCommands: number;
    readonly listenerCount: number;
    readonly historyDepth: number;
    readonly auditDepth: number;
    readonly moduleCount: number;
}
//# sourceMappingURL=types.d.ts.map