@arts-n-crafts/ts 3.15.0 → 3.17.0

package/packages/v4/dist/index.d.ts

@@ -0,0 +1,575 @@
+interface BaseMetadata {
+    /** Correlates a flow across services (end-to-end). */
+    correlationId?: string;
+    /** Points to the immediate cause (often previous message id). */
+    causationId?: string;
+    /** Trace identifier for distributed tracing. */
+    traceId?: string;
+    /** Schema version of this event's metadata/payload. */
+    schemaVersion?: number;
+    /** Tenant identifier for multi-tenant systems. */
+    tenantId?: string;
+    /** Actor or user responsible for the change. */
+    userId?: string;
+    /** Marker: domain events originate internally. */
+    /**
+     * Producer identifier. Prefer your service name, e.g., "orders-service".
+     */
+    source?: string;
+    /** Room for additive extensions. */
+    [key: string]: unknown;
+}
+
+type WithIdentifier<T = object> = {
+    id: string;
+} & T;
+
+interface CommandMetadata extends BaseMetadata {
+}
+interface Command<TType = string, TPayload = unknown> extends WithIdentifier {
+    /** Unique command id. */
+    id: string;
+    /** Command type, e.g., "CreateOrder". */
+    type: TType;
+    /** Target aggregate type (optional; may be inferred). */
+    aggregateType?: string;
+    /** Target aggregate id (optional for create commands). */
+    aggregateId?: string;
+    /** Business intent payload. */
+    payload: TPayload;
+    /** When the command was issued. */
+    timestamp: number;
+    /** Expected aggregate version for optimistic concurrency. */
+    expectedVersion?: number;
+    /** Optional metadata. */
+    metadata?: Partial<CommandMetadata>;
+    /** Discriminator for the message intent. */
+    kind: 'command';
+}
+
+interface CommandHandler<CommandType extends Command, TReturnType = Promise<void>> {
+    execute(aCommand: CommandType): TReturnType;
+}
+
+/**
+ * Domain events are internal, immutable, state-changing facts appended to the
+ * aggregate event stream (event sourcing). They do not leave the bounded
+ * context directly; map them to IntegrationEvents when publishing externally.
+ */
+interface DomainEventMetadata extends BaseMetadata {
+}
+interface DomainEvent<TPayload = unknown> {
+    /** Unique id for this domain event. */
+    id: string;
+    /** Event type, e.g., "OrderCreated". */
+    type: string;
+    /** Aggregate type, e.g., "Order". */
+    aggregateType: string;
+    /** Aggregate id. */
+    aggregateId: string;
+    /** Event payload (state change details). */
+    payload: TPayload;
+    /**
+     * Event time in epoch milliseconds (internal consistency for ES and sorting).
+     * Prefer number internally; convert to ISO for outbound messages.
+     */
+    timestamp: number;
+    /** Optional metadata; keep it small and stable. */
+    metadata: Partial<DomainEventMetadata>;
+    /** Discriminator for the message intent. */
+    kind: 'domain';
+}
+
+/**
+ * ISO 8601 datetime string, e.g., "2025-12-20T13:59:59.123Z".
+ */
+type ISODateTime = string;
+
+/**
+ * ExternalEvent is a fact emitted by another bounded context or third-party.
+ * Your service treats it as an immutable notification and may react to it
+ * (e.g., drive a saga or translate it into an internal Command).
+ */
+interface ExternalEventMetadata extends BaseMetadata {
+}
+interface ExternalEvent<TPayload = unknown> {
+    /** Producer-assigned id (treat as opaque). */
+    id: string;
+    /** External type, e.g., "PaymentSettled". */
+    type: string;
+    /** Event payload as produced by the external system. */
+    payload: TPayload;
+    /** ISO timestamp from the producer. */
+    timestamp: ISODateTime;
+    /** Optional metadata from the producer. */
+    metadata?: Partial<ExternalEventMetadata>;
+    /** Discriminator for the message intent. */
+    kind: 'external';
+}
+
+/**
+ * Integration events are the wire contract you publish externally (Kafka, audit,
+ * New Relic). The same envelope carries both accepted domain facts and rejected
+ * decisions. Keep the schema stable and evolve with schemaVersion.
+ */
+interface IntegrationEventMetadata extends BaseMetadata {
+    /** Outcome of the decision. */
+    outcome?: 'accepted' | 'rejected';
+    /** Correlation and routing fields. */
+    aggregateType?: string;
+    aggregateId?: string;
+    commandType?: string;
+    commandId?: string;
+    expectedVersion?: number;
+    currentVersion?: number;
+}
+interface IntegrationEvent<TPayload = unknown> {
+    /** Stable id for idempotency. */
+    id: string;
+    /** Event type, e.g., "OrderCreated" or "CreateOrderRejected". */
+    type: string;
+    /** Event payload. For rejections include reasonCode and related info. */
+    payload: TPayload;
+    /** ISO timestamp (external consistency). */
+    timestamp: ISODateTime;
+    /** Standardized, extensible metadata. */
+    metadata: Partial<IntegrationEventMetadata>;
+    /** Discriminator for the message intent. */
+    kind: 'integration';
+}
+
+interface Handling<TEvent extends DomainEvent | IntegrationEvent | ExternalEvent, TReturnType> {
+    handle(anEvent: TEvent): TReturnType;
+}
+interface EventHandler<TEvent extends DomainEvent | IntegrationEvent | ExternalEvent, TReturnType = Promise<void>> extends Handling<TEvent, TReturnType> {
+}
+
+type Module = Record<symbol, unknown>;
+
+interface QueryMetadata extends BaseMetadata {
+}
+interface Query<TType = string, TPayload = unknown> extends WithIdentifier {
+    type: TType;
+    payload: TPayload;
+    timestamp: number;
+    metadata: Partial<QueryMetadata>;
+    /** Discriminator for the message intent. */
+    kind: 'query';
+}
+
+interface QueryHandler<TQuery extends Query, TProjection = Promise<unknown>> {
+    execute(aQuery: TQuery): TProjection;
+}
+
+type FilledArray = [Record<string, unknown>, ...Record<string, unknown>[]];
+
+type Maybe<T> = T | null | undefined;
+
+type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};
+
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+
+/**
+ * UnixTimestamp in seconds since the Unix epoch.
+ * Example: 1734719999 (represents "2025-12-20T13:59:59Z")
+ *
+ * Usage (JavaScript/TypeScript):
+ * ```ts
+ * const now: UnixTimestampInSeconds = Math.floor(new Date().getTime() / 1000);
+ * ```
+ *
+ * Notes:
+ * - Prefer milliseconds for higher resolution; use seconds when interoperating
+ *   with systems/APIs that expect second precision.
+ */
+type UnixTimestampInSeconds = number;
+
+declare function createCommand<TType extends string, TPayload>(type: TType, aggregateId: string, aggregateType: string, payload: TPayload, metadata?: Partial<CommandMetadata>): Command<TType, TPayload>;
+
+declare function createQuery<TType extends string, TPayload>(type: TType, payload: TPayload, metadata?: QueryMetadata): Query<TType, TPayload>;
+
+declare const getTimestamp: (date?: Date) => number;
+
+declare function isCommand(candidate: unknown): candidate is Command<string, unknown>;
+
+declare function isQuery(candidate: unknown): candidate is Query<unknown>;
+
+interface Identifiable<TId> {
+    id: TId;
+}
+interface HasProperties<TProps extends object> {
+    props: TProps;
+}
+interface hasOutbox<TEvent extends DomainEvent> {
+    uncommittedEvents: TEvent[];
+}
+interface EventBased<TEvent extends DomainEvent> {
+    fromEvents(events: TEvent[]): void;
+}
+interface AggregateRoot<TId, TProps extends object, TEvent extends DomainEvent> extends Identifiable<TId>, HasProperties<TProps>, hasOutbox<TEvent> {
+    get id(): TId;
+    get props(): TProps;
+    get uncommittedEvents(): TEvent[];
+}
+interface EventBasedAggregateRoot<TId, TProps extends object, TEvent extends DomainEvent> extends AggregateRoot<TId, TProps, TEvent>, EventBased<TEvent> {
+}
+
+/**
+ * Rejection models a failed command decision. It is NOT part of the aggregate
+ * event stream. Persist via an outbox/inbox if you need durability and emit an
+ * IntegrationEvent with outcome="rejected" for external consumers.
+ */
+interface RejectionMetadata extends BaseMetadata {
+}
+interface Rejection<TDetails = unknown> {
+    /** Unique id; derive from commandId if possible for dedupe. */
+    id: string;
+    /** Rejection type, format e.g., "{commandType}Rejected", "{commandType}Failed". Example "CreateUserRejected" */
+    type: string;
+    /** Discriminator for the message intent. */
+    kind: 'rejection';
+    /** Aggregate type when known (for correlation). */
+    aggregateType?: string;
+    /** Aggregate id when known (for correlation/partitioning). */
+    aggregateId?: string;
+    /** The command that was rejected. */
+    commandId: string;
+    /** The command type, e.g., "CreateOrder". */
+    commandType: string;
+    /** Short machine-readable code, e.g., "VERSION_CONFLICT", "VALIDATION_FAILED". */
+    reasonCode: string | 'VERSION_CONFLICT' | 'VALIDATION_FAILED';
+    /** Human-readable summary (avoid PII if externalized). */
+    reason?: string;
+    /** Classification for routing/metrics. */
+    classification?: 'business' | 'validation' | 'concurrency' | 'technical';
+    /** Hint to infra/ops whether retry makes sense. */
+    retryable?: boolean;
+    /** Structured details specific to this rejection. */
+    details?: TDetails;
+    /**
+     * Only for VALIDATION_FAILED: list of field-level errors.
+     */
+    validationErrors?: Array<{
+        field?: string;
+        code: string;
+        message?: string;
+    }>;
+    /** ISO timestamp for external consistency. */
+    timestamp: number;
+    /** Optional metadata (trace/correlation/tenant). */
+    metadata?: RejectionMetadata;
+}
+
+interface Decider<TState, TCommand, TEvent extends DomainEvent, TRejection extends Rejection> {
+    decide(this: void, command: TCommand, currentState: TState): (TEvent | TRejection)[];
+    evolve(this: void, currentState: TState, event: TEvent): TState;
+    initialState(this: void, id: string): TState;
+}
+
+interface Loadable$1<TReturnType> {
+    load(aggregateId: string): TReturnType;
+}
+interface Storable<TEvent, TReturnType = Promise<void>> {
+    store(events: TEvent[]): TReturnType;
+}
+interface Repository<TEvent, TLoadReturnType, TStoreReturnType = Promise<void>> extends Loadable$1<TLoadReturnType>, Storable<TEvent, TStoreReturnType> {
+    readonly streamName: string;
+}
+
+type QueryNode = {
+    type: 'eq' | 'gt' | 'lt';
+    field: string | number | symbol;
+    value: Primitive;
+} | {
+    type: 'and' | 'or';
+    nodes: QueryNode[];
+} | {
+    type: 'not';
+    node: QueryNode;
+};
+
+interface Specification<T> {
+    isSatisfiedBy(entity: T): boolean;
+}
+declare abstract class CompositeSpecification<T> implements Specification<T> {
+    abstract isSatisfiedBy(entity: T): boolean;
+    abstract toQuery(): QueryNode;
+    and(other: CompositeSpecification<T>): CompositeSpecification<T>;
+    or(other: CompositeSpecification<T>): CompositeSpecification<T>;
+    not(): CompositeSpecification<T>;
+}
+declare class AndSpecification<T> extends CompositeSpecification<T> {
+    private left;
+    private right;
+    constructor(left: CompositeSpecification<T>, right: CompositeSpecification<T>);
+    isSatisfiedBy(entity: T): boolean;
+    toQuery(): QueryNode;
+}
+declare class OrSpecification<T> extends CompositeSpecification<T> {
+    private left;
+    private right;
+    constructor(left: CompositeSpecification<T>, right: CompositeSpecification<T>);
+    isSatisfiedBy(entity: T): boolean;
+    toQuery(): QueryNode;
+}
+declare class NotSpecification<T> extends CompositeSpecification<T> {
+    private spec;
+    constructor(spec: CompositeSpecification<T>);
+    isSatisfiedBy(entity: T): boolean;
+    toQuery(): QueryNode;
+}
+
+declare class FieldEquals<T> extends CompositeSpecification<T> {
+    private field;
+    private value;
+    constructor(field: keyof T, value: Primitive);
+    isSatisfiedBy(entity: T): boolean;
+    toQuery(): QueryNode;
+}
+
+declare class FieldGreaterThan<T> extends CompositeSpecification<T> {
+    private field;
+    private value;
+    constructor(field: keyof T, value: number);
+    private isNumber;
+    isSatisfiedBy(entity: T): boolean;
+    toQuery(): QueryNode;
+}
+
+declare function createQueryNode(type: 'eq' | 'gt' | 'lt', field: string | number | symbol, value: Primitive): QueryNode;
+declare function createQueryNode(type: 'and' | 'or', field: undefined, value: QueryNode[]): QueryNode;
+declare function createQueryNode(type: 'not', field: undefined, value: QueryNode): QueryNode;
+
+declare function createDomainEvent<TPayload = unknown>(type: string, aggregateId: string, aggregateType: string, payload: TPayload, metadata?: Partial<DomainEventMetadata>): DomainEvent<TPayload>;
+
+declare function createRejection<TDetails = unknown>(rejectionSpecifics: {
+    commandId: Rejection['commandId'];
+    commandType: Rejection['commandType'];
+    reasonCode: Rejection['reasonCode'];
+    reason?: Rejection['reason'];
+    aggregateType?: Rejection['aggregateType'];
+    aggregateId?: Rejection['aggregateId'];
+    classification: Rejection['classification'];
+    retryable?: Rejection['retryable'];
+    validationErrors?: Rejection['validationErrors'];
+    type: 'Failed' | 'Rejected' | string;
+    details?: TDetails;
+}, metadata?: Partial<RejectionMetadata>): Rejection<TDetails>;
+
+declare function isDomainEvent(event: unknown): event is DomainEvent;
+
+declare function isEvent(event: unknown): event is DomainEvent | IntegrationEvent | ExternalEvent | Rejection;
+
+interface Registerable$1<TCommand extends Command, TResult = void> {
+    register(aTypeOfCommand: TCommand['type'], anHandler: CommandHandler<TCommand>): TResult;
+}
+interface Executable$3<TCommand extends Command, TResult = Promise<void>> {
+    execute(aCommand: TCommand): TResult;
+}
+interface CommandBus<TCommand extends Command, TExecutionResult = Promise<void>, TRegisterResult = void> extends Executable$3<TCommand, TExecutionResult>, Registerable$1<TCommand, TRegisterResult> {
+}
+
+declare class SimpleCommandBus<TCommand extends Command> implements CommandBus<TCommand> {
+    private handlers;
+    register(aTypeOfCommand: TCommand['type'], anHandler: CommandHandler<TCommand>): void;
+    execute(aCommand: TCommand): Promise<void>;
+}
+
+declare enum Operation {
+    CREATE = "CREATE",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
+}
+interface Statement<TModel> {
+    operation: Operation;
+    payload: TModel;
+}
+interface CreateStatement<TModel> extends Statement<TModel> {
+    operation: Operation.CREATE;
+    payload: TModel;
+}
+interface PutStatement<TModel> extends Statement<TModel> {
+    operation: Operation.PUT;
+    payload: TModel;
+}
+interface PatchStatement<TModel> extends Statement<Partial<TModel>> {
+    operation: Operation.PATCH;
+    payload: WithIdentifier<Partial<TModel>>;
+}
+interface DeleteStatement extends Statement<WithIdentifier> {
+    operation: Operation.DELETE;
+    payload: WithIdentifier;
+}
+interface Executable$2<TModel, TReturnType = Promise<void>> {
+    execute(tableName: string, statement: CreateStatement<TModel>): TReturnType;
+    execute(tableName: string, statement: PutStatement<TModel>): TReturnType;
+    execute(tableName: string, statement: PatchStatement<TModel>): TReturnType;
+    execute(tableName: string, statement: DeleteStatement): TReturnType;
+}
+interface QueryAble<TModel, TReturnType = Promise<TModel[]>> {
+    query(collectionName: string, specification: CompositeSpecification<TModel>): TReturnType;
+}
+interface Database<TModel, TExecuteReturnType = Promise<void>, TQueryReturnType = Promise<TModel[]>> extends QueryAble<TModel, TQueryReturnType>, Executable$2<TModel, TExecuteReturnType> {
+}
+
+declare class SimpleDatabase<TModel extends WithIdentifier> implements Database<TModel, Promise<void>, Promise<TModel[]>> {
+    private readonly datasource;
+    private simulateOffline;
+    query(tableName: string, specification: CompositeSpecification<TModel>): Promise<TModel[]>;
+    execute(tableName: string, statement: CreateStatement<TModel> | PutStatement<TModel> | PatchStatement<TModel> | DeleteStatement): Promise<void>;
+    goOffline(): void;
+}
+
+interface Executable$1<TInput, TResult> {
+    execute(input: TInput): TResult;
+}
+interface Directive<TInput, TResult = void> extends Executable$1<TInput, TResult> {
+}
+
+interface EventProducer<TEvent extends DomainEvent | IntegrationEvent | ExternalEvent, TReturnType = Promise<void>> {
+    publish(stream: string, anEvent: TEvent): TReturnType;
+}
+interface EventConsumer<TEvent extends DomainEvent | IntegrationEvent | ExternalEvent, TEventHandler = EventHandler<TEvent>, TConsumeReturnType = Promise<void>, TSubscribeReturnType = void> {
+    subscribe(stream: string, handler: TEventHandler): TSubscribeReturnType;
+    consume(stream: string, anEvent: TEvent): TConsumeReturnType;
+}
+
+declare class SimpleEventBus<TEvent extends DomainEvent | IntegrationEvent | ExternalEvent> implements EventConsumer<TEvent>, EventProducer<TEvent> {
+    private handlers;
+    subscribe(stream: string, aHandler: EventHandler<TEvent>): void;
+    consume(stream: string, anEvent: TEvent): Promise<void>;
+    publish(stream: string, anEvent: TEvent): Promise<void>;
+}
+
+declare function createIntegrationEvent<TPayload = unknown>(type: string, payload: TPayload, metadata?: Partial<IntegrationEventMetadata>): IntegrationEvent<TPayload>;
+
+declare function isIntegrationEvent<TPayload>(event: unknown): event is IntegrationEvent<TPayload>;
+
+type StreamKey = `${string}#${string}`;
+
+/**
+ * StoredEvent wraps a DomainEvent for persistence in the event store with its
+ * stream coordinates and version. This table must be immutable, append-only.
+ */
+interface StoredEvent<TEvent> {
+    /** Same as DomainEvent.id. */
+    id: string;
+    /** Stream key, e.g., `${aggregateType}#${aggregateId}`. */
+    streamKey: StreamKey;
+    /** Aggregate version after applying this event. */
+    version: number;
+    /** Epoch millis for write-time ordering. */
+    timestamp: number;
+    /** The actual domain event. */
+    event: TEvent;
+}
+
+interface Loadable<TEvent, TReturnType = Promise<StoredEvent<TEvent>>> {
+    load(streamName: string, aggregateId: string): TReturnType;
+}
+interface Appendable<TEvent, TReturnType = Promise<void>> {
+    append(streamName: string, events: TEvent[]): TReturnType;
+}
+interface EventStore<TEvent, TAppendReturnType = Promise<void>, TLoadReturnType = Promise<TEvent[]>> extends Loadable<TEvent, TLoadReturnType>, Appendable<TEvent, TAppendReturnType> {
+}
+
+interface OutboxEntry {
+    id: string;
+    event: DomainEvent;
+    published: boolean;
+    retryCount: number;
+    lastAttemptAt?: number;
+}
+
+interface Queueable<TReturnType = Promise<void>> {
+    enqueue(event: OutboxEntry['event']): TReturnType;
+}
+interface Outbox<TEnqueueReturnType = Promise<void>, TGetPendingReturnType = Promise<OutboxEntry[]>, TMarkAsPublishedReturnType = Promise<void>, TMarkAsFailedReturnType = Promise<void>> extends Queueable<TEnqueueReturnType> {
+    getPending(limit?: number): TGetPendingReturnType;
+    markAsPublished(id: string): TMarkAsPublishedReturnType;
+    markAsFailed(id: string): TMarkAsFailedReturnType;
+}
+
+declare class SimpleEventStore<TEvent extends DomainEvent> implements EventStore<TEvent, Promise<void>, Promise<TEvent[]>> {
+    private readonly database;
+    private readonly outbox?;
+    private readonly tableName;
+    constructor(database: Database<StoredEvent<TEvent>, Promise<void>, Promise<StoredEvent<TEvent>[]>>, outbox?: Outbox | undefined);
+    load(streamName: string, aggregateId: string): Promise<TEvent[]>;
+    append(streamName: string, events: TEvent[]): Promise<void>;
+}
+
+declare function createStoredEvent<TEvent extends DomainEvent>(streamName: string, version: number, event: TEvent): StoredEvent<TEvent>;
+
+interface Runnable<TReturnType = Promise<void>> {
+    runOnce(): TReturnType;
+}
+interface Tickable<TReturnType = Promise<void>> {
+    tick(): TReturnType;
+}
+interface Startable<TReturnType = void> {
+    start(intervalMs: number): TReturnType;
+}
+interface OutboxWorker extends Runnable, Tickable, Startable {
+}
+
+declare class GenericOutboxWorker implements OutboxWorker {
+    protected outbox: Outbox;
+    protected eventBus: EventProducer<DomainEvent | IntegrationEvent | ExternalEvent>;
+    protected stream: string;
+    constructor(outbox: Outbox, eventBus: EventProducer<DomainEvent | IntegrationEvent | ExternalEvent>, stream: string);
+    runOnce(): Promise<void>;
+    tick(): Promise<void>;
+    start(intervalMs: number): void;
+}
+
+declare class InMemoryOutbox implements Outbox {
+    protected entries: OutboxEntry[];
+    protected idCounter: number;
+    enqueue(event: DomainEvent<unknown>): Promise<void>;
+    getPending(limit?: number): Promise<OutboxEntry[]>;
+    markAsPublished(id: string): Promise<void>;
+    markAsFailed(id: string): Promise<void>;
+}
+
+declare function createOutboxEntry(event: DomainEvent<unknown>): OutboxEntry;
+
+interface Registerable<TQuery extends Query, TResult = void> {
+    register(aTypeOfQuery: TQuery['type'], anHandler: QueryHandler<TQuery>): TResult;
+}
+interface Executable<TQuery extends Query, TResult = Promise<unknown>> {
+    execute(aQuery: TQuery): TResult;
+}
+interface QueryBus<TQuery extends Query, TExecutionResult, TRegisterResult = void> extends Executable<TQuery, TExecutionResult>, Registerable<TQuery, TRegisterResult> {
+}
+
+declare class SimpleQueryBus<TQuery extends Query, TProjection> implements QueryBus<TQuery, Promise<TProjection>> {
+    private handlers;
+    register(aTypeOfQuery: TQuery['type'], anHandler: QueryHandler<TQuery, Promise<TProjection>>): void;
+    execute(aQuery: TQuery): Promise<TProjection>;
+}
+
+declare class SimpleRepository<TState, TCommand, TEvent extends DomainEvent, TRejection extends Rejection> implements Repository<TEvent, Promise<TState>, Promise<void>> {
+    private readonly eventStore;
+    readonly streamName: string;
+    private readonly evolveFn;
+    private readonly initialState;
+    constructor(eventStore: EventStore<TEvent, Promise<void>, Promise<TEvent[]>>, streamName: string, evolveFn: Decider<TState, TCommand, TEvent, TRejection>['evolve'], initialState: Decider<TState, TCommand, TEvent, TRejection>['initialState']);
+    load(aggregateId: string): Promise<TState>;
+    store(events: TEvent[]): Promise<void>;
+}
+
+declare function fail(anExpression: Error): () => never;
+
+declare function invariant(condition: boolean, onInvalid: () => never): asserts condition;
+
+declare function isEqual<T>(a: T, b: T): boolean;
+
+declare function parseAsError(value: unknown): Error;
+
+declare function makeStreamKey(streamName: string, aggregateId: string): StreamKey;
+
+export { type AggregateRoot, AndSpecification, type BaseMetadata, type Command, type CommandBus, type CommandHandler, type CommandMetadata, CompositeSpecification, type CreateStatement, type Database, type Decider, type DeleteStatement, type Directive, type DomainEvent, type DomainEventMetadata, type EventBasedAggregateRoot, type EventConsumer, type EventHandler, type EventProducer, type EventStore, FieldEquals, FieldGreaterThan, type FilledArray, GenericOutboxWorker, type ISODateTime, InMemoryOutbox, type IntegrationEvent, type IntegrationEventMetadata, type Maybe, type Module, NotSpecification, type Nullable, Operation, OrSpecification, type Outbox, type OutboxEntry, type OutboxWorker, type PatchStatement, type Primitive, type PutStatement, type Query, type QueryBus, type QueryHandler, type QueryMetadata, type QueryNode, type Rejection, type RejectionMetadata, type Repository, SimpleCommandBus, SimpleDatabase, SimpleEventBus, SimpleEventStore, SimpleQueryBus, SimpleRepository, type Specification, type StoredEvent, type StreamKey, type UnixTimestampInSeconds, type WithIdentifier, createCommand, createDomainEvent, createIntegrationEvent, createOutboxEntry, createQuery, createQueryNode, createRejection, createStoredEvent, fail, getTimestamp, invariant, isCommand, isDomainEvent, isEqual, isEvent, isIntegrationEvent, isQuery, makeStreamKey, parseAsError };