import { a as EmmettError, C as ConcurrencyError, e as ErrorConstructor } from './index-Amos00J7.js';
export { l as ConcurrencyInMemoryDatabaseError, i as EmmettCliCommand, d as EmmettCliPlugin, g as EmmettCliPluginRegistration, c as EmmettPlugin, f as EmmettPluginConfig, h as EmmettPluginRegistration, b as EmmettPluginType, E as EmmettPluginsConfig, I as IllegalStateError, N as NotFoundError, V as ValidationError, k as isErrorConstructor, j as isPluginConfig } from './index-Amos00J7.js';
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 | undefined = undefined> = Readonly<CommandMetaData extends undefined ? {
    type: CommandType;
    data: Readonly<CommandData>;
    metadata?: DefaultCommandMetadata | undefined;
} : {
    type: CommandType;
    data: CommandData;
    metadata: CommandMetaData;
}> & {
    readonly kind?: 'Command';
};
type AnyCommand = Command<any, any, any>;
type CommandTypeOf<T extends Command> = T['type'];
type CommandDataOf<T extends Command> = T['data'];
type CommandMetaDataOf<T extends Command> = T extends {
    metadata: infer M;
} ? M : undefined;
type CreateCommandType<CommandType extends string, CommandData extends DefaultRecord, CommandMetaData extends DefaultRecord | undefined = undefined> = Readonly<CommandMetaData extends undefined ? {
    type: CommandType;
    data: CommandData;
    metadata?: DefaultCommandMetadata | undefined;
} : {
    type: CommandType;
    data: CommandData;
    metadata: CommandMetaData;
}> & {
    readonly kind?: 'Command';
};
declare const command: <CommandType extends Command<string, any, any>>(...args: CommandMetaDataOf<CommandType> extends undefined ? [type: CommandTypeOf<CommandType>, data: CommandDataOf<CommandType>, metadata?: DefaultCommandMetadata | undefined] : [type: CommandTypeOf<CommandType>, data: CommandDataOf<CommandType>, metadata: CommandMetaDataOf<CommandType>]) => CommandType;
type DefaultCommandMetadata = {
    now: Date;
};

type Message<Type extends string = string, Data extends DefaultRecord = DefaultRecord, MetaData extends DefaultRecord | undefined = undefined> = Command<Type, Data, MetaData> | Event<Type, Data, MetaData>;
type AnyMessage = AnyEvent | AnyCommand;
type MessageKindOf<T extends Message> = T['kind'];
type MessageTypeOf<T extends Message> = T['type'];
type MessageDataOf<T extends Message> = T['data'];
type MessageMetaDataOf<T extends Message> = T extends {
    metadata: infer M;
} ? M : undefined;
type CanHandle<T extends Message> = MessageTypeOf<T>[];
declare const message: <MessageType extends Message<string, any, any>>(...args: MessageMetaDataOf<MessageType> extends undefined ? [kind: MessageKindOf<MessageType>, type: MessageTypeOf<MessageType>, data: MessageDataOf<MessageType>] : [kind: MessageKindOf<MessageType>, type: MessageTypeOf<MessageType>, data: MessageDataOf<MessageType>, metadata: MessageMetaDataOf<MessageType>]) => MessageType;
type CombinedMessageMetadata<MessageType extends Message = Message, MessageMetaDataType extends DefaultRecord = DefaultRecord> = MessageMetaDataOf<MessageType> extends undefined ? MessageMetaDataType : MessageMetaDataOf<MessageType> & MessageMetaDataType;
type CombineMetadata<MessageType extends Message = Message, MessageMetaDataType extends DefaultRecord = DefaultRecord> = MessageType & {
    metadata: CombinedMessageMetadata<MessageType, MessageMetaDataType>;
};
type RecordedMessage<MessageType extends Message = Message, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata> = CombineMetadata<MessageType, MessageMetaDataType> & {
    kind: NonNullable<MessageKindOf<Message>>;
};
type CommonRecordedMessageMetadata<StreamPosition = BigIntStreamPosition> = Readonly<{
    messageId: string;
    streamPosition: StreamPosition;
    streamName: string;
}>;
type WithGlobalPosition<GlobalPosition> = Readonly<{
    globalPosition: GlobalPosition;
}>;
type RecordedMessageMetadata<GlobalPosition = undefined, StreamPosition = BigIntStreamPosition> = CommonRecordedMessageMetadata<StreamPosition> & (GlobalPosition extends undefined ? {} : WithGlobalPosition<GlobalPosition>);
type AnyRecordedMessage = Message<any, any, any>;
type AnyRecordedMessageMetadata = RecordedMessageMetadata<any, any>;
type RecordedMessageMetadataWithGlobalPosition<GlobalPosition = BigIntGlobalPosition> = RecordedMessageMetadata<GlobalPosition>;
type RecordedMessageMetadataWithoutGlobalPosition<StreamPosition = BigIntStreamPosition> = RecordedMessageMetadata<undefined, StreamPosition>;
type GlobalPositionTypeOfRecordedMessageMetadata<RecordedMessageMetadataType> = RecordedMessageMetadataType extends RecordedMessageMetadata<infer GP, any> ? GP : never;
type StreamPositionTypeOfRecordedMessageMetadata<RecordedMessageMetadataType> = RecordedMessageMetadataType extends RecordedMessageMetadata<any, infer SV> ? SV : never;

type BigIntStreamPosition = bigint;
type BigIntGlobalPosition = bigint;
type Event<EventType extends string = string, EventData extends DefaultRecord = DefaultRecord, EventMetaData extends DefaultRecord | undefined = undefined> = Readonly<EventMetaData extends undefined ? {
    type: EventType;
    data: EventData;
} : {
    type: EventType;
    data: EventData;
    metadata: EventMetaData;
}> & {
    readonly kind?: 'Event';
};
type AnyEvent = Event<any, any, any>;
type EventTypeOf<T extends Event> = T['type'];
type EventDataOf<T extends Event> = T['data'];
type EventMetaDataOf<T extends Event> = T extends {
    metadata: infer M;
} ? M : undefined;
type CreateEventType<EventType extends string, EventData extends DefaultRecord, EventMetaData extends DefaultRecord | undefined = undefined> = Readonly<EventMetaData extends undefined ? {
    type: EventType;
    data: EventData;
} : {
    type: EventType;
    data: EventData;
    metadata: EventMetaData;
}> & {
    readonly kind?: 'Event';
};
declare const event: <EventType extends Event<string, any, any>>(...args: EventMetaDataOf<EventType> extends undefined ? [type: EventTypeOf<EventType>, data: EventDataOf<EventType>] : [type: EventTypeOf<EventType>, data: EventDataOf<EventType>, metadata: EventMetaDataOf<EventType>]) => EventType;
type CombinedReadEventMetadata<EventType extends Event = Event, EventMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata> = CombinedMessageMetadata<EventType, EventMetaDataType>;
type ReadEvent<EventType extends Event = Event, EventMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata> = RecordedMessage<EventType, EventMetaDataType>;
type AnyReadEvent<EventMetaDataType extends AnyReadEventMetadata = AnyReadEventMetadata> = ReadEvent<AnyEvent, EventMetaDataType>;
type CommonReadEventMetadata<StreamPosition = BigIntStreamPosition> = CommonRecordedMessageMetadata<StreamPosition>;
type ReadEventMetadata<GlobalPosition = undefined, StreamPosition = BigIntStreamPosition> = RecordedMessageMetadata<GlobalPosition, StreamPosition>;
type AnyReadEventMetadata = AnyRecordedMessageMetadata;
type ReadEventMetadataWithGlobalPosition<GlobalPosition = BigIntGlobalPosition> = RecordedMessageMetadataWithGlobalPosition<GlobalPosition>;
type ReadEventMetadataWithoutGlobalPosition<StreamPosition = BigIntStreamPosition> = RecordedMessageMetadataWithoutGlobalPosition<StreamPosition>;
type GlobalPositionTypeOfReadEventMetadata<ReadEventMetadataType> = GlobalPositionTypeOfRecordedMessageMetadata<ReadEventMetadataType>;
type StreamPositionTypeOfReadEventMetadata<ReadEventMetadataType> = StreamPositionTypeOfRecordedMessageMetadata<ReadEventMetadataType>;

type SingleRawMessageHandlerWithoutContext<MessageType extends Message = AnyMessage> = (message: MessageType) => Promise<MessageHandlerResult> | MessageHandlerResult;
type SingleRecordedMessageHandlerWithoutContext<MessageType extends Message = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata> = (message: RecordedMessage<MessageType, MessageMetaDataType>) => Promise<MessageHandlerResult> | MessageHandlerResult;
type SingleMessageHandlerWithoutContext<MessageType extends AnyMessage = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = never> = SingleRawMessageHandlerWithoutContext<MessageType> | SingleRecordedMessageHandlerWithoutContext<MessageType, MessageMetaDataType>;
type SingleRawMessageHandlerWithContext<MessageType extends Message = AnyMessage, HandlerContext extends DefaultRecord | undefined = undefined> = (message: MessageType, context: HandlerContext) => Promise<MessageHandlerResult> | MessageHandlerResult;
type SingleRecordedMessageHandlerWithContext<MessageType extends Message = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends DefaultRecord | undefined = undefined> = (message: RecordedMessage<MessageType, MessageMetaDataType>, context: HandlerContext) => Promise<MessageHandlerResult> | MessageHandlerResult;
type SingleMessageHandlerWithContext<MessageType extends AnyMessage = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = never, HandlerContext extends DefaultRecord = DefaultRecord> = SingleRawMessageHandlerWithContext<MessageType, HandlerContext> | SingleRecordedMessageHandlerWithContext<MessageType, MessageMetaDataType, HandlerContext>;
type SingleMessageHandler<MessageType extends Message = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends DefaultRecord | undefined = undefined> = HandlerContext extends DefaultRecord ? SingleMessageHandlerWithContext<MessageType, MessageMetaDataType, HandlerContext> : SingleMessageHandlerWithoutContext<MessageType, MessageMetaDataType>;
type BatchRawMessageHandlerWithoutContext<MessageType extends Message = AnyMessage> = (messages: MessageType[]) => Promise<MessageHandlerResult> | MessageHandlerResult;
type BatchRecordedMessageHandlerWithoutContext<MessageType extends Message = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata> = (messages: RecordedMessage<MessageType, MessageMetaDataType>[]) => Promise<MessageHandlerResult> | MessageHandlerResult;
type BatchMessageHandlerWithoutContext<MessageType extends AnyMessage = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata> = BatchRawMessageHandlerWithoutContext<MessageType> | BatchRecordedMessageHandlerWithoutContext<MessageType, MessageMetaDataType>;
type BatchRawMessageHandlerWithContext<MessageType extends Message = AnyMessage, HandlerContext extends DefaultRecord | undefined = undefined> = (messages: MessageType[], context: HandlerContext) => Promise<MessageHandlerResult> | MessageHandlerResult;
type BatchRecordedMessageHandlerWithContext<MessageType extends Message = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends DefaultRecord = DefaultRecord> = (messages: RecordedMessage<MessageType, MessageMetaDataType>[], context: HandlerContext) => Promise<MessageHandlerResult> | MessageHandlerResult;
type BatchMessageHandlerWithContext<MessageType extends AnyMessage = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends DefaultRecord = DefaultRecord> = BatchRawMessageHandlerWithContext<MessageType, HandlerContext> | BatchRecordedMessageHandlerWithContext<MessageType, MessageMetaDataType, HandlerContext>;
type BatchMessageHandler<MessageType extends Message = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends DefaultRecord | undefined = undefined> = HandlerContext extends DefaultRecord ? BatchMessageHandlerWithContext<MessageType, MessageMetaDataType, HandlerContext> : BatchMessageHandlerWithoutContext<MessageType, MessageMetaDataType>;
type MessageHandler<MessageType extends Message = Message, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends DefaultRecord | undefined = undefined> = (HandlerContext extends DefaultRecord ? SingleMessageHandler<MessageType, MessageMetaDataType, HandlerContext> : SingleMessageHandler<MessageType, MessageMetaDataType>) | (HandlerContext extends DefaultRecord ? BatchMessageHandler<MessageType, MessageMetaDataType, HandlerContext> : BatchMessageHandler<MessageType, MessageMetaDataType>);
type MessageHandlerResult = void | {
    type: 'SKIP';
    reason?: string;
} | {
    type: 'STOP';
    reason?: string;
    error?: EmmettError;
};

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 AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand> = {
    decide: (command: Input, state: State) => WorkflowOutput<Output>[];
    evolve: (currentState: State, event: WorkflowEvent<Output>) => State;
    initialState: () => State;
};
type WorkflowEvent<Output extends AnyEvent | AnyCommand> = Extract<Output, {
    kind?: 'Event';
}>;
type WorkflowCommand<Output extends AnyEvent | AnyCommand> = Extract<Output, {
    kind?: 'Command';
}>;
type WorkflowOutput<TOutput extends AnyEvent | AnyCommand> = {
    action: 'Reply';
    message: TOutput;
} | {
    action: 'Send';
    message: WorkflowCommand<TOutput>;
} | {
    action: 'Publish';
    message: WorkflowEvent<TOutput>;
} | {
    action: 'Schedule';
    message: TOutput;
    when: {
        afterInMs: number;
    } | {
        at: Date;
    };
} | {
    action: 'Complete';
} | {
    action: 'Accept';
} | {
    action: 'Ignore';
    reason: string;
} | {
    action: 'Error';
    reason: string;
};
declare const reply: <TOutput extends AnyEvent | AnyCommand>(message: TOutput) => WorkflowOutput<TOutput>;
declare const send: <TOutput extends AnyEvent | AnyCommand>(message: WorkflowCommand<TOutput>) => WorkflowOutput<TOutput>;
declare const publish: <TOutput extends AnyEvent | AnyCommand>(message: WorkflowEvent<TOutput>) => WorkflowOutput<TOutput>;
declare const schedule: <TOutput extends AnyEvent | AnyCommand>(message: TOutput, when: {
    afterInMs: number;
} | {
    at: Date;
}) => WorkflowOutput<TOutput>;
declare const complete: <TOutput extends AnyEvent | AnyCommand>() => WorkflowOutput<TOutput>;
declare const ignore: <TOutput extends AnyEvent | AnyCommand>(reason: string) => WorkflowOutput<TOutput>;
declare const error: <TOutput extends AnyEvent | AnyCommand>(reason: string) => WorkflowOutput<TOutput>;
declare const accept: <TOutput extends AnyEvent | AnyCommand>() => WorkflowOutput<TOutput>;

type Brand<K, T> = K & {
    readonly __brand: T;
};
type Flavour<K, T> = K & {
    readonly __brand?: T;
};
type DefaultRecord = Record<string, unknown>;
type AnyRecord = Record<string, any>;
type NonNullable$1<T> = T extends null | undefined ? never : T;
declare const emmettPrefix = "emt";
declare const globalTag = "global";
declare const defaultTag = "emt:default";
declare const unknownTag = "emt:unknown";

type ExpectedStreamVersion<VersionType = BigIntStreamPosition> = ExpectedStreamVersionWithValue<VersionType> | ExpectedStreamVersionGeneral;
type ExpectedStreamVersionWithValue<VersionType = BigIntStreamPosition> = 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 = BigIntStreamPosition>(current: StreamVersion | undefined, expected: ExpectedStreamVersion<StreamVersion>, defaultVersion: StreamVersion) => boolean;
declare const assertExpectedVersionMatchesCurrent: <StreamVersion = BigIntStreamPosition>(current: StreamVersion, expected: ExpectedStreamVersion<StreamVersion> | undefined, defaultVersion: StreamVersion) => void;
declare class ExpectedVersionConflictError<VersionType = BigIntStreamPosition> extends ConcurrencyError {
    constructor(current: VersionType, expected: ExpectedStreamVersion<VersionType>);
}
declare const isExpectedVersionConflictError: (error: unknown) => error is ExpectedVersionConflictError;

interface EventStore<ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata> {
    aggregateStream<State, EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, options: AggregateStreamOptions<State, EventType, ReadEventMetadataType, EventPayloadType>): Promise<AggregateStreamResult<State, StreamPositionTypeOfReadEventMetadata<ReadEventMetadataType>>>;
    readStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, options?: ReadStreamOptions<StreamPositionTypeOfReadEventMetadata<ReadEventMetadataType>, EventType, EventPayloadType>): Promise<ReadStreamResult<EventType, ReadEventMetadataType>>;
    appendToStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, events: EventType[], options?: AppendToStreamOptions<StreamPositionTypeOfReadEventMetadata<ReadEventMetadataType>, EventType, EventPayloadType>): Promise<AppendToStreamResult<StreamPositionTypeOfReadEventMetadata<ReadEventMetadataType>>>;
    streamExists(streamName: string): Promise<StreamExistsResult>;
}
type EventStoreReadEventMetadata<Store extends EventStore> = Store extends EventStore<infer T> ? T extends CommonReadEventMetadata<infer SP> ? T extends WithGlobalPosition<infer GP> ? ReadEventMetadata<GP, SP> & T : ReadEventMetadata<undefined, SP> & T : never : never;
type GlobalPositionTypeOfEventStore<Store extends EventStore> = GlobalPositionTypeOfReadEventMetadata<EventStoreReadEventMetadata<Store>>;
type StreamPositionTypeOfEventStore<Store extends EventStore> = StreamPositionTypeOfReadEventMetadata<EventStoreReadEventMetadata<Store>>;
type EventStoreSession<EventStoreType extends EventStore> = {
    eventStore: EventStoreType;
    close: () => Promise<void>;
};
interface EventStoreSessionFactory<EventStoreType extends EventStore> {
    withSession<T = unknown>(callback: (session: EventStoreSession<EventStoreType>) => Promise<T>): Promise<T>;
}
declare const canCreateEventStoreSession: <Store extends EventStore>(eventStore: Store | EventStoreSessionFactory<Store>) => eventStore is EventStoreSessionFactory<Store>;
declare const nulloSessionFactory: <EventStoreType extends EventStore>(eventStore: EventStoreType) => EventStoreSessionFactory<EventStoreType>;
type EventStoreReadSchemaOptions<StreamEvent extends Event = Event, StoredEvent extends Event = StreamEvent> = {
    versioning?: {
        upcast?: (event: StoredEvent) => StreamEvent;
    };
};
type EventStoreAppendSchemaOptions<StreamEvent extends Event = Event, StoredEvent extends Event = StreamEvent> = {
    versioning?: {
        downcast?: (event: StreamEvent) => StoredEvent;
    };
};
type EventStoreSchemaOptions<StreamEvent extends Event = Event, StoredEvent extends Event = StreamEvent> = EventStoreReadSchemaOptions<StreamEvent, StoredEvent> & EventStoreAppendSchemaOptions<StreamEvent, StoredEvent>;
type ReadStreamOptions<StreamVersion = BigIntStreamPosition, EventType extends Event = Event, EventPayloadType extends Event = EventType> = {
    from?: StreamVersion;
    to?: StreamVersion;
    maxCount?: bigint;
    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
    schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
};
type ReadStreamResult<EventType extends Event, ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata> = {
    currentStreamVersion: StreamPositionTypeOfReadEventMetadata<ReadEventMetadataType>;
    events: ReadEvent<EventType, ReadEventMetadataType>[];
    streamExists: boolean;
};
type Evolve<State, EventType extends Event, ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata> = ((currentState: State, event: EventType) => State) | ((currentState: State, event: ReadEvent<EventType, ReadEventMetadataType>) => State) | ((currentState: State, event: ReadEvent<EventType>) => State);
type AggregateStreamOptions<State, EventType extends Event, ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, EventPayloadType extends Event = EventType> = {
    evolve: Evolve<State, EventType, ReadEventMetadataType>;
    initialState: () => State;
    read?: ReadStreamOptions<StreamPositionTypeOfReadEventMetadata<ReadEventMetadataType>, EventType, EventPayloadType>;
};
type AggregateStreamResult<State, StreamPosition = BigIntStreamPosition> = {
    currentStreamVersion: StreamPosition;
    state: State;
    streamExists: boolean;
};
type AggregateStreamResultWithGlobalPosition<State, StreamPosition = BigIntStreamPosition, GlobalPosition = BigIntGlobalPosition> = (AggregateStreamResult<State, StreamPosition> & {
    streamExists: true;
    lastEventGlobalPosition: GlobalPosition;
}) | (AggregateStreamResult<State, StreamPosition> & {
    streamExists: false;
});
type AggregateStreamResultOfEventStore<Store extends EventStore> = Store['aggregateStream'] extends (...args: any[]) => Promise<infer R> ? R : never;
type AppendToStreamOptions<StreamVersion = BigIntStreamPosition, EventType extends Event = Event, EventPayloadType extends Event = EventType> = {
    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
    schema?: EventStoreAppendSchemaOptions<EventType, EventPayloadType>;
};
type AppendToStreamResult<StreamVersion = BigIntStreamPosition> = {
    nextExpectedStreamVersion: StreamVersion;
    createdNewStream: boolean;
};
type AppendToStreamResultWithGlobalPosition<StreamVersion = BigIntStreamPosition, GlobalPosition = BigIntGlobalPosition> = AppendToStreamResult<StreamVersion> & {
    lastEventGlobalPosition: GlobalPosition;
};
type AppendStreamResultOfEventStore<Store extends EventStore> = Store['appendToStream'] extends (...args: any[]) => Promise<infer R> ? R : never;
type StreamExistsResult = boolean;
type DefaultEventStoreOptions<Store extends EventStore, HandlerContext extends DefaultRecord | undefined = undefined> = {
    /**
     * Pluggable set of hooks informing about the event store internal behaviour.
     */
    hooks?: {
        /**
         * This hook will be called **AFTER** events were stored in the event store.
         * It's designed to handle scenarios where delivery and ordering guarantees do not matter much.
         *
         * **WARNINGS:**
         *
         *  1. It will be called **EXACTLY ONCE** if append succeded.
         *  2. If the hook fails, its append **will still silently succeed**, and no error will be thrown.
         *  3. Wen process crashes after events were committed, but before the hook was called, delivery won't be retried.
         * That can lead to state inconsistencies.
         *  4. In the case of high concurrent traffic, **race conditions may cause ordering issues**.
         * For instance, where the second hook takes longer to process than the first one, ordering won't be guaranteed.
         *
         * @type {AfterEventStoreCommitHandler<Store, HandlerContext>}
         */
        onAfterCommit?: AfterEventStoreCommitHandler<Store, HandlerContext>;
    };
};

type AfterEventStoreCommitHandler<Store extends EventStore, HandlerContext extends DefaultRecord | undefined = undefined> = HandlerContext extends undefined ? BatchRecordedMessageHandlerWithoutContext<Event, EventStoreReadEventMetadata<Store>> : BatchRecordedMessageHandlerWithContext<Event, EventStoreReadEventMetadata<Store>, NonNullable<HandlerContext>>;
type BeforeEventStoreCommitHandler<Store extends EventStore, HandlerContext extends DefaultRecord | undefined = undefined> = HandlerContext extends undefined ? BatchRecordedMessageHandlerWithoutContext<Event, EventStoreReadEventMetadata<Store>> : BatchRecordedMessageHandlerWithContext<Event, EventStoreReadEventMetadata<Store>, NonNullable<HandlerContext>>;
type TryPublishMessagesAfterCommitOptions<Store extends EventStore, HandlerContext extends DefaultRecord | undefined = undefined> = {
    onAfterCommit?: AfterEventStoreCommitHandler<Store, HandlerContext>;
};
declare function tryPublishMessagesAfterCommit<Store extends EventStore>(messages: ReadEvent<Event, EventStoreReadEventMetadata<Store>>[], options: TryPublishMessagesAfterCommitOptions<Store, undefined> | undefined): Promise<boolean>;
declare function tryPublishMessagesAfterCommit<Store extends EventStore, HandlerContext extends DefaultRecord | undefined = undefined>(messages: ReadEvent<Event, EventStoreReadEventMetadata<Store>>[], options: TryPublishMessagesAfterCommitOptions<Store, HandlerContext> | undefined, context: HandlerContext): Promise<boolean>;

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;
}
interface CommandProcessor {
    handle<CommandType extends Command>(commandHandler: SingleMessageHandler<CommandType>, ...commandTypes: CommandTypeOf<CommandType>[]): void;
}
interface EventSubscription {
    subscribe<EventType extends Event>(eventHandler: SingleMessageHandler<EventType>, ...eventTypes: EventTypeOf<EventType>[]): void;
}
type ScheduledMessage = {
    message: Message;
    options?: ScheduleOptions;
};
interface ScheduledMessageProcessor {
    dequeue(): ScheduledMessage[];
}
type MessageSubscription = EventSubscription | CommandProcessor;
declare const getInMemoryMessageBus: () => MessageBus & EventSubscription & CommandProcessor & ScheduledMessageProcessor;

declare const forwardToMessageBus: <Store extends EventStore, HandlerContext extends DefaultRecord | undefined = undefined>(eventPublisher: EventsPublisher) => AfterEventStoreCommitHandler<Store, HandlerContext>;

declare const GlobalStreamCaughtUpType = "__emt:GlobalStreamCaughtUp";
type GlobalStreamCaughtUp = Event<'__emt:GlobalStreamCaughtUp', {
    globalPosition: bigint;
}, {
    globalPosition: bigint;
}>;
declare const isGlobalStreamCaughtUp: (event: Event) => event is GlobalStreamCaughtUp;
declare const caughtUpEventFrom: (position: bigint) => (event: ReadEvent<Event, ReadEventMetadataWithGlobalPosition>) => event is ReadEvent<GlobalStreamCaughtUp, ReadEventMetadataWithGlobalPosition>;
declare const globalStreamCaughtUp: (data: EventDataOf<GlobalStreamCaughtUp>) => GlobalStreamCaughtUp;
declare const isSubscriptionEvent: (event: Event) => event is GlobalSubscriptionEvent;
declare const isNotInternalEvent: (event: Event) => boolean;
type GlobalSubscriptionEvent = GlobalStreamCaughtUp;

/** TypeScript Omit (Exclude to be specific) does not work for objects with an "any" indexed type, and breaks discriminated unions @public */
declare type EnhancedOmit<TRecordOrUnion, KeyUnion> = string extends keyof TRecordOrUnion ? TRecordOrUnion : TRecordOrUnion extends any ? Pick<TRecordOrUnion, Exclude<keyof TRecordOrUnion, KeyUnion>> : never;
declare type WithId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
    _id: string;
};
type WithoutId<T> = Omit<T, '_id'>;
declare type WithVersion<TSchema> = EnhancedOmit<TSchema, '_version'> & {
    _version: bigint;
};
type WithoutVersion<T> = Omit<T, '_version'>;
type WithIdAndVersion<TSchema> = EnhancedOmit<TSchema, '_version' | '_id'> & {
    _id: string;
    _version: bigint;
};
type Document = Record<string, unknown>;
type DocumentHandler<T extends Document> = (document: T | null) => T | null;
type ExpectedDocumentVersionGeneral = 'DOCUMENT_EXISTS' | 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK';
type ExpectedDocumentVersion = bigint | ExpectedDocumentVersionGeneral;
type ExpectedDocumentVersionValue = bigint;
type DatabaseHandleOptions = {
    expectedVersion?: ExpectedDocumentVersion;
};
type OperationResult = {
    acknowledged: boolean;
    successful: boolean;
    assertSuccessful: (errorMessage?: string) => void;
};
interface InsertOneResult extends OperationResult {
    insertedId: string | null;
    nextExpectedVersion: bigint;
}
interface InsertManyResult extends OperationResult {
    insertedIds: string[];
    insertedCount: number;
}
interface UpdateResult extends OperationResult {
    matchedCount: number;
    modifiedCount: number;
    nextExpectedVersion: bigint;
}
interface UpdateManyResult extends OperationResult {
    matchedCount: number;
    modifiedCount: number;
}
interface DeleteResult extends OperationResult {
    matchedCount: number;
    deletedCount: number;
}
interface DeleteManyResult extends OperationResult {
    deletedCount: number;
}
type DatabaseHandleResult<T> = (InsertOneResult & {
    document: WithIdAndVersion<T>;
}) | (UpdateResult & {
    document: WithIdAndVersion<T>;
}) | (DeleteResult & {
    document: null;
}) | (OperationResult & {
    document: null;
});
type DatabaseHandleOptionErrors = {
    throwOnOperationFailures?: boolean;
} | undefined;
declare type OptionalId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
    _id?: string;
};
declare type OptionalVersion<TSchema> = EnhancedOmit<TSchema, '_version'> & {
    _version?: bigint;
};
declare type OptionalUnlessRequiredId<TSchema> = TSchema extends {
    _id: string;
} ? TSchema : OptionalId<TSchema>;
declare type OptionalUnlessRequiredVersion<TSchema> = TSchema extends {
    _version: bigint;
} ? TSchema : OptionalVersion<TSchema>;
declare type OptionalUnlessRequiredIdAndVersion<TSchema> = OptionalUnlessRequiredId<TSchema> & OptionalUnlessRequiredVersion<TSchema>;
type InsertOneOptions = {
    expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK'>;
};
type InsertManyOptions = {
    expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK'>;
};
type UpdateOneOptions = {
    expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
};
type UpdateManyOptions = {
    expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
};
type ReplaceOneOptions = {
    expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
};
type DeleteOneOptions = {
    expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
};
type DeleteManyOptions = {
    expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
};
type FullId<Collection extends string, Id extends string> = `${Collection}-${Id}`;

interface InMemoryDocumentsCollection<T extends Document> {
    handle: (id: string, handle: DocumentHandler<T>, options?: DatabaseHandleOptions) => Promise<DatabaseHandleResult<T>>;
    findOne: (predicate?: Predicate<T>) => Promise<T | null>;
    find: (predicate?: Predicate<T>) => Promise<T[]>;
    insertOne: (document: OptionalUnlessRequiredIdAndVersion<T>) => Promise<InsertOneResult>;
    deleteOne: (predicate?: Predicate<T>) => Promise<DeleteResult>;
    replaceOne: (predicate: Predicate<T>, document: WithoutId<T>, options?: ReplaceOneOptions) => Promise<UpdateResult>;
}
interface InMemoryDatabase {
    collection: <T extends Document>(name: string) => InMemoryDocumentsCollection<T>;
}
type Predicate<T> = (item: T) => boolean;
declare const getInMemoryDatabase: () => InMemoryDatabase;

type ProjectionHandlingType = 'inline' | 'async';
type ProjectionHandler<EventType extends Event = AnyEvent, EventMetaDataType extends AnyReadEventMetadata = AnyReadEventMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord> = BatchRecordedMessageHandlerWithContext<EventType, EventMetaDataType, ProjectionHandlerContext>;
type TruncateProjection<ProjectionHandlerContext extends DefaultRecord = DefaultRecord> = (context: ProjectionHandlerContext) => Promise<void>;
type ProjectionInitOptions<ProjectionHandlerContext extends DefaultRecord = DefaultRecord> = {
    version: number;
    status?: 'active' | 'inactive';
    registrationType: ProjectionHandlingType;
    context: ProjectionHandlerContext;
};
interface ProjectionDefinition<EventType extends Event = AnyEvent, EventMetaDataType extends AnyReadEventMetadata = AnyReadEventMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord, EventPayloadType extends Event = EventType> {
    name?: string;
    version?: number;
    kind?: string;
    canHandle: CanHandle<EventType>;
    handle: ProjectionHandler<EventType, EventMetaDataType, ProjectionHandlerContext>;
    truncate?: TruncateProjection<ProjectionHandlerContext>;
    init?: (options: ProjectionInitOptions<ProjectionHandlerContext>) => void | Promise<void>;
    eventsOptions?: {
        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
    };
}
type ProjectionRegistration<HandlingType extends ProjectionHandlingType, ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord> = {
    type: HandlingType;
    projection: ProjectionDefinition<AnyEvent, ReadEventMetadataType, ProjectionHandlerContext, AnyEvent>;
};
declare const filterProjections: <ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord>(type: ProjectionHandlingType, projections: ProjectionRegistration<ProjectionHandlingType, ReadEventMetadataType, ProjectionHandlerContext>[]) => ProjectionDefinition<AnyEvent, ReadEventMetadataType, ProjectionHandlerContext, AnyEvent>[];
declare const projection: <EventType extends Event = Event, EventMetaDataType extends AnyReadEventMetadata = AnyReadEventMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord, EventPayloadType extends Event = EventType>(definition: ProjectionDefinition<EventType, EventMetaDataType, ProjectionHandlerContext, EventPayloadType>) => ProjectionDefinition<EventType, EventMetaDataType, ProjectionHandlerContext, EventPayloadType>;
declare const inlineProjections: <ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord>(definitions: ProjectionDefinition<any, ReadEventMetadataType, ProjectionHandlerContext>[]) => ProjectionRegistration<"inline", ReadEventMetadataType, ProjectionHandlerContext>[];
declare const asyncProjections: <ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord>(definitions: ProjectionDefinition<AnyEvent, ReadEventMetadataType, ProjectionHandlerContext>[]) => ProjectionRegistration<"inline", ReadEventMetadataType, ProjectionHandlerContext>[];
declare const projections: {
    inline: <ReadEventMetadataType extends AnyReadEventMetadata = AnyRecordedMessageMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord>(definitions: ProjectionDefinition<any, ReadEventMetadataType, ProjectionHandlerContext>[]) => ProjectionRegistration<"inline", ReadEventMetadataType, ProjectionHandlerContext>[];
    async: <ReadEventMetadataType extends AnyReadEventMetadata = AnyRecordedMessageMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord>(definitions: ProjectionDefinition<AnyEvent, ReadEventMetadataType, ProjectionHandlerContext>[]) => ProjectionRegistration<"inline", ReadEventMetadataType, ProjectionHandlerContext>[];
};

declare const InMemoryEventStoreDefaultStreamVersion = 0n;
type InMemoryEventStore = EventStore<ReadEventMetadataWithGlobalPosition> & {
    database: InMemoryDatabase;
};
type InMemoryReadEventMetadata = ReadEventMetadataWithGlobalPosition;
type InMemoryProjectionHandlerContext = {
    eventStore?: InMemoryEventStore;
    database?: InMemoryDatabase;
};
type InMemoryEventStoreOptions = DefaultEventStoreOptions<InMemoryEventStore> & {
    projections?: ProjectionRegistration<'inline', InMemoryReadEventMetadata, InMemoryProjectionHandlerContext>[];
    database?: InMemoryDatabase;
};
type InMemoryReadEvent<EventType extends Event = Event> = ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>;
declare const getInMemoryEventStore: (eventStoreOptions?: InMemoryEventStoreOptions) => InMemoryEventStore;

declare const DATABASE_REQUIRED_ERROR_MESSAGE = "Database is required in context for InMemory projections";
type InMemoryProjectionDefinition<EventType extends Event> = ProjectionDefinition<EventType, InMemoryReadEventMetadata, InMemoryProjectionHandlerContext>;
type InMemoryProjectionHandlerOptions<EventType extends Event = Event> = {
    projections: InMemoryProjectionDefinition<EventType>[];
    events: ReadEvent<EventType, InMemoryReadEventMetadata>[];
    database: InMemoryDatabase;
    eventStore?: InMemoryProjectionHandlerContext['eventStore'];
};
/**
 * Handles projections for the InMemoryEventStore
 * Similar to the PostgreSQL implementation, this processes events through projections
 */
declare const handleInMemoryProjections: <EventType extends Event = Event>(options: InMemoryProjectionHandlerOptions<EventType>) => Promise<void>;
type InMemoryWithNotNullDocumentEvolve<DocumentType extends Record<string, unknown>, EventType extends Event> = (document: DocumentType, event: ReadEvent<EventType, InMemoryReadEventMetadata>) => DocumentType | null;
type InMemoryWithNullableDocumentEvolve<DocumentType extends Record<string, unknown>, EventType extends Event> = (document: DocumentType | null, event: ReadEvent<EventType, InMemoryReadEventMetadata>) => DocumentType | null;
type InMemoryDocumentEvolve<DocumentType extends Record<string, unknown>, EventType extends Event> = InMemoryWithNotNullDocumentEvolve<DocumentType, EventType> | InMemoryWithNullableDocumentEvolve<DocumentType, EventType>;
type InMemoryProjectionOptions<EventType extends Event> = {
    handle: (events: ReadEvent<EventType, InMemoryReadEventMetadata>[], context: InMemoryProjectionHandlerContext & {
        database: InMemoryDatabase;
    }) => Promise<void>;
    canHandle: CanHandle<EventType>;
    truncate?: TruncateProjection<InMemoryProjectionHandlerContext & {
        database: InMemoryDatabase;
    }>;
};
/**
 * Creates an InMemory projection
 */
declare const inMemoryProjection: <EventType extends Event>({ truncate, handle, canHandle, }: InMemoryProjectionOptions<EventType>) => InMemoryProjectionDefinition<EventType>;
/**
 * Creates a multi-stream projection for InMemoryDatabase
 */
type InMemoryMultiStreamProjectionOptions<DocumentType extends Record<string, unknown>, EventType extends Event> = {
    canHandle: CanHandle<EventType>;
    collectionName: string;
    getDocumentId: (event: ReadEvent<EventType>) => string;
} & ({
    evolve: InMemoryWithNullableDocumentEvolve<DocumentType, EventType>;
} | {
    evolve: InMemoryWithNotNullDocumentEvolve<DocumentType, EventType>;
    initialState: () => DocumentType;
});
/**
 * Creates a projection that handles events across multiple streams
 */
declare const inMemoryMultiStreamProjection: <DocumentType extends Record<string, unknown>, EventType extends Event>(options: InMemoryMultiStreamProjectionOptions<DocumentType, EventType>) => InMemoryProjectionDefinition<EventType>;
/**
 * Creates a single-stream projection for InMemoryDatabase
 */
type InMemorySingleStreamProjectionOptions<DocumentType extends Record<string, unknown>, EventType extends Event> = {
    canHandle: CanHandle<EventType>;
    getDocumentId?: (event: ReadEvent<EventType>) => string;
    collectionName: string;
} & ({
    evolve: InMemoryWithNullableDocumentEvolve<DocumentType, EventType>;
} | {
    evolve: InMemoryWithNotNullDocumentEvolve<DocumentType, EventType>;
    initialState: () => DocumentType;
});
/**
 * Creates a projection that handles events from a single stream
 */
declare const inMemorySingleStreamProjection: <DocumentType extends Record<string, unknown>, EventType extends Event>(options: InMemorySingleStreamProjectionOptions<DocumentType, EventType>) => InMemoryProjectionDefinition<EventType>;

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 assertDoesNotThrow: <TError extends Error>(fun: () => void, errorCheck?: (error: Error) => boolean) => TError | null;
declare const assertRejects: <T, TError extends Error = Error>(promise: Promise<T>, errorCheck?: ((error: TError) => boolean) | TError) => Promise<void>;
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 const assertDefined: (value: unknown, message?: string | Error) => asserts value;
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;
    containsElementsMatching: (other: T[]) => void;
    containsOnlyElementsMatching: (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 AsyncDeciderSpecification<Command, Event> = (givenEvents: Event | Event[]) => {
    when: (command: Command) => {
        then: (expectedEvents: Event | Event[]) => Promise<void>;
        thenNothingHappened: () => Promise<void>;
        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
    };
};
type DeciderSpecification<Command, Event> = (givenEvents: Event | Event[]) => {
    when: (command: Command) => {
        then: (expectedEvents: Event | Event[]) => void;
        thenNothingHappened: () => void;
        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => void;
    };
};
declare const DeciderSpecification: {
    for: typeof deciderSpecificationFor;
};
declare function deciderSpecificationFor<Command, Event, State>(decider: {
    decide: (command: Command, state: State) => Event | Event[];
    evolve: (state: State, event: Event) => State;
    initialState: () => State;
}): DeciderSpecification<Command, Event>;
declare function deciderSpecificationFor<Command, Event, State>(decider: {
    decide: (command: Command, state: State) => Promise<Event | Event[]>;
    evolve: (state: State, event: Event) => State;
    initialState: () => State;
}): AsyncDeciderSpecification<Command, Event>;

type TestEventStream<EventType extends Event = Event> = [
    string,
    EventType[]
];
type EventStoreWrapper<Store extends EventStore> = Store & {
    appendedEvents: Map<string, TestEventStream>;
    setup<EventType extends Event>(streamName: string, events: EventType[]): Promise<AppendToStreamResult<StreamPositionTypeOfEventStore<Store>>>;
};
declare const WrapEventStore: <Store extends EventStore>(eventStore: Store) => EventStoreWrapper<Store>;

type DocumentWithId = Document & {
    _id?: string | number;
};
type InMemoryProjectionSpecEvent<EventType extends Event, EventMetaDataType extends InMemoryReadEventMetadata = InMemoryReadEventMetadata> = EventType & {
    metadata?: Partial<EventMetaDataType>;
};
type InMemoryProjectionSpecWhenOptions = {
    numberOfTimes: number;
};
type InMemoryProjectionAssert = (options: {
    database: InMemoryDatabase;
}) => Promise<void | boolean>;
type InMemoryProjectionSpecOptions<EventType extends Event> = {
    projection: InMemoryProjectionDefinition<EventType>;
};
type InMemoryProjectionSpec<EventType extends Event> = (givenEvents: InMemoryProjectionSpecEvent<EventType>[]) => {
    when: (events: InMemoryProjectionSpecEvent<EventType>[], options?: InMemoryProjectionSpecWhenOptions) => {
        then: (assert: InMemoryProjectionAssert, message?: string) => Promise<void>;
        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
    };
};
declare const InMemoryProjectionSpec: {
    for: <EventType extends Event>(options: InMemoryProjectionSpecOptions<EventType>) => InMemoryProjectionSpec<EventType>;
};
declare const eventInStream: <EventType extends Event = Event, EventMetaDataType extends InMemoryReadEventMetadata = InMemoryReadEventMetadata>(streamName: string, event: InMemoryProjectionSpecEvent<EventType, EventMetaDataType>) => InMemoryProjectionSpecEvent<EventType, EventMetaDataType>;
declare const eventsInStream: <EventType extends Event = Event, EventMetaDataType extends InMemoryReadEventMetadata = InMemoryReadEventMetadata>(streamName: string, events: InMemoryProjectionSpecEvent<EventType, EventMetaDataType>[]) => InMemoryProjectionSpecEvent<EventType, EventMetaDataType>[];
declare const newEventsInStream: <EventType extends Event = Event, EventMetaDataType extends InMemoryReadEventMetadata = InMemoryReadEventMetadata>(streamName: string, events: InMemoryProjectionSpecEvent<EventType, EventMetaDataType>[]) => InMemoryProjectionSpecEvent<EventType, EventMetaDataType>[];
declare function documentExists<T extends DocumentWithId>(expected: Partial<T>, options: {
    inCollection: string;
    withId: string | number;
}): InMemoryProjectionAssert;
declare const expectInMemoryDocuments: {
    fromCollection: <T extends DocumentWithId>(collectionName: string) => {
        withId: (id: string | number) => {
            toBeEqual: (expected: Partial<T>) => InMemoryProjectionAssert;
        };
    };
};

type MessageDowncast<MessageType extends AnyMessage, MessagePayloadType extends AnyMessage = MessageType, RecordedMessageMetadataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata> = ((message: RecordedMessage<MessageType, RecordedMessageMetadataType>) => RecordedMessage<MessagePayloadType, RecordedMessageMetadataType>) | ((message: MessageType) => MessagePayloadType);
declare const downcastRecordedMessage: <MessageType extends AnyMessage, MessagePayloadType extends AnyMessage = MessageType, RecordedMessageMetadataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata>(recordedMessage: RecordedMessage<MessageType, RecordedMessageMetadataType> | MessageType, options?: {
    downcast?: MessageDowncast<MessageType, MessagePayloadType, RecordedMessageMetadataType>;
}) => RecordedMessage<MessagePayloadType, RecordedMessageMetadataType>;
declare const downcastRecordedMessages: <MessageType extends AnyMessage, MessagePayloadType extends AnyMessage = MessageType, RecordedMessageMetadataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata>(recordedMessages: RecordedMessage<MessageType, RecordedMessageMetadataType>[] | MessageType[], options?: {
    downcast?: MessageDowncast<MessageType, MessagePayloadType, RecordedMessageMetadataType>;
}) => RecordedMessage<MessagePayloadType, RecordedMessageMetadataType>[];

type MessageUpcast<MessageType extends AnyMessage, MessagePayloadType extends AnyMessage = MessageType, RecordedMessageMetadataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata> = ((message: MessagePayloadType) => MessageType) | ((message: RecordedMessage<MessagePayloadType, RecordedMessageMetadataType>) => RecordedMessage<MessageType, RecordedMessageMetadataType>);
declare const upcastRecordedMessage: <MessageType extends AnyMessage, MessagePayloadType extends AnyMessage = MessageType, RecordedMessageMetadataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata>(recordedMessage: RecordedMessage<MessagePayloadType, RecordedMessageMetadataType> | MessagePayloadType, options?: {
    upcast?: MessageUpcast<MessageType, MessagePayloadType, RecordedMessageMetadataType>;
}) => RecordedMessage<MessageType, RecordedMessageMetadataType>;
declare const upcastRecordedMessages: <MessageType extends AnyMessage, MessagePayloadType extends AnyMessage = MessageType, RecordedMessageMetadataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata>(recordedMessages: RecordedMessage<MessagePayloadType, RecordedMessageMetadataType>[] | MessagePayloadType[], options?: {
    upcast?: MessageUpcast<MessageType, MessagePayloadType, RecordedMessageMetadataType>;
}) => RecordedMessage<MessageType, RecordedMessageMetadataType>[];

type Closeable = {
    /**
     * Gracefully cleans up managed resources
     *
     * @memberof Closeable
     */
    close: () => Promise<void>;
};

declare const merge: <T>(array: T[], item: T, where: (current: T) => boolean, onExisting: (current: T) => T, onNotFound?: () => T | undefined) => T[];

declare const arrayUtils: {
    merge: <T>(array: T[], item: T, where: (current: T) => boolean, onExisting: (current: T) => T, onNotFound?: () => T | undefined) => T[];
    hasDuplicates: <ArrayItem, Mapped>(array: ArrayItem[], predicate: (value: ArrayItem, index: number, array: ArrayItem[]) => Mapped) => boolean;
    getDuplicates: <ArrayItem, Mapped>(array: ArrayItem[], predicate: (value: ArrayItem, index: number, array: ArrayItem[]) => Mapped) => ArrayItem[];
};

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;

type LockOptions = {
    lockId: number;
};
type AcquireLockOptions = {
    lockId: string;
};
type ReleaseLockOptions = {
    lockId: string;
};
type Lock = {
    acquire(options: AcquireLockOptions): Promise<void>;
    tryAcquire(options: AcquireLockOptions): Promise<boolean>;
    release(options: ReleaseLockOptions): Promise<boolean>;
    withAcquire: <Result = unknown>(handle: () => Promise<Result>, options: AcquireLockOptions) => Promise<Result>;
};
declare const InProcessLock: () => Lock;

declare const toNormalizedString: (value: bigint) => string;
declare const bigInt: {
    toNormalizedString: (value: bigint) => string;
};

declare const delay: (ms: number) => Promise<void>;
type AsyncAwaiter<T = void> = {
    wait: Promise<T>;
    resolve: (value: T | PromiseLike<T>) => void;
    reject: (reason?: any) => void;
    reset: () => void;
};
declare const asyncAwaiter: <T = void>() => AsyncAwaiter<T>;

type AsyncRetryOptions<T = unknown> = retry.Options & {
    shouldRetryResult?: (result: T) => boolean;
    shouldRetryError?: (error?: unknown) => boolean;
};
declare const NoRetries: AsyncRetryOptions;
declare const asyncRetry: <T>(fn: () => Promise<T>, opts?: AsyncRetryOptions<T>) => Promise<T>;

type ShutdownHandler = () => void | Promise<void>;
/**
 * Registers handlers for OS signals to enable graceful shutdown.
 * Handles SIGTERM and SIGINT by default.
 * Works in Node.js, Bun, and Deno. Safely no-ops in Browser/Cloudflare Workers.
 *
 * @param handler - Function to call when shutdown signal is received
 * @returns Cleanup function to unregister the handlers
 */
declare const onShutdown: (handler: ShutdownHandler) => (() => void);

declare const hashText: (text: string) => Promise<bigint>;

declare const CommandHandlerStreamVersionConflictRetryOptions: AsyncRetryOptions;
type CommandHandlerRetryOptions = AsyncRetryOptions | {
    onVersionConflict: true | number | AsyncRetryOptions;
};
type CommandHandlerResult<State, StreamEvent extends Event, Store extends EventStore> = AppendStreamResultOfEventStore<Store> & {
    newState: State;
    newEvents: StreamEvent[];
};
type CommandHandlerOptions<State, StreamEvent extends Event, StoredEvent extends Event = StreamEvent> = {
    evolve: (state: State, event: StreamEvent) => State;
    initialState: () => State;
    mapToStreamId?: (id: string) => string;
    retry?: CommandHandlerRetryOptions;
    schema?: {
        versioning?: {
            upcast?: (event: StoredEvent) => StreamEvent;
            downcast?: (event: StreamEvent) => StoredEvent;
        };
    };
};
type HandleOptions<Store extends EventStore> = Parameters<Store['appendToStream']>[2] & ({
    expectedStreamVersion?: ExpectedStreamVersion<StreamPositionTypeOfEventStore<Store>>;
} | {
    retry?: CommandHandlerRetryOptions;
});
type CommandHandlerFunction<State, StreamEvent extends Event> = (state: State) => StreamEvent | StreamEvent[] | Promise<StreamEvent | StreamEvent[]>;
declare const CommandHandler: <State, StreamEvent extends Event, EventPayloadType extends Event = StreamEvent>(options: CommandHandlerOptions<State, StreamEvent, EventPayloadType>) => <Store extends EventStore>(store: Store, id: string, handle: CommandHandlerFunction<State, StreamEvent> | CommandHandlerFunction<State, StreamEvent>[], handleOptions?: HandleOptions<Store>) => Promise<CommandHandlerResult<State, StreamEvent, Store>>;

type DeciderCommandHandlerOptions<State, CommandType extends Command, StreamEvent extends Event> = CommandHandlerOptions<State, StreamEvent> & Decider<State, CommandType, StreamEvent>;
declare const DeciderCommandHandler: <State, CommandType extends Command, StreamEvent extends Event>(options: DeciderCommandHandlerOptions<State, CommandType, StreamEvent>) => <Store extends EventStore>(eventStore: Store, id: string, commands: CommandType | CommandType[], handleOptions?: HandleOptions<Store>) => Promise<CommandHandlerResult<State, StreamEvent, Store>>;

type CurrentMessageProcessorPosition<CheckpointType = any> = {
    lastCheckpoint: CheckpointType;
} | 'BEGINNING' | 'END';
type GetCheckpoint<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, CheckpointType = GlobalPositionTypeOfRecordedMessageMetadata<MessageMetadataType>> = (message: RecordedMessage<MessageType, MessageMetadataType>) => CheckpointType | null;
declare const getCheckpoint: <MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, CheckpointType = GlobalPositionTypeOfRecordedMessageMetadata<MessageMetadataType>>(message: RecordedMessage<MessageType, MessageMetadataType>) => CheckpointType | null;
declare const wasMessageHandled: <MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, CheckpointType = GlobalPositionTypeOfRecordedMessageMetadata<MessageMetadataType>>(message: RecordedMessage<MessageType, MessageMetadataType>, checkpoint: CheckpointType | null) => boolean;
type MessageProcessorStartFrom<CheckpointType = any> = CurrentMessageProcessorPosition<CheckpointType> | 'CURRENT';
type MessageProcessorType = 'projector' | 'reactor';
declare const MessageProcessorType: {
    PROJECTOR: MessageProcessorType;
    REACTOR: MessageProcessorType;
};
type MessageProcessor<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends DefaultRecord | undefined = undefined, CheckpointType = GlobalPositionTypeOfRecordedMessageMetadata<MessageMetadataType>> = {
    id: string;
    instanceId: string;
    type: string;
    init: (options: Partial<HandlerContext>) => Promise<void>;
    start: (options: Partial<HandlerContext>) => Promise<CurrentMessageProcessorPosition<CheckpointType> | undefined>;
    close: (closeOptions: Partial<HandlerContext>) => Promise<void>;
    isActive: boolean;
    handle: BatchRecordedMessageHandlerWithContext<MessageType, MessageMetadataType, Partial<HandlerContext>>;
};
declare const MessageProcessor: {
    result: {
        skip: (options?: {
            reason?: string;
        }) => MessageHandlerResult;
        stop: (options?: {
            reason?: string;
            error?: EmmettError;
        }) => MessageHandlerResult;
    };
};
type MessageProcessingScope<HandlerContext extends DefaultRecord | undefined = undefined> = <Result = MessageHandlerResult>(handler: (context: HandlerContext) => Result | Promise<Result>, partialContext: Partial<HandlerContext>) => Result | Promise<Result>;
type Checkpointer<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends DefaultRecord = DefaultRecord, CheckpointType = GlobalPositionTypeOfRecordedMessageMetadata<MessageMetadataType>> = {
    read: ReadProcessorCheckpoint<CheckpointType, HandlerContext>;
    store: StoreProcessorCheckpoint<MessageType, MessageMetadataType, CheckpointType, HandlerContext>;
};
type ProcessorHooks<HandlerContext extends DefaultRecord = DefaultRecord> = {
    onInit?: OnReactorInitHook<HandlerContext>;
    onStart?: OnReactorStartHook<HandlerContext>;
    onClose?: OnReactorCloseHook<HandlerContext>;
};
type BaseMessageProcessorOptions<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends DefaultRecord = DefaultRecord, CheckpointType = GlobalPositionTypeOfRecordedMessageMetadata<MessageMetadataType>> = {
    type?: string;
    processorId: string;
    processorInstanceId?: string;
    version?: number;
    partition?: string;
    startFrom?: MessageProcessorStartFrom<CheckpointType>;
    stopAfter?: (message: RecordedMessage<MessageType, MessageMetadataType>) => boolean;
    processingScope?: MessageProcessingScope<HandlerContext>;
    checkpoints?: Checkpointer<MessageType, MessageMetadataType, HandlerContext, CheckpointType>;
    canHandle?: CanHandle<MessageType>;
    hooks?: ProcessorHooks<HandlerContext>;
};
type HandlerOptions<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends DefaultRecord = DefaultRecord> = {
    eachMessage: SingleRecordedMessageHandlerWithContext<MessageType, MessageMetadataType, HandlerContext>;
    eachBatch?: never;
} | {
    eachMessage?: never;
    eachBatch: BatchRecordedMessageHandlerWithContext<MessageType, MessageMetadataType, HandlerContext>;
};
type OnReactorInitHook<HandlerContext extends DefaultRecord = DefaultRecord> = (context: HandlerContext) => Promise<void>;
type OnReactorStartHook<HandlerContext extends DefaultRecord = DefaultRecord> = (context: HandlerContext) => Promise<void>;
type OnReactorCloseHook<HandlerContext extends DefaultRecord = DefaultRecord> = (context: HandlerContext) => Promise<void>;
type ReactorOptions<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends DefaultRecord = DefaultRecord, CheckpointType = GlobalPositionTypeOfRecordedMessageMetadata<MessageMetadataType>, MessagePayloadType extends AnyMessage = MessageType> = BaseMessageProcessorOptions<MessageType, MessageMetadataType, HandlerContext, CheckpointType> & HandlerOptions<MessageType, MessageMetadataType, HandlerContext> & {
    messageOptions?: {
        schema?: {
            versioning?: {
                upcast?: (event: MessagePayloadType) => MessageType;
            };
        };
    };
};
type ProjectorOptions<EventType extends AnyEvent = AnyEvent, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends DefaultRecord = DefaultRecord, CheckpointType = GlobalPositionTypeOfRecordedMessageMetadata<MessageMetadataType>, EventPayloadType extends Event = EventType> = Omit<BaseMessageProcessorOptions<EventType, MessageMetadataType, HandlerContext, CheckpointType>, 'type' | 'processorId'> & {
    processorId?: string;
} & {
    truncateOnStart?: boolean;
    projection: ProjectionDefinition<EventType, MessageMetadataType, HandlerContext, EventPayloadType>;
};
declare const defaultProcessingMessageProcessingScope: <HandlerContext = never, Result = MessageHandlerResult>(handler: (context: HandlerContext) => Result | Promise<Result>, partialContext: Partial<HandlerContext>) => Result | Promise<Result>;
type ReadProcessorCheckpointResult<CheckpointType = unknown> = {
    lastCheckpoint: CheckpointType | null;
};
type ReadProcessorCheckpoint<CheckpointType = unknown, HandlerContext extends DefaultRecord = DefaultRecord> = (options: {
    processorId: string;
    partition?: string;
}, context: HandlerContext) => Promise<ReadProcessorCheckpointResult<CheckpointType>>;
type StoreProcessorCheckpointResult<CheckpointType = unknown> = {
    success: true;
    newCheckpoint: CheckpointType;
} | {
    success: false;
    reason: 'IGNORED' | 'MISMATCH' | 'CURRENT_AHEAD';
};
type StoreProcessorCheckpoint<MessageType extends Message = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, CheckpointType = unknown, HandlerContext extends DefaultRecord | undefined = undefined> = ((options: {
    message: RecordedMessage<MessageType, MessageMetadataType>;
    processorId: string;
    version: number | undefined;
    lastCheckpoint: CheckpointType | null;
    partition?: string;
}, context: HandlerContext) => Promise<StoreProcessorCheckpointResult<CheckpointType | null>>) | ((options: {
    message: RecordedMessage<MessageType, MessageMetadataType>;
    processorId: string;
    version: number | undefined;
    lastCheckpoint: CheckpointType | null;
    partition?: string;
}, context: HandlerContext) => Promise<StoreProcessorCheckpointResult<CheckpointType>>);
declare const defaultProcessorVersion = 1;
declare const defaultProcessorPartition = "emt:default";
declare const getProcessorInstanceId: (processorId: string) => string;
declare const getProjectorId: (options: {
    projectionName: string;
}) => string;
declare const reactor: <MessageType extends Message = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends DefaultRecord = DefaultRecord, CheckpointType = GlobalPositionTypeOfRecordedMessageMetadata<MessageMetadataType>, MessagePayloadType extends Message = MessageType>(options: ReactorOptions<MessageType, MessageMetadataType, HandlerContext, CheckpointType, MessagePayloadType>) => MessageProcessor<MessageType, MessageMetadataType, HandlerContext, CheckpointType>;
declare const projector: <EventType extends Event = Event, EventMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends DefaultRecord = DefaultRecord, CheckpointType = GlobalPositionTypeOfRecordedMessageMetadata<EventMetaDataType>, EventPayloadType extends Event = EventType>(options: ProjectorOptions<EventType, EventMetaDataType, HandlerContext, CheckpointType, EventPayloadType>) => MessageProcessor<EventType, EventMetaDataType, HandlerContext, CheckpointType>;

type InMemoryProcessorHandlerContext = {
    database: InMemoryDatabase;
};
type InMemoryProcessor<MessageType extends AnyMessage = AnyMessage> = MessageProcessor<MessageType, ReadEventMetadataWithGlobalPosition, InMemoryProcessorHandlerContext> & {
    database: InMemoryDatabase;
};
type InMemoryProcessorEachMessageHandler<MessageType extends AnyMessage = AnyMessage> = SingleRecordedMessageHandlerWithContext<MessageType, ReadEventMetadataWithGlobalPosition, InMemoryProcessorHandlerContext>;
type InMemoryProcessorEachBatchHandler<MessageType extends AnyMessage = AnyMessage> = BatchRecordedMessageHandlerWithContext<MessageType, ReadEventMetadataWithGlobalPosition, InMemoryProcessorHandlerContext>;
type InMemoryProcessorConnectionOptions = {
    database?: InMemoryDatabase;
};
type InMemoryCheckpointer<MessageType extends AnyMessage = AnyMessage> = Checkpointer<MessageType, ReadEventMetadataWithGlobalPosition, InMemoryProcessorHandlerContext>;
declare const inMemoryCheckpointer: <MessageType extends AnyMessage = AnyMessage>() => InMemoryCheckpointer<MessageType>;
type InMemoryConnectionOptions = {
    connectionOptions?: InMemoryProcessorConnectionOptions;
};
type InMemoryReactorOptions<MessageType extends AnyMessage = AnyMessage> = ReactorOptions<MessageType, ReadEventMetadataWithGlobalPosition, InMemoryProcessorHandlerContext> & InMemoryConnectionOptions;
type InMemoryProjectorOptions<EventType extends AnyEvent = AnyEvent> = ProjectorOptions<EventType, ReadEventMetadataWithGlobalPosition, InMemoryProcessorHandlerContext> & InMemoryConnectionOptions;
type InMemoryProcessorOptions<MessageType extends AnyMessage = AnyMessage> = InMemoryReactorOptions<MessageType> | InMemoryProjectorOptions<MessageType & AnyEvent>;
declare const inMemoryProjector: <EventType extends AnyEvent = AnyEvent>(options: InMemoryProjectorOptions<EventType>) => InMemoryProcessor<EventType>;
declare const inMemoryReactor: <MessageType extends AnyMessage = AnyMessage>(options: InMemoryReactorOptions<MessageType>) => InMemoryProcessor<MessageType>;

type MessageConsumerOptions<ConsumerMessageType extends Message = any> = {
    consumerId?: string;
    processors?: Array<MessageProcessor<ConsumerMessageType, any, any, any>>;
};
type MessageConsumer<ConsumerMessageType extends Message = any> = Readonly<{
    consumerId: string;
    isRunning: boolean;
    processors: ReadonlyArray<MessageProcessor<ConsumerMessageType, any, any>>;
    start: () => Promise<void>;
    stop: () => Promise<void>;
    close: () => Promise<void>;
}>;

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;
};

type TaskQueue = TaskQueueItem[];
type TaskQueueItem = {
    task: () => Promise<void>;
    options?: EnqueueTaskOptions;
};
type TaskProcessorOptions = {
    maxActiveTasks: number;
    maxQueueSize: number;
    maxTaskIdleTime?: number;
};
type Task<T> = (context: TaskContext) => Promise<T>;
type TaskContext = {
    ack: () => void;
};
type EnqueueTaskOptions = {
    taskGroupId?: string;
};
declare class TaskProcessor {
    private options;
    private queue;
    private isProcessing;
    private activeTasks;
    private activeGroups;
    constructor(options: TaskProcessorOptions);
    enqueue<T>(task: Task<T>, options?: EnqueueTaskOptions): Promise<T>;
    waitForEndOfProcessing(): Promise<void>;
    private schedule;
    private ensureProcessing;
    private processQueue;
    private executeItem;
    private takeFirstAvailableItem;
    private hasItemsToProcess;
}

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 isBigint: (val: any) => val is bigint;
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 AcquireLockOptions, type AfterEventStoreCommitHandler, type AggregateStreamOptions, type AggregateStreamResult, type AggregateStreamResultOfEventStore, type AggregateStreamResultWithGlobalPosition, type AnyCommand, type AnyEvent, type AnyMessage, type AnyReadEvent, type AnyReadEventMetadata, type AnyRecord, type AnyRecordedMessage, type AnyRecordedMessageMetadata, type AppendStreamResultOfEventStore, type AppendToStreamOptions, type AppendToStreamResult, type AppendToStreamResultWithGlobalPosition, type ArgumentMatcher, AssertionError, type AsyncAwaiter, type AsyncDeciderSpecification, type AsyncRetryOptions, type BaseMessageProcessorOptions, type BatchMessageHandler, type BatchMessageHandlerWithContext, type BatchMessageHandlerWithoutContext, type BatchRawMessageHandlerWithContext, type BatchRawMessageHandlerWithoutContext, type BatchRecordedMessageHandlerWithContext, type BatchRecordedMessageHandlerWithoutContext, type BeforeEventStoreCommitHandler, type BigIntGlobalPosition, type BigIntStreamPosition, type Brand, type CanHandle, type Checkpointer, type Closeable, type CombineMetadata, type CombinedMessageMetadata, type CombinedReadEventMetadata, type Command, type CommandBus, type CommandDataOf, CommandHandler, type CommandHandlerOptions, type CommandHandlerResult, type CommandHandlerRetryOptions, CommandHandlerStreamVersionConflictRetryOptions, type CommandMetaDataOf, type CommandProcessor, type CommandSender, type CommandTypeOf, type CommonReadEventMetadata, type CommonRecordedMessageMetadata, ConcurrencyError, type CreateCommandType, type CreateEventType, type CurrentMessageProcessorPosition, DATABASE_REQUIRED_ERROR_MESSAGE, type DatabaseHandleOptionErrors, type DatabaseHandleOptions, type DatabaseHandleResult, type Decider, DeciderCommandHandler, type DeciderCommandHandlerOptions, DeciderSpecification, type DeepReadonly, type DefaultCommandMetadata, type DefaultEventStoreOptions, type DefaultRecord, type DeleteManyOptions, type DeleteManyResult, type DeleteOneOptions, type DeleteResult, type Document, type DocumentHandler, EmmettError, type EnhancedOmit, type EnqueueTaskOptions, type Equatable, ErrorConstructor, type Event, type EventBus, type EventDataOf, type EventMetaDataOf, type EventStore, type EventStoreAppendSchemaOptions, type EventStoreReadEventMetadata, type EventStoreReadSchemaOptions, type EventStoreSchemaOptions, type EventStoreSession, type EventStoreSessionFactory, type EventStoreWrapper, type EventSubscription, type EventTypeOf, type EventsPublisher, type ExpectedDocumentVersion, type ExpectedDocumentVersionGeneral, type ExpectedDocumentVersionValue, type ExpectedStreamVersion, type ExpectedStreamVersionGeneral, type ExpectedStreamVersionWithValue, ExpectedVersionConflictError, type Flavour, type FullId, type GetCheckpoint, type GlobalPositionTypeOfEventStore, type GlobalPositionTypeOfReadEventMetadata, type GlobalPositionTypeOfRecordedMessageMetadata, type GlobalStreamCaughtUp, GlobalStreamCaughtUpType, type GlobalSubscriptionEvent, type HandleOptions, type HandlerOptions, type InMemoryCheckpointer, type InMemoryDatabase, type InMemoryDocumentEvolve, type InMemoryDocumentsCollection, type InMemoryEventStore, InMemoryEventStoreDefaultStreamVersion, type InMemoryEventStoreOptions, type InMemoryMultiStreamProjectionOptions, type InMemoryProcessor, type InMemoryProcessorConnectionOptions, type InMemoryProcessorEachBatchHandler, type InMemoryProcessorEachMessageHandler, type InMemoryProcessorHandlerContext, type InMemoryProcessorOptions, type InMemoryProjectionAssert, type InMemoryProjectionDefinition, type InMemoryProjectionHandlerContext, type InMemoryProjectionHandlerOptions, type InMemoryProjectionOptions, InMemoryProjectionSpec, type InMemoryProjectionSpecEvent, type InMemoryProjectionSpecOptions, type InMemoryProjectionSpecWhenOptions, type InMemoryProjectorOptions, type InMemoryReactorOptions, type InMemoryReadEvent, type InMemoryReadEventMetadata, type InMemorySingleStreamProjectionOptions, type InMemoryWithNotNullDocumentEvolve, type InMemoryWithNullableDocumentEvolve, InProcessLock, type InsertManyOptions, type InsertManyResult, type InsertOneOptions, type InsertOneResult, JSONParser, type Lock, type LockOptions, type Mapper, type MapperArgs, type Message, type MessageBus, type MessageConsumer, type MessageConsumerOptions, type MessageDataOf, type MessageDowncast, type MessageHandler, type MessageHandlerResult, type MessageKindOf, type MessageMetaDataOf, type MessageProcessingScope, MessageProcessor, type MessageProcessorStartFrom, MessageProcessorType, type MessageScheduler, type MessageSubscription, type MessageTypeOf, type MessageUpcast, type MockedFunction, type Mutable, NO_CONCURRENCY_CHECK, NoRetries, type NonNullable$1 as NonNullable, type OnReactorCloseHook, type OnReactorInitHook, type OnReactorStartHook, type OperationResult, type OptionalId, type OptionalUnlessRequiredId, type OptionalUnlessRequiredIdAndVersion, type OptionalUnlessRequiredVersion, type OptionalVersion, ParseError, type ParseOptions, type ProcessorHooks, type ProjectionDefinition, type ProjectionHandler, type ProjectionHandlingType, type ProjectionInitOptions, type ProjectionRegistration, type ProjectorOptions, type ReactorOptions, type ReadEvent, type ReadEventMetadata, type ReadEventMetadataWithGlobalPosition, type ReadEventMetadataWithoutGlobalPosition, type ReadProcessorCheckpoint, type ReadProcessorCheckpointResult, type ReadStreamOptions, type ReadStreamResult, type RecordedMessage, type RecordedMessageMetadata, type RecordedMessageMetadataWithGlobalPosition, type RecordedMessageMetadataWithoutGlobalPosition, type ReleaseLockOptions, type ReplaceOneOptions, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, type ScheduleOptions, type ScheduledMessage, type ScheduledMessageProcessor, type ShutdownHandler, type SingleMessageHandler, type SingleMessageHandlerWithContext, type SingleMessageHandlerWithoutContext, type SingleRawMessageHandlerWithContext, type SingleRawMessageHandlerWithoutContext, type SingleRecordedMessageHandlerWithContext, type SingleRecordedMessageHandlerWithoutContext, type StoreProcessorCheckpoint, type StoreProcessorCheckpointResult, type StreamExistsResult, type StreamPositionTypeOfEventStore, type StreamPositionTypeOfReadEventMetadata, type StreamPositionTypeOfRecordedMessageMetadata, type StringifyOptions, type Task, type TaskContext, TaskProcessor, type TaskProcessorOptions, type TaskQueue, type TaskQueueItem, type TestEventStream, type ThenThrows, type TruncateProjection, type UpdateManyOptions, type UpdateManyResult, type UpdateOneOptions, type UpdateResult, ValidationErrors, type WithGlobalPosition, type WithId, type WithIdAndVersion, type WithVersion, type WithoutId, type WithoutVersion, type Workflow, type WorkflowCommand, type WorkflowEvent, type WorkflowOutput, WrapEventStore, accept, argMatches, argValue, arrayUtils, assertDeepEqual, assertDefined, assertDoesNotThrow, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEmptyString, assertNotEqual, assertOk, assertPositiveNumber, assertRejects, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, assertUnsignedBigInt, asyncAwaiter, asyncProjections, asyncRetry, bigInt, canCreateEventStoreSession, caughtUpEventFrom, command, complete, deepEquals, defaultProcessingMessageProcessingScope, defaultProcessorPartition, defaultProcessorVersion, defaultTag, delay, documentExists, downcastRecordedMessage, downcastRecordedMessages, emmettPrefix, error, event, eventInStream, eventsInStream, expectInMemoryDocuments, filterProjections, formatDateToUtcYYYYMMDD, forwardToMessageBus, getCheckpoint, getInMemoryDatabase, getInMemoryEventStore, getInMemoryMessageBus, getProcessorInstanceId, getProjectorId, globalStreamCaughtUp, globalTag, handleInMemoryProjections, hashText, ignore, inMemoryCheckpointer, inMemoryMultiStreamProjection, inMemoryProjection, inMemoryProjector, inMemoryReactor, inMemorySingleStreamProjection, inlineProjections, isBigint, isEquatable, isExpectedVersionConflictError, isGlobalStreamCaughtUp, isNotInternalEvent, isNumber, isString, isSubscriptionEvent, isSubset, isValidYYYYMMDD, matchesExpectedVersion, merge, message, newEventsInStream, nulloSessionFactory, onShutdown, parseDateFromUtcYYYYMMDD, projection, projections, projector, publish, reactor, reply, schedule, send, sum, toNormalizedString, tryPublishMessagesAfterCommit, unknownTag, upcastRecordedMessage, upcastRecordedMessages, verifyThat, wasMessageHandled };