@event-driven-io/emmett 0.17.0 → 0.18.0

package/dist/index.d.mts

@@ -1,24 +1,484 @@
-export { CommandHandler, CommandHandlerResult } from './commandHandling/handleCommand.mjs';
-export { DeciderCommandHandler } from './commandHandling/handleCommandWithDecider.mjs';
-export { ConcurrencyError, EmmettError, ErrorConstructor, IllegalStateError, NotFoundError, ValidationError, isErrorConstructor } from './errors/index.mjs';
-export { A as AggregateStreamOptions, b as AggregateStreamResult, c as AppendToStreamOptions, d as AppendToStreamResult, D as DefaultStreamVersionType, E as EventStore, e as ExpectedStreamVersion, g as ExpectedStreamVersionGeneral, f as ExpectedStreamVersionWithValue, j as ExpectedVersionConflictError, N as NO_CONCURRENCY_CHECK, R as ReadStreamOptions, a as ReadStreamResult, h as STREAM_DOES_NOT_EXIST, S as STREAM_EXISTS, i as assertExpectedVersionMatchesCurrent, m as matchesExpectedVersion } from './eventStore-CdmvM2NC.mjs';
-export { EventHandler, getInMemoryEventStore } from './eventStore/inMemoryEventStore.mjs';
-export { CommandBus, CommandProcessor, CommandSender, EventBus, EventProcessor, EventsPublisher, MessageBus, MessageHandler, MessageProcessor, MessageScheduler, ScheduleOptions, ScheduledMessage, ScheduledMessageProcessor, getInMemoryMessageBus } from './messageBus/index.mjs';
-export { ProjectionDefinition, ProjectionHandler, ProjectionHandlingType, ProjectionRegistration, TypedProjectionDefinition, asyncProjections, inlineProjections, projection, projections } from './projections/index.mjs';
-export { JSONParser, Mapper, MapperArgs, ParseError, ParseOptions, StringifyOptions } from './serialization/json/JSONParser.mjs';
-export { concatUint8Arrays } from './streaming/binaryArrays.mjs';
-export { collectStream } from './streaming/collect.mjs';
-export { BinaryJsonDecoder, CompositeDecoder, Decoder, DefaultDecoder, JsonDecoder, ObjectDecoder, StringDecoder } from './streaming/decoders/index.mjs';
-export { restream } from './streaming/restream.mjs';
-export { ArgumentMatcher, AssertionError, MockedFunction, argMatches, argValue, assertDeepEqual, assertEqual, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEqual, assertOk, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, isSubset, verifyThat } from './testing/assertions.mjs';
-export { DeciderSpecfication, DeciderSpecification, ThenThrows } from './testing/deciderSpecification.mjs';
-export { TestEventStream, WrapEventStore } from './testing/wrapEventStore.mjs';
-export { Brand, CanHandle, Command, CommandDataOf, CommandMetaDataOf, CommandTypeOf, CreateCommandType, CreateEventType, Decider, DefaultCommandMetadata, DefaultRecord, Event, EventDataOf, EventMetaDataOf, EventTypeOf, Flavour, ReadEvent, ReadEventMetadata, ReadEventMetadataWithGlobalPosition, Workflow, WorkflowCommand, WorkflowEvent, WorkflowOutput, accept, command, complete, error, event, ignore, publish, reply, schedule, send } from './typing/index.mjs';
-export { Equatable, deepEquals, isEquatable } from './utils/deepEquals.mjs';
-export { sum } from './utils/iterators.mjs';
-export { merge } from './utils/merge.mjs';
-export { ValidationErrors, assertNotEmptyString, assertPositiveNumber, assertUnsignedBigInt, isNumber, isString } from './validation/index.mjs';
-export { DeepReadonly, Mutable } from './typing/deepReadonly.mjs';
-export { formatDateToUtcYYYYMMDD, isValidYYYYMMDD, parseDateFromUtcYYYYMMDD } from './validation/dates.mjs';
-import 'web-streams-polyfill';
-import 'async-retry';
+import { ReadableStream } from 'web-streams-polyfill';
+import retry from 'async-retry';
+
+type Primitive = undefined | null | boolean | string | number | bigint | symbol | Function;
+type ImmutableTypes = Date | RegExp;
+type DeepReadonly<T> = T extends Primitive | ImmutableTypes ? T : T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer M> ? ReadonlySet<DeepReadonly<M>> : T extends Promise<infer U> ? Promise<DeepReadonly<U>> : T extends object ? DeepReadonlyObject<T> : Readonly<T>;
+type DeepReadonlyObject<T> = {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+};
+type Mutable<T> = T extends Primitive ? T : T extends ReadonlyArray<infer U> ? MutableArray<U> : T extends ReadonlyMap<infer K, infer V> ? MutableMap<K, V> : T extends ReadonlySet<infer M> ? MutableSet<M> : T extends Function ? T : T extends object ? MutableObject<T> : unknown;
+type MutableArray<T> = Array<Mutable<T>>;
+type MutableMap<K, V> = Map<Mutable<K>, Mutable<V>>;
+type MutableSet<T> = Set<Mutable<T>>;
+type MutableObject<T> = {
+    -readonly [P in keyof T]: Mutable<T[P]>;
+};
+
+type Command<CommandType extends string = string, CommandData extends DefaultRecord = DefaultRecord, CommandMetaData extends DefaultRecord = DefaultCommandMetadata> = Flavour<Readonly<{
+    type: CommandType;
+    data: Readonly<CommandData>;
+    metadata?: CommandMetaData | undefined;
+}>, 'Command'>;
+type CommandTypeOf<T extends Command> = T['type'];
+type CommandDataOf<T extends Command> = T['data'];
+type CommandMetaDataOf<T extends Command> = T['metadata'];
+type CreateCommandType<CommandType extends string, CommandData extends DefaultRecord, CommandMetaData extends DefaultRecord | undefined> = Readonly<{
+    type: CommandType;
+    data: CommandData;
+    metadata?: CommandMetaData;
+}>;
+declare const command: <CommandType extends Command>(type: CommandTypeOf<CommandType>, data: CommandDataOf<CommandType>, metadata?: CommandMetaDataOf<CommandType>) => CreateCommandType<CommandTypeOf<CommandType>, CommandDataOf<CommandType>, CommandMetaDataOf<CommandType>>;
+type DefaultCommandMetadata = {
+    now: Date;
+};
+
+type Event<EventType extends string = string, EventData extends DefaultRecord = DefaultRecord, EventMetaData extends DefaultRecord = DefaultRecord> = Flavour<Readonly<{
+    type: EventType;
+    data: EventData;
+    metadata?: EventMetaData;
+}>, 'Event'>;
+type EventTypeOf<T extends Event> = T['type'];
+type EventDataOf<T extends Event> = T['data'];
+type EventMetaDataOf<T extends Event> = T['metadata'];
+type CanHandle<T extends Event> = EventTypeOf<T>[];
+type CreateEventType<EventType extends string, EventData extends DefaultRecord, EventMetaData extends DefaultRecord | undefined> = Readonly<{
+    type: EventType;
+    data: EventData;
+    metadata?: EventMetaData;
+}>;
+declare const event: <EventType extends Event>(type: EventTypeOf<EventType>, data: EventDataOf<EventType>, metadata?: EventMetaDataOf<EventType>) => CreateEventType<EventTypeOf<EventType>, EventDataOf<EventType>, EventMetaDataOf<EventType>>;
+type ReadEvent<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata> = CreateEventType<EventTypeOf<EventType>, EventDataOf<EventType>, EventMetaDataType> & EventType & {
+    metadata: EventMetaDataType;
+};
+type ReadEventMetadata = Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}>;
+type ReadEventMetadataWithGlobalPosition = ReadEventMetadata & {
+    globalPosition: bigint;
+};
+
+type Decider<State, CommandType extends Command, StreamEvent extends Event> = {
+    decide: (command: CommandType, state: State) => StreamEvent | StreamEvent[];
+    evolve: (currentState: State, event: StreamEvent) => State;
+    initialState: () => State;
+};
+
+type Workflow<Input extends Event | Command, State, Output extends Event | Command> = {
+    decide: (command: Input, state: State) => WorkflowOutput<Output>[];
+    evolve: (currentState: State, event: WorkflowEvent<Output>) => State;
+    initialState: () => State;
+};
+type WorkflowEvent<Output extends Command | Event> = Extract<Output, {
+    __brand?: 'Event';
+}>;
+type WorkflowCommand<Output extends Command | Event> = Extract<Output, {
+    __brand?: 'Command';
+}>;
+type WorkflowOutput<TOutput extends Command | Event> = {
+    kind: 'Reply';
+    message: TOutput;
+} | {
+    kind: 'Send';
+    message: WorkflowCommand<TOutput>;
+} | {
+    kind: 'Publish';
+    message: WorkflowEvent<TOutput>;
+} | {
+    kind: 'Schedule';
+    message: TOutput;
+    when: {
+        afterInMs: number;
+    } | {
+        at: Date;
+    };
+} | {
+    kind: 'Complete';
+} | {
+    kind: 'Accept';
+} | {
+    kind: 'Ignore';
+    reason: string;
+} | {
+    kind: 'Error';
+    reason: string;
+};
+declare const reply: <TOutput extends Command | Event>(message: TOutput) => WorkflowOutput<TOutput>;
+declare const send: <TOutput extends Command | Event>(message: WorkflowCommand<TOutput>) => WorkflowOutput<TOutput>;
+declare const publish: <TOutput extends Command | Event>(message: WorkflowEvent<TOutput>) => WorkflowOutput<TOutput>;
+declare const schedule: <TOutput extends Command | Event>(message: TOutput, when: {
+    afterInMs: number;
+} | {
+    at: Date;
+}) => WorkflowOutput<TOutput>;
+declare const complete: <TOutput extends Command | Event>() => WorkflowOutput<TOutput>;
+declare const ignore: <TOutput extends Command | Event>(reason: string) => WorkflowOutput<TOutput>;
+declare const error: <TOutput extends Command | Event>(reason: string) => WorkflowOutput<TOutput>;
+declare const accept: <TOutput extends Command | Event>() => WorkflowOutput<TOutput>;
+
+type Brand<K, T> = K & {
+    readonly __brand: T;
+};
+type Flavour<K, T> = K & {
+    readonly __brand?: T;
+};
+type DefaultRecord = Record<string, unknown>;
+
+type ErrorConstructor<ErrorType extends Error> = new (...args: any[]) => ErrorType;
+declare const isErrorConstructor: <ErrorType extends Error>(expect: Function) => expect is ErrorConstructor<ErrorType>;
+declare class EmmettError extends Error {
+    errorCode: number;
+    constructor(options?: {
+        errorCode: number;
+        message?: string;
+    } | string | number);
+}
+declare class ConcurrencyError extends EmmettError {
+    current: string | undefined;
+    expected: string;
+    constructor(current: string | undefined, expected: string, message?: string);
+}
+declare class ValidationError extends EmmettError {
+    constructor(message?: string);
+}
+declare class IllegalStateError extends EmmettError {
+    constructor(message?: string);
+}
+declare class NotFoundError extends EmmettError {
+    constructor(options?: {
+        id: string;
+        type: string;
+        message?: string;
+    });
+}
+
+type ExpectedStreamVersion<VersionType = DefaultStreamVersionType> = ExpectedStreamVersionWithValue<VersionType> | ExpectedStreamVersionGeneral;
+type ExpectedStreamVersionWithValue<VersionType = DefaultStreamVersionType> = Flavour<VersionType, 'StreamVersion'>;
+type ExpectedStreamVersionGeneral = Flavour<'STREAM_EXISTS' | 'STREAM_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK', 'StreamVersion'>;
+declare const STREAM_EXISTS: ExpectedStreamVersionGeneral;
+declare const STREAM_DOES_NOT_EXIST: ExpectedStreamVersionGeneral;
+declare const NO_CONCURRENCY_CHECK: ExpectedStreamVersionGeneral;
+declare const matchesExpectedVersion: <StreamVersion = bigint>(current: StreamVersion | undefined, expected: ExpectedStreamVersion<StreamVersion>) => boolean;
+declare const assertExpectedVersionMatchesCurrent: <StreamVersion = bigint>(current: StreamVersion | undefined, expected: ExpectedStreamVersion<StreamVersion> | undefined) => void;
+declare class ExpectedVersionConflictError<VersionType = DefaultStreamVersionType> extends ConcurrencyError {
+    constructor(current: VersionType | undefined, expected: ExpectedStreamVersion<VersionType>);
+}
+
+interface EventStore<StreamVersion = DefaultStreamVersionType, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> {
+    aggregateStream<State, EventType extends Event>(streamName: string, options: AggregateStreamOptions<State, EventType, StreamVersion, ReadEventMetadataType>): Promise<AggregateStreamResult<State, StreamVersion> | null>;
+    readStream<EventType extends Event>(streamName: string, options?: ReadStreamOptions<StreamVersion>): Promise<ReadStreamResult<EventType, StreamVersion, ReadEventMetadataType>>;
+    appendToStream<EventType extends Event>(streamName: string, events: EventType[], options?: AppendToStreamOptions<StreamVersion>): Promise<AppendToStreamResult<StreamVersion>>;
+}
+type EventStoreSession<EventStoreType extends EventStore<StreamVersion>, StreamVersion = DefaultStreamVersionType> = {
+    eventStore: EventStoreType;
+    close: () => Promise<void>;
+};
+interface EventStoreSessionFactory<EventStoreType extends EventStore<StreamVersion>, StreamVersion = DefaultStreamVersionType> {
+    withSession<T = unknown>(callback: (session: EventStoreSession<EventStoreType, StreamVersion>) => Promise<T>): Promise<T>;
+}
+type DefaultStreamVersionType = bigint;
+declare const canCreateEventStoreSession: <Store extends EventStore<StreamVersion>, StreamVersion = bigint>(eventStore: Store | EventStoreSessionFactory<Store, StreamVersion>) => eventStore is EventStoreSessionFactory<Store, StreamVersion>;
+declare const nulloSessionFactory: <EventStoreType extends EventStore<StreamVersion>, StreamVersion = bigint>(eventStore: EventStoreType) => EventStoreSessionFactory<EventStoreType, StreamVersion>;
+type ReadStreamOptions<StreamVersion = DefaultStreamVersionType> = ({
+    from: StreamVersion;
+} | {
+    to: StreamVersion;
+} | {
+    from: StreamVersion;
+    maxCount?: bigint;
+} | {
+    expectedStreamVersion: ExpectedStreamVersion<StreamVersion>;
+}) & {
+    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
+};
+type ReadStreamResult<EventType extends Event, StreamVersion = DefaultStreamVersionType, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> = {
+    currentStreamVersion: StreamVersion;
+    events: ReadEvent<EventType, ReadEventMetadataType>[];
+} | null;
+type Evolve<State, EventType extends Event, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> = ((currentState: State, event: EventType) => State) | ((currentState: State, event: ReadEvent<EventType, ReadEventMetadataType>) => State) | ((currentState: State, event: ReadEvent<EventType>) => State);
+type AggregateStreamOptions<State, EventType extends Event, StreamVersion = DefaultStreamVersionType, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> = {
+    evolve: Evolve<State, EventType, ReadEventMetadataType>;
+    initialState: () => State;
+    read?: ReadStreamOptions<StreamVersion>;
+};
+type AggregateStreamResult<State, StreamVersion = DefaultStreamVersionType> = {
+    currentStreamVersion: StreamVersion;
+    state: State;
+};
+type AppendToStreamOptions<StreamVersion = DefaultStreamVersionType> = {
+    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
+};
+type AppendToStreamResult<StreamVersion = DefaultStreamVersionType> = {
+    nextExpectedStreamVersion: StreamVersion;
+};
+
+type EventHandler$1<E extends Event = Event> = (eventEnvelope: ReadEvent<E>) => void;
+declare const getInMemoryEventStore: () => EventStore<DefaultStreamVersionType, ReadEventMetadataWithGlobalPosition>;
+
+type CommandHandlerResult<State, StreamEvent extends Event, StreamVersion = DefaultStreamVersionType> = AppendToStreamResult<StreamVersion> & {
+    newState: State;
+    newEvents: StreamEvent[];
+};
+declare const CommandHandler$1: <State, StreamEvent extends Event, StreamVersion = bigint>(evolve: (state: State, event: StreamEvent) => State, initialState: () => State, mapToStreamId?: (id: string) => string) => <Store extends EventStore<StreamVersion>>(store: Store, id: string, handle: (state: State) => StreamEvent | StreamEvent[], options?: Parameters<Store["appendToStream"]>[2] & {
+    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
+}) => Promise<CommandHandlerResult<State, StreamEvent, StreamVersion>>;
+
+declare const DeciderCommandHandler: <State, CommandType extends Command, StreamEvent extends Event, StreamVersion = bigint>({ decide, evolve, initialState }: Decider<State, CommandType, StreamEvent>, mapToStreamId?: (id: string) => string) => (eventStore: EventStore<StreamVersion>, id: string, command: CommandType, options?: {
+    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
+}) => Promise<CommandHandlerResult<State, StreamEvent, StreamVersion>>;
+
+interface CommandSender {
+    send<CommandType extends Command = Command>(command: CommandType): Promise<void>;
+}
+interface EventsPublisher {
+    publish<EventType extends Event = Event>(event: EventType): Promise<void>;
+}
+type ScheduleOptions = {
+    afterInMs: number;
+} | {
+    at: Date;
+};
+interface MessageScheduler<CommandOrEvent extends Command | Event> {
+    schedule<MessageType extends CommandOrEvent>(message: MessageType, when?: ScheduleOptions): void;
+}
+interface CommandBus extends CommandSender, MessageScheduler<Command> {
+}
+interface EventBus extends EventsPublisher, MessageScheduler<Event> {
+}
+interface MessageBus extends CommandBus, EventBus {
+    schedule<MessageType extends Command | Event>(message: MessageType, when?: ScheduleOptions): void;
+}
+type CommandHandler<CommandType extends Command = Command> = (command: CommandType) => Promise<void> | void;
+interface CommandProcessor {
+    handle<CommandType extends Command>(commandHandler: CommandHandler<CommandType>, ...commandTypes: CommandTypeOf<CommandType>[]): void;
+}
+type EventHandler<EventType extends Event = Event> = (event: EventType) => Promise<void> | void;
+interface EventProcessor {
+    subscribe<EventType extends Event>(eventHandler: EventHandler<EventType>, ...eventTypes: EventTypeOf<EventType>[]): void;
+}
+type ScheduledMessage = {
+    message: Event | Command;
+    options?: ScheduleOptions;
+};
+interface ScheduledMessageProcessor {
+    dequeue(): ScheduledMessage[];
+}
+type MessageHandler = CommandHandler | EventHandler;
+type MessageProcessor = EventProcessor | CommandProcessor;
+declare const getInMemoryMessageBus: () => MessageBus & EventProcessor & CommandProcessor & ScheduledMessageProcessor;
+
+type ProjectionHandlingType = 'inline' | 'async';
+type ProjectionHandler<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord> = (events: ReadEvent<EventType, EventMetaDataType>[], context: ProjectionHandlerContext) => Promise<void> | void;
+interface ProjectionDefinition<ProjectionHandlerContext extends DefaultRecord = DefaultRecord> {
+    name?: string;
+    canHandle: CanHandle<Event>;
+    handle: ProjectionHandler<Event, ReadEventMetadata, ProjectionHandlerContext>;
+}
+interface TypedProjectionDefinition<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord> {
+    name?: string;
+    canHandle: CanHandle<EventType>;
+    handle: ProjectionHandler<EventType, EventMetaDataType, ProjectionHandlerContext>;
+}
+type ProjectionRegistration<HandlingType extends ProjectionHandlingType, ProjectionHandlerContext extends DefaultRecord = DefaultRecord> = {
+    type: HandlingType;
+    projection: ProjectionDefinition<ProjectionHandlerContext>;
+};
+declare const projection: <EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}>, ProjectionHandlerContext extends DefaultRecord = DefaultRecord, ProjectionDefintionType extends TypedProjectionDefinition<EventType, EventMetaDataType, ProjectionHandlerContext> = ProjectionDefinition<ProjectionHandlerContext>>(definition: ProjectionDefintionType) => ProjectionDefintionType;
+declare const inlineProjections: <ProjectionHandlerContext extends DefaultRecord = DefaultRecord, ProjectionDefintionType extends ProjectionDefinition<ProjectionHandlerContext> = ProjectionDefinition<ProjectionHandlerContext>>(definitions: ProjectionDefintionType[]) => ProjectionRegistration<"inline", ProjectionHandlerContext>[];
+declare const asyncProjections: <ProjectionHandlerContext extends DefaultRecord = DefaultRecord, ProjectionDefintionType extends ProjectionDefinition<ProjectionHandlerContext> = ProjectionDefinition<ProjectionHandlerContext>>(definitions: ProjectionDefintionType[]) => ProjectionRegistration<"async", ProjectionHandlerContext>[];
+declare const projections: {
+    inline: <ProjectionHandlerContext extends DefaultRecord = DefaultRecord, ProjectionDefintionType extends ProjectionDefinition<ProjectionHandlerContext> = ProjectionDefinition<ProjectionHandlerContext>>(definitions: ProjectionDefintionType[]) => ProjectionRegistration<"inline", ProjectionHandlerContext>[];
+    async: <ProjectionHandlerContext extends DefaultRecord = DefaultRecord, ProjectionDefintionType extends ProjectionDefinition<ProjectionHandlerContext> = ProjectionDefinition<ProjectionHandlerContext>>(definitions: ProjectionDefintionType[]) => ProjectionRegistration<"async", ProjectionHandlerContext>[];
+};
+
+declare class ParseError extends Error {
+    constructor(text: string);
+}
+type Mapper<From, To = From> = ((value: unknown) => To) | ((value: Partial<From>) => To) | ((value: From) => To) | ((value: Partial<To>) => To) | ((value: To) => To) | ((value: Partial<To | From>) => To) | ((value: To | From) => To);
+type MapperArgs<From, To = From> = Partial<From> & From & Partial<To> & To;
+type ParseOptions<From, To = From> = {
+    reviver?: (key: string, value: unknown) => unknown;
+    map?: Mapper<From, To>;
+    typeCheck?: <To>(value: unknown) => value is To;
+};
+type StringifyOptions<From, To = From> = {
+    map?: Mapper<From, To>;
+};
+declare const JSONParser: {
+    stringify: <From, To = From>(value: From, options?: StringifyOptions<From, To>) => string;
+    parse: <From, To = From>(text: string, options?: ParseOptions<From, To>) => To | undefined;
+};
+
+declare const concatUint8Arrays: (chunks: Uint8Array[]) => Uint8Array;
+
+declare const collectStream: <T>(reader: ReadableStream<T>) => Promise<T[]>;
+
+declare class BinaryJsonDecoder<Decoded> implements Decoder<Uint8Array, Decoded> {
+    private buffer;
+    addToBuffer(data: Uint8Array): void;
+    clearBuffer(): void;
+    hasCompleteMessage(): boolean;
+    decode(): Decoded | null;
+}
+
+declare class CompositeDecoder<Decoded> implements Decoder<unknown, Decoded> {
+    private decoders;
+    constructor(decoders: [(data: unknown) => boolean, Decoder<unknown, Decoded>][]);
+    private decoderFor;
+    addToBuffer(data: unknown): void;
+    clearBuffer(): void;
+    hasCompleteMessage(): boolean;
+    decode(): Decoded | null;
+}
+declare class DefaultDecoder<Decoded> extends CompositeDecoder<Decoded> {
+    constructor();
+}
+
+declare class StringDecoder<Decoded> implements Decoder<string, Decoded> {
+    private transform;
+    protected buffer: string[];
+    constructor(transform: (input: string) => Decoded);
+    addToBuffer(data: string): void;
+    clearBuffer(): void;
+    hasCompleteMessage(): boolean;
+    decode(): Decoded | null;
+}
+
+declare class JsonDecoder<Decoded> extends StringDecoder<Decoded> {
+    constructor();
+}
+
+declare class ObjectDecoder<Decoded> implements Decoder<Decoded, Decoded> {
+    private buffer;
+    addToBuffer(data: Decoded): void;
+    clearBuffer(): void;
+    hasCompleteMessage(): boolean;
+    decode(): Decoded | null;
+}
+
+interface Decoder<Source = unknown, Decoded = DefaultRecord> {
+    addToBuffer(data: Source): void;
+    decode(): Decoded | null;
+    clearBuffer(): void;
+    hasCompleteMessage(): boolean;
+}
+
+declare const restream: <Source = unknown, Transformed = Source, StreamType = object>(createSourceStream: () => ReadableStream<StreamType>, transform?: (input: Source) => Transformed, retryOptions?: retry.Options, decoder?: Decoder<StreamType, Source>) => ReadableStream<Transformed>;
+
+declare class AssertionError extends Error {
+    constructor(message: string);
+}
+declare const isSubset: (superObj: unknown, subObj: unknown) => boolean;
+declare const assertFails: (message?: string) => never;
+declare const assertThrowsAsync: <TError extends Error>(fun: () => Promise<void>, errorCheck?: (error: Error) => boolean) => Promise<TError>;
+declare const assertThrows: <TError extends Error>(fun: () => void, errorCheck?: (error: Error) => boolean) => TError;
+declare const assertMatches: (actual: unknown, expected: unknown, message?: string) => void;
+declare const assertDeepEqual: <T = unknown>(actual: T, expected: T, message?: string) => void;
+declare const assertNotDeepEqual: <T = unknown>(actual: T, expected: T, message?: string) => void;
+declare const assertThat: <T>(item: T) => {
+    isEqualTo: (other: T) => void;
+};
+declare function assertFalse(condition: boolean, message?: string): asserts condition is false;
+declare function assertTrue(condition: boolean, message?: string): asserts condition is true;
+declare function assertOk<T>(obj: T | null | undefined, message?: string): asserts obj is T;
+declare function assertEqual<T>(expected: T | null | undefined, actual: T | null | undefined, message?: string): void;
+declare function assertNotEqual<T>(obj: T | null | undefined, other: T | null | undefined, message?: string): void;
+declare function assertIsNotNull<T extends object | bigint>(result: T | null): asserts result is T;
+declare function assertIsNull<T extends object>(result: T | null): asserts result is null;
+type Call = {
+    arguments: unknown[];
+    result: unknown;
+    target: unknown;
+    this: unknown;
+};
+type ArgumentMatcher = (arg: unknown) => boolean;
+declare const argValue: <T>(value: T) => ArgumentMatcher;
+declare const argMatches: <T>(matches: (arg: T) => boolean) => ArgumentMatcher;
+type MockedFunction = Function & {
+    mock?: {
+        calls: Call[];
+    };
+};
+declare function verifyThat(fn: MockedFunction): {
+    calledTimes: (times: number) => void;
+    notCalled: () => void;
+    called: () => void;
+    calledWith: (...args: unknown[]) => void;
+    calledOnceWith: (...args: unknown[]) => void;
+    calledWithArgumentMatching: (...matches: ArgumentMatcher[]) => void;
+    notCalledWithArgumentMatching: (...matches: ArgumentMatcher[]) => void;
+};
+declare const assertThatArray: <T>(array: T[]) => {
+    isEmpty: () => void;
+    isNotEmpty: () => void;
+    hasSize: (length: number) => void;
+    containsElements: (...other: T[]) => void;
+    containsExactlyInAnyOrder: (...other: T[]) => void;
+    containsExactlyInAnyOrderElementsOf: (other: T[]) => void;
+    containsExactlyElementsOf: (other: T[]) => void;
+    containsExactly: (elem: T) => void;
+    contains: (elem: T) => void;
+    containsOnlyOnceElementsOf: (other: T[]) => void;
+    containsAnyOf: (...other: T[]) => void;
+    allMatch: (matches: (item: T) => boolean) => void;
+    anyMatches: (matches: (item: T) => boolean) => void;
+    allMatchAsync: (matches: (item: T) => Promise<boolean>) => Promise<void>;
+};
+
+type ErrorCheck<ErrorType> = (error: ErrorType) => boolean;
+type ThenThrows<ErrorType extends Error> = (() => void) | ((errorConstructor: ErrorConstructor<ErrorType>) => void) | ((errorCheck: ErrorCheck<ErrorType>) => void) | ((errorConstructor: ErrorConstructor<ErrorType>, errorCheck?: ErrorCheck<ErrorType>) => void);
+type DeciderSpecfication<Command, Event> = (givenEvents: Event | Event[]) => {
+    when: (command: Command) => {
+        then: (expectedEvents: Event | Event[]) => void;
+        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => void;
+    };
+};
+declare const DeciderSpecification: {
+    for: <Command, Event, State>(decider: {
+        decide: (command: Command, state: State) => Event | Event[];
+        evolve: (state: State, event: Event) => State;
+        initialState: () => State;
+    }) => DeciderSpecfication<Command, Event>;
+};
+
+type TestEventStream<EventType extends Event = Event> = [
+    string,
+    EventType[]
+];
+declare const WrapEventStore: <StreamVersion = bigint>(eventStore: EventStore<StreamVersion>) => EventStore<StreamVersion> & {
+    appendedEvents: Map<string, TestEventStream>;
+    setup<EventType extends Event>(streamName: string, events: EventType[]): Promise<AppendToStreamResult<StreamVersion>>;
+};
+
+declare const deepEquals: <T>(left: T, right: T) => boolean;
+type Equatable<T> = {
+    equals: (right: T) => boolean;
+} & T;
+declare const isEquatable: <T>(left: T) => left is Equatable<T>;
+
+declare const sum: (iterator: Iterator<number, number, number> | Iterator<number>) => number;
+
+declare const merge: <T>(array: T[], item: T, where: (current: T) => boolean, onExisting: (current: T) => T, onNotFound?: () => T | undefined) => T[];
+
+declare const formatDateToUtcYYYYMMDD: (date: Date) => string;
+declare const isValidYYYYMMDD: (dateString: string) => boolean;
+declare const parseDateFromUtcYYYYMMDD: (dateString: string) => Date;
+
+declare const enum ValidationErrors {
+    NOT_A_NONEMPTY_STRING = "NOT_A_NONEMPTY_STRING",
+    NOT_A_POSITIVE_NUMBER = "NOT_A_POSITIVE_NUMBER",
+    NOT_AN_UNSIGNED_BIGINT = "NOT_AN_UNSIGNED_BIGINT"
+}
+declare const isNumber: (val: unknown) => val is number;
+declare const isString: (val: unknown) => val is string;
+declare const assertNotEmptyString: (value: unknown) => string;
+declare const assertPositiveNumber: (value: unknown) => number;
+declare const assertUnsignedBigInt: (value: string) => bigint;
+
+export { type AggregateStreamOptions, type AggregateStreamResult, type AppendToStreamOptions, type AppendToStreamResult, type ArgumentMatcher, AssertionError, BinaryJsonDecoder, type Brand, type CanHandle, type Command, type CommandBus, type CommandDataOf, CommandHandler$1 as CommandHandler, type CommandHandlerResult, type CommandMetaDataOf, type CommandProcessor, type CommandSender, type CommandTypeOf, CompositeDecoder, ConcurrencyError, type CreateCommandType, type CreateEventType, type Decider, DeciderCommandHandler, type DeciderSpecfication, DeciderSpecification, type Decoder, type DeepReadonly, type DefaultCommandMetadata, DefaultDecoder, type DefaultRecord, type DefaultStreamVersionType, EmmettError, type Equatable, type ErrorConstructor, type Event, type EventBus, type EventDataOf, type EventHandler$1 as EventHandler, type EventMetaDataOf, type EventProcessor, type EventStore, type EventStoreSession, type EventStoreSessionFactory, type EventTypeOf, type EventsPublisher, type ExpectedStreamVersion, type ExpectedStreamVersionGeneral, type ExpectedStreamVersionWithValue, ExpectedVersionConflictError, type Flavour, IllegalStateError, JSONParser, JsonDecoder, type Mapper, type MapperArgs, type MessageBus, type MessageHandler, type MessageProcessor, type MessageScheduler, type MockedFunction, type Mutable, NO_CONCURRENCY_CHECK, NotFoundError, ObjectDecoder, ParseError, type ParseOptions, type ProjectionDefinition, type ProjectionHandler, type ProjectionHandlingType, type ProjectionRegistration, type ReadEvent, type ReadEventMetadata, type ReadEventMetadataWithGlobalPosition, type ReadStreamOptions, type ReadStreamResult, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, type ScheduleOptions, type ScheduledMessage, type ScheduledMessageProcessor, StringDecoder, type StringifyOptions, type TestEventStream, type ThenThrows, type TypedProjectionDefinition, ValidationError, ValidationErrors, type Workflow, type WorkflowCommand, type WorkflowEvent, type WorkflowOutput, WrapEventStore, accept, argMatches, argValue, assertDeepEqual, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEmptyString, assertNotEqual, assertOk, assertPositiveNumber, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, assertUnsignedBigInt, asyncProjections, canCreateEventStoreSession, collectStream, command, complete, concatUint8Arrays, deepEquals, error, event, formatDateToUtcYYYYMMDD, getInMemoryEventStore, getInMemoryMessageBus, ignore, inlineProjections, isEquatable, isErrorConstructor, isNumber, isString, isSubset, isValidYYYYMMDD, matchesExpectedVersion, merge, nulloSessionFactory, parseDateFromUtcYYYYMMDD, projection, projections, publish, reply, restream, schedule, send, sum, verifyThat };