@event-driven-io/emmett 0.43.0-beta.2 → 0.43.0-beta.20

package/dist/index.d.cts

@@ -1,67 +1,102 @@
-import { a as EmmettError, C as ConcurrencyError, e as ErrorConstructor } from './index-Amos00J7.cjs';
-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.cjs';
-import retry from 'async-retry';
+import { _ as isPluginConfig, a as IllegalStateError, c as isErrorConstructor, d as EmmettCliPlugin, f as EmmettCliPluginRegistration, g as EmmettPluginType, h as EmmettPluginRegistration, i as ErrorConstructor, l as EmmettPluginsConfig, m as EmmettPluginConfig, n as ConcurrencyInMemoryDatabaseError, o as NotFoundError, p as EmmettPlugin, r as EmmettError, s as ValidationError, t as ConcurrencyError, u as EmmettCliCommand } from "./index-BXN5muYb.cjs";
+import { AttributeTarget, Meter, ObservabilityConfig, ObservabilityScope, SpanContext, TracePropagation, Tracer } from "@event-driven-io/almanac";
+import retry from "async-retry";
+export * from "@event-driven-io/almanac";
 
+//#region \0rolldown/runtime.js
+//#endregion
+//#region src/typing/deepReadonly.d.ts
 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 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 MutableObject<T> = { -readonly [P in keyof T]: Mutable<T[P]> };
+//#endregion
+//#region src/typing/command.d.ts
 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: Readonly<CommandData>;
+  metadata?: DefaultCommandMetadata | undefined;
 } : {
-    type: CommandType;
-    data: CommandData;
-    metadata: CommandMetaData;
+  type: CommandType;
+  data: CommandData;
+  metadata: CommandMetaData;
 }> & {
-    readonly kind?: 'Command';
+  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;
+  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?: DefaultCommandMetadata | undefined;
 } : {
-    type: CommandType;
-    data: CommandData;
-    metadata: CommandMetaData;
+  type: CommandType;
+  data: CommandData;
+  metadata: CommandMetaData;
 }> & {
-    readonly kind?: 'Command';
+  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;
+  now: Date;
 };
-
+//#endregion
+//#region src/processors/checkpoints.d.ts
+type ProcessorCheckpoint = Brand<string, 'ProcessorCheckpoint'>;
+declare const ProcessorCheckpoint: (checkpoint: string) => ProcessorCheckpoint;
+declare const bigIntProcessorCheckpoint: (value: bigint) => ProcessorCheckpoint;
+declare const parseBigIntProcessorCheckpoint: (value: ProcessorCheckpoint) => bigint;
+type GetCheckpoint<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata> = (message: RecordedMessage<MessageType, MessageMetadataType>) => ProcessorCheckpoint | null;
+declare const getCheckpoint: <MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata>(message: RecordedMessage<MessageType, MessageMetadataType>) => ProcessorCheckpoint | null;
+type Checkpointer<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends DefaultRecord = DefaultRecord> = {
+  read: ReadProcessorCheckpoint<HandlerContext>;
+  store: StoreProcessorCheckpoint<MessageType, MessageMetadataType, HandlerContext>;
+};
+type ReadProcessorCheckpoint<HandlerContext extends DefaultRecord = DefaultRecord> = (options: {
+  processorId: string;
+  partition?: string;
+}, context: HandlerContext) => Promise<ReadProcessorCheckpointResult>;
+type StoreProcessorCheckpoint<MessageType extends Message = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends DefaultRecord | undefined = undefined> = (options: {
+  message: RecordedMessage<MessageType, MessageMetadataType>;
+  processorId: string;
+  version: number | undefined;
+  lastCheckpoint: ProcessorCheckpoint | null;
+  partition?: string;
+}, context: HandlerContext) => Promise<StoreProcessorCheckpointResult>;
+type StoreProcessorCheckpointResult = {
+  success: true;
+  newCheckpoint: ProcessorCheckpoint | null;
+} | {
+  success: false;
+  reason: 'IGNORED' | 'MISMATCH' | 'CURRENT_AHEAD';
+};
+type ReadProcessorCheckpointResult = {
+  lastCheckpoint: ProcessorCheckpoint | null;
+};
+//#endregion
+//#region src/database/types.d.ts
 /** 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;
+  _id: string;
 };
 type WithoutId<T> = Omit<T, '_id'>;
 declare type WithVersion<TSchema> = EnhancedOmit<TSchema, '_version'> & {
-    _version: bigint;
+  _version: bigint;
 };
 type WithoutVersion<T> = Omit<T, '_version'>;
 type WithIdAndVersion<TSchema> = EnhancedOmit<TSchema, '_version' | '_id'> & {
-    _id: string;
-    _version: bigint;
+  _id: string;
+  _version: bigint;
 };
 type Document = Record<string, unknown>;
 type DocumentHandler<T extends Document> = (document: T | null) => T | null;
@@ -69,330 +104,601 @@ type ExpectedDocumentVersionGeneral = 'DOCUMENT_EXISTS' | 'DOCUMENT_DOES_NOT_EXI
 type ExpectedDocumentVersion = bigint | ExpectedDocumentVersionGeneral;
 type ExpectedDocumentVersionValue = bigint;
 type DatabaseHandleOptions = {
-    expectedVersion?: ExpectedDocumentVersion;
+  expectedVersion?: ExpectedDocumentVersion;
 };
 type OperationResult = {
-    acknowledged: boolean;
-    successful: boolean;
-    assertSuccessful: (errorMessage?: string) => void;
+  acknowledged: boolean;
+  successful: boolean;
+  assertSuccessful: (errorMessage?: string) => void;
 };
 interface InsertOneResult extends OperationResult {
-    insertedId: string | null;
-    nextExpectedVersion: bigint;
+  insertedId: string | null;
+  nextExpectedVersion: bigint;
 }
 interface InsertManyResult extends OperationResult {
-    insertedIds: string[];
-    insertedCount: number;
+  insertedIds: string[];
+  insertedCount: number;
 }
 interface UpdateResult extends OperationResult {
-    matchedCount: number;
-    modifiedCount: number;
-    nextExpectedVersion: bigint;
+  matchedCount: number;
+  modifiedCount: number;
+  nextExpectedVersion: bigint;
 }
 interface UpdateManyResult extends OperationResult {
-    matchedCount: number;
-    modifiedCount: number;
+  matchedCount: number;
+  modifiedCount: number;
 }
 interface DeleteResult extends OperationResult {
-    matchedCount: number;
-    deletedCount: number;
+  matchedCount: number;
+  deletedCount: number;
 }
 interface DeleteManyResult extends OperationResult {
-    deletedCount: number;
+  deletedCount: number;
 }
 type DatabaseHandleResult<T> = (InsertOneResult & {
-    document: WithIdAndVersion<T>;
+  document: WithIdAndVersion<T>;
 }) | (UpdateResult & {
-    document: WithIdAndVersion<T>;
+  document: WithIdAndVersion<T>;
 }) | (DeleteResult & {
-    document: null;
+  document: null;
 }) | (OperationResult & {
-    document: null;
+  document: null;
 });
 type DatabaseHandleOptionErrors = {
-    throwOnOperationFailures?: boolean;
+  throwOnOperationFailures?: boolean;
 } | undefined;
 declare type OptionalId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
-    _id?: string;
+  _id?: string;
 };
 declare type OptionalVersion<TSchema> = EnhancedOmit<TSchema, '_version'> & {
-    _version?: bigint;
+  _version?: bigint;
 };
 declare type OptionalUnlessRequiredId<TSchema> = TSchema extends {
-    _id: string;
+  _id: string;
 } ? TSchema : OptionalId<TSchema>;
 declare type OptionalUnlessRequiredVersion<TSchema> = TSchema extends {
-    _version: bigint;
+  _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'>;
+  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK'>;
 };
 type InsertManyOptions = {
-    expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK'>;
+  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK'>;
 };
 type UpdateOneOptions = {
-    expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
+  expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
 };
 type UpdateManyOptions = {
-    expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
+  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
 };
 type ReplaceOneOptions = {
-    expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
+  expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
 };
 type DeleteOneOptions = {
-    expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
+  expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
 };
 type DeleteManyOptions = {
-    expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
+  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
 };
 type FullId<Collection extends string, Id extends string> = `${Collection}-${Id}`;
-
+//#endregion
+//#region src/database/inMemoryDatabase.d.ts
 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>;
+  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>;
+  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>;
+//#endregion
+//#region src/observability/attributes.d.ts
+declare const EmmettAttributes: {
+  readonly scope: {
+    readonly type: "emmett.scope.type";
+  };
+  readonly command: {
+    readonly type: "emmett.command.type";
+    readonly status: "emmett.command.status";
+    readonly eventCount: "emmett.command.event_count";
+    readonly eventTypes: "emmett.command.event_types";
+  };
+  readonly stream: {
+    readonly name: "emmett.stream.name";
+    readonly versionBefore: "emmett.stream.version.before";
+    readonly versionAfter: "emmett.stream.version.after";
+  };
+  readonly eventStore: {
+    readonly operation: "emmett.eventstore.operation";
+    readonly read: {
+      readonly eventCount: "emmett.eventstore.read.event_count";
+      readonly eventTypes: "emmett.eventstore.read.event_types";
+      readonly status: "emmett.eventstore.read.status";
+    };
+    readonly append: {
+      readonly batchSize: "emmett.eventstore.append.batch_size";
+      readonly status: "emmett.eventstore.append.status";
     };
+  };
+  readonly event: {
+    readonly type: "emmett.event.type";
+  };
+  readonly processor: {
+    readonly id: "emmett.processor.id";
+    readonly type: "emmett.processor.type";
+    readonly status: "emmett.processor.status";
+    readonly batchSize: "emmett.processor.batch_size";
+    readonly eventTypes: "emmett.processor.event_types";
+    readonly checkpointBefore: "emmett.processor.checkpoint.before";
+    readonly checkpointAfter: "emmett.processor.checkpoint.after";
+    readonly lagEvents: "emmett.processor.lag_events";
+  };
+  readonly workflow: {
+    readonly id: "emmett.workflow.id";
+    readonly type: "emmett.workflow.type";
+    readonly inputType: "emmett.workflow.input.type";
+    readonly outputs: "emmett.workflow.outputs";
+    readonly outputsCount: "emmett.workflow.outputs.count";
+    readonly streamPosition: "emmett.workflow.stream_position";
+    readonly stateRebuildEventCount: "emmett.workflow.state_rebuild.event_count";
+  };
+  readonly consumer: {
+    readonly batchSize: "emmett.consumer.batch_size";
+    readonly processorCount: "emmett.consumer.processor_count";
+    readonly delivery: {
+      readonly processorId: "emmett.consumer.delivery.processor_id";
+    };
+  };
+};
+declare const EmmettMetrics: {
+  readonly command: {
+    readonly handlingDuration: "emmett.command.handling.duration";
+  };
+  readonly event: {
+    readonly appendingCount: "emmett.event.appending.count";
+    readonly readingCount: "emmett.event.reading.count";
+  };
+  readonly stream: {
+    readonly readingDuration: "emmett.stream.reading.duration";
+    readonly readingSize: "emmett.stream.reading.size";
+    readonly appendingDuration: "emmett.stream.appending.duration";
+    readonly appendingSize: "emmett.stream.appending.size";
+  };
+  readonly processor: {
+    readonly processingDuration: "emmett.processor.processing.duration";
+    readonly lagEvents: "emmett.processor.lag_events";
+  };
+  readonly workflow: {
+    readonly processingDuration: "emmett.workflow.processing.duration";
+  };
+  readonly consumer: {
+    readonly pollDuration: "emmett.consumer.poll.duration";
+    readonly deliveryDuration: "emmett.consumer.delivery.duration";
+  };
+};
+declare const ScopeTypes: {
+  readonly command: "command";
+  readonly processor: "processor";
+  readonly reactor: "reactor";
+  readonly projector: "projector";
+  readonly workflow: "workflow";
+  readonly consumer: "consumer";
+};
+declare const MessagingSystemName: "emmett";
+//#endregion
+//#region src/observability/options.d.ts
+type WithObservabilityScope<Context> = Context & {
+  observabilityScope: ObservabilityScope;
+};
+type PollTracing = 'off' | 'active' | 'verbose';
+type EmmettObservabilityConfig = ObservabilityConfig<'emmett'> & {
+  pollTracing?: PollTracing;
+  includeMessagePayloads?: boolean;
+};
+type EmmettObservabilityOptions = {
+  observability?: EmmettObservabilityConfig;
+};
+type ConsumerObservabilityConfig = Pick<EmmettObservabilityConfig, 'tracer' | 'meter' | 'pollTracing' | 'attributeTarget'>;
+type WorkflowObservabilityConfig = Pick<EmmettObservabilityConfig, 'tracer' | 'meter' | 'propagation' | 'attributeTarget' | 'includeMessagePayloads'>;
+type ResolvedConsumerObservability = {
+  tracer: Tracer;
+  meter: Meter;
+  pollTracing: PollTracing;
+  attributeTarget: AttributeTarget;
+};
+type ResolvedWorkflowObservability = {
+  tracer: Tracer;
+  meter: Meter;
+  propagation: TracePropagation;
+  attributeTarget: AttributeTarget;
+  includeMessagePayloads: boolean;
+};
+declare const resolveConsumerObservability: (options: {
+  observability?: ConsumerObservabilityConfig;
+} | undefined, parent?: EmmettObservabilityOptions) => ResolvedConsumerObservability;
+declare const resolveWorkflowObservability: (options: {
+  observability?: WorkflowObservabilityConfig;
+} | undefined, parent?: EmmettObservabilityOptions) => ResolvedWorkflowObservability;
+//#endregion
+//#region src/observability/tracer.d.ts
+declare const tracer: {
+  (): void;
+  info(eventName: string, attributes?: Record<string, any>): void;
+  warn(eventName: string, attributes?: Record<string, any>): void;
+  log(eventName: string, attributes?: Record<string, any>): void;
+  error(eventName: string, attributes?: Record<string, any>): void;
+};
+type LogLevel = 'DISABLED' | 'INFO' | 'LOG' | 'WARN' | 'ERROR';
+declare const LogLevel: {
+  DISABLED: LogLevel;
+  INFO: LogLevel;
+  LOG: LogLevel;
+  WARN: LogLevel;
+  ERROR: LogLevel;
+};
+type LogType = 'CONSOLE';
+type LogStyle = 'RAW' | 'PRETTY';
+declare const LogStyle: {
+  RAW: LogStyle;
+  PRETTY: LogStyle;
+};
+//#endregion
+//#region src/eventStore/observability/eventStoreCollector.d.ts
+type EventStoreObservabilityConfig = Pick<EmmettObservabilityConfig, 'tracer' | 'meter' | 'attributeTarget'>;
+type ResolvedEventStoreObservability = {
+  tracer: Tracer;
+  meter: Meter;
+  attributeTarget: AttributeTarget;
+};
+declare const resolveEventStoreObservability: (options: {
+  observability?: EventStoreObservabilityConfig;
+} | undefined, parent?: EmmettObservabilityOptions) => ResolvedEventStoreObservability;
+declare const eventStoreCollector: (observability: ResolvedEventStoreObservability) => {
+  instrumentRead: <EventType extends Event, ReadEventMetadataType extends AnyReadEventMetadata = AnyRecordedMessageMetadata>(streamName: string, fn: () => Promise<ReadStreamResult<EventType, ReadEventMetadataType>>) => Promise<ReadStreamResult<EventType, ReadEventMetadataType>>;
+  instrumentAppend: <Result extends AppendToStreamResult, EventType extends Event = Event>(streamName: string, events: EventType[], fn: () => Promise<Result>) => Promise<Result>;
+};
+//#endregion
+//#region src/observability/collectors/consumerCollector.d.ts
+declare const consumerCollector: (observability: ResolvedConsumerObservability) => {
+  tracePoll: <T>(context: {
+    processorCount: number;
+    batchSize: number;
+    empty: boolean;
+    waitMs?: number;
+  }, fn: (scope: ObservabilityScope) => Promise<T>) => Promise<T>;
+  recordPollMetrics: (durationMs: number, attrs?: Record<string, unknown>) => void;
+  traceDelivery: <T>(scope: ObservabilityScope, processorId: string, fn: () => Promise<T>) => Promise<T>;
+};
+//#endregion
+//#region src/observability/collectors/workflowCollector.d.ts
+type WorkflowCollectorContext = {
+  workflowId: string;
+  workflowType: string;
+  inputType: string;
+};
+declare const workflowCollector: (observability: ResolvedWorkflowObservability) => {
+  startScope: <T>(context: WorkflowCollectorContext, fn: (scope: ObservabilityScope) => Promise<T>) => Promise<T>;
+  recordOutputs: (scope: ObservabilityScope, outputs: {
+    type: string;
+  }[]) => void;
+  recordStateRebuild: (scope: ObservabilityScope, eventCount: number) => void;
+};
+//#endregion
+//#region src/serialization/json/serializer.d.ts
+interface Serializer<Payload, SerializeOptions extends Record<string, unknown> = Record<string, unknown>, DeserializeOptions extends Record<string, unknown> = SerializeOptions> {
+  serialize<T>(object: T, options?: SerializeOptions): Payload;
+  deserialize<T>(payload: Payload, options?: DeserializeOptions): T;
+}
+interface SerializationCodec<T, Payload, SerializeOptions extends Record<string, unknown> = Record<string, unknown>, DeserializeOptions extends Record<string, unknown> = SerializeOptions> {
+  encode(object: T, options?: SerializeOptions): Payload;
+  decode(payload: Payload, options?: DeserializeOptions): T;
 }
-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>[];
+//#endregion
+//#region src/serialization/json/jsonSerializer.d.ts
+interface JSONSerializer<SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> extends Serializer<string, SerializeOptions, DeserializeOptions> {
+  serialize<T>(object: T, options?: SerializeOptions): string;
+  deserialize<T>(payload: string, options?: DeserializeOptions): T;
+}
+type JSONSerializerOptions = {
+  parseDates?: boolean;
+  parseBigInts?: boolean;
+  failOnBigIntSerialization?: boolean;
+  useDefaultDateSerialization?: boolean;
+};
+type JSONSerializeOptions = {
+  replacer?: JSONReplacer;
+} & JSONSerializerOptions;
+type JSONDeserializeOptions = {
+  reviver?: JSONReviver;
+} & JSONSerializerOptions;
+interface JSONCodec<T, SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> extends SerializationCodec<T, string, SerializeOptions, DeserializeOptions> {
+  encode(object: T, options?: SerializeOptions): string;
+  decode(payload: string, options?: DeserializeOptions): T;
+}
+type JSONCodecSerializationOptions<SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> = {
+  serializer?: JSONSerializer<SerializeOptions, DeserializeOptions>;
+  serializerOptions?: never;
+} | {
+  serializer?: never;
+  serializerOptions?: JSONSerializerOptions;
+};
+type JSONSerializationOptions<SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> = {
+  serialization?: {
+    serializer?: JSONSerializer<SerializeOptions, DeserializeOptions>;
+    options?: JSONSerializeOptions | JSONDeserializeOptions;
+  } | undefined;
+};
+type JSONCodecOptions<T, Payload = T, SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> = JSONCodecSerializationOptions<SerializeOptions, DeserializeOptions> & {
+  upcast?: (document: Payload) => T;
+  downcast?: (document: T) => Payload;
+};
+type JSONReplacer = (this: any, key: string, value: any) => any;
+type JSONReviver = (this: any, key: string, value: any, context: JSONReviverContext) => any;
+type JSONReviverContext = {
+  source: string;
+};
+declare const composeJSONReplacers: (...replacers: (JSONReplacer | undefined)[]) => JSONReplacer | undefined;
+declare const composeJSONRevivers: (...revivers: (JSONReviver | undefined)[]) => JSONReviver | undefined;
+declare const JSONReplacer: (opts?: JSONSerializeOptions) => JSONReplacer | undefined;
+declare const JSONReviver: (opts?: JSONDeserializeOptions) => JSONReviver | undefined;
+declare const JSONReplacers: {
+  bigInt: JSONReplacer;
+  date: JSONReplacer;
+};
+declare const JSONRevivers: {
+  bigInt: JSONReviver;
+  date: JSONReviver;
+};
+declare const jsonSerializer: (options?: JSONSerializerOptions & JSONDeserializeOptions & JSONSerializeOptions) => JSONSerializer;
+declare const JSONSerializer: JSONSerializer & {
+  from: <SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions>(options?: JSONSerializationOptions<SerializeOptions, DeserializeOptions>) => JSONSerializer<SerializeOptions, DeserializeOptions>;
+};
+declare const JSONCodec: <T, Payload = T, SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions>(options: JSONCodecOptions<T, Payload, SerializeOptions, DeserializeOptions>) => JSONCodec<T, SerializeOptions, DeserializeOptions>;
+//#endregion
+//#region src/projections/index.d.ts
+type ProjectionHandlingType = 'inline' | 'async';
+type ProjectionHandlerContext<HandlerContext extends DefaultRecord = DefaultRecord> = MessageHandlerContext<HandlerContext>;
+type ProjectionHandler<EventType extends Event = AnyEvent, EventMetaDataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext> = BatchRecordedMessageHandlerWithContext<EventType, EventMetaDataType, HandlerContext>;
+type TruncateProjection<HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext> = (context: HandlerContext) => Promise<void>;
+type ProjectionInitOptions<HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext> = {
+  version: number;
+  status?: 'active' | 'inactive';
+  registrationType: ProjectionHandlingType;
+  context: HandlerContext;
+};
+type ProjectionDefinition<EventType extends Event = AnyEvent, EventMetaDataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext, EventPayloadType extends Event = EventType> = {
+  name?: string;
+  version?: number;
+  kind?: string;
+  canHandle: CanHandle<EventType>;
+  handle: ProjectionHandler<EventType, EventMetaDataType, HandlerContext>;
+  truncate?: TruncateProjection<HandlerContext>;
+  init?: (options: ProjectionInitOptions<HandlerContext>) => void | Promise<void>;
+  eventsOptions?: {
+    schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+  };
+} & JSONSerializationOptions;
+type ProjectionRegistration<HandlingType extends ProjectionHandlingType, ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext> = {
+  type: HandlingType;
+  projection: ProjectionDefinition<AnyEvent, ReadEventMetadataType, HandlerContext, AnyEvent>;
+};
+declare const filterProjections: <ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext>(type: ProjectionHandlingType, projections: ProjectionRegistration<ProjectionHandlingType, ReadEventMetadataType, HandlerContext>[]) => ProjectionDefinition<AnyEvent, ReadEventMetadataType, HandlerContext, AnyEvent>[];
+declare const projection: <EventType extends Event = Event, EventMetaDataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext, EventPayloadType extends Event = EventType>(definition: ProjectionDefinition<EventType, EventMetaDataType, HandlerContext, EventPayloadType>) => ProjectionDefinition<EventType, EventMetaDataType, HandlerContext, EventPayloadType>;
+declare const inlineProjections: <ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext>(definitions: ProjectionDefinition<any, ReadEventMetadataType, HandlerContext>[]) => ProjectionRegistration<"inline", ReadEventMetadataType, HandlerContext>[];
+declare const asyncProjections: <ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext>(definitions: ProjectionDefinition<AnyEvent, ReadEventMetadataType, HandlerContext>[]) => ProjectionRegistration<"inline", ReadEventMetadataType, HandlerContext>[];
 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>[];
-};
-
+  inline: <ReadEventMetadataType extends AnyReadEventMetadata = AnyRecordedMessageMetadata, HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext<DefaultRecord>>(definitions: ProjectionDefinition<any, ReadEventMetadataType, HandlerContext>[]) => ProjectionRegistration<"inline", ReadEventMetadataType, HandlerContext>[];
+  async: <ReadEventMetadataType extends AnyReadEventMetadata = AnyRecordedMessageMetadata, HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext<DefaultRecord>>(definitions: ProjectionDefinition<AnyEvent, ReadEventMetadataType, HandlerContext>[]) => ProjectionRegistration<"inline", ReadEventMetadataType, HandlerContext>[];
+};
+//#endregion
+//#region src/processors/observability/processorCollector.d.ts
+type ProcessorObservabilityConfig = Pick<EmmettObservabilityConfig, 'tracer' | 'meter' | 'propagation' | 'attributeTarget' | 'includeMessagePayloads'>;
+type ResolvedProcessorObservability = {
+  tracer: Tracer;
+  meter: Meter;
+  propagation: TracePropagation;
+  attributeTarget: AttributeTarget;
+  includeMessagePayloads: boolean;
+};
+declare const resolveProcessorObservability: (options: {
+  observability?: ProcessorObservabilityConfig;
+} | undefined, parent?: EmmettObservabilityOptions) => ResolvedProcessorObservability;
+type ProcessorCollectorContext = {
+  processorId: string;
+  type: string;
+  checkpoint: ProcessorCheckpoint | null;
+};
+declare const processorCollector: (observability: ResolvedProcessorObservability) => {
+  startScope: <MessageType extends Message = Message, MessageMetadataType extends AnyReadEventMetadata = AnyRecordedMessageMetadata, T = void>(context: ProcessorCollectorContext, messages: RecordedMessage<MessageType, MessageMetadataType>[], fn: (scope: ObservabilityScope) => Promise<T>) => Promise<T>;
+  startMessageScope: <MessageType extends Message = Message, MessageMetadataType extends AnyReadEventMetadata = AnyRecordedMessageMetadata, T = void>(context: ProcessorCollectorContext & {
+    archetypeType: string;
+  }, message: RecordedMessage<MessageType, MessageMetadataType>, batchCtx: SpanContext, fn: (scope: ObservabilityScope) => Promise<T>) => Promise<T>;
+  recordLag: (processorId: string, lag: number) => void;
+};
+//#endregion
+//#region src/processors/processors.d.ts
 type CurrentMessageProcessorPosition = {
-    lastCheckpoint: ProcessorCheckpoint;
+  lastCheckpoint: ProcessorCheckpoint;
 } | 'BEGINNING' | 'END';
-type GetCheckpoint<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata> = (message: RecordedMessage<MessageType, MessageMetadataType>) => ProcessorCheckpoint | null;
-declare const getCheckpoint: <MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata>(message: RecordedMessage<MessageType, MessageMetadataType>) => ProcessorCheckpoint | null;
 declare const wasMessageHandled: <MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata>(message: RecordedMessage<MessageType, MessageMetadataType>, checkpoint: ProcessorCheckpoint | null) => boolean;
 type MessageProcessorStartFrom = CurrentMessageProcessorPosition | '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> = {
-    id: string;
-    instanceId: string;
-    type: string;
-    canHandle?: string[];
-    init: (options: Partial<HandlerContext>) => Promise<void>;
-    start: (options: Partial<HandlerContext>) => Promise<CurrentMessageProcessorPosition | undefined>;
-    close: (closeOptions: Partial<HandlerContext>) => Promise<void>;
-    isActive: boolean;
-    handle: BatchRecordedMessageHandlerWithContext<MessageType, MessageMetadataType, Partial<HandlerContext>>;
+  PROJECTOR: MessageProcessorType;
+  REACTOR: MessageProcessorType;
+};
+type MessageProcessor<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends MessageHandlerContext | undefined = undefined> = {
+  id: string;
+  instanceId: string;
+  type: string;
+  canHandle?: string[];
+  init: (options?: Partial<HandlerContext>) => Promise<void>;
+  start: (options?: Partial<HandlerContext>) => Promise<CurrentMessageProcessorPosition | 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> = {
-    read: ReadProcessorCheckpoint<HandlerContext>;
-    store: StoreProcessorCheckpoint<MessageType, MessageMetadataType, 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> = {
-    type?: string;
-    processorId: string;
-    processorInstanceId?: string;
-    version?: number;
-    partition?: string;
-    startFrom?: MessageProcessorStartFrom;
-    stopAfter?: (message: RecordedMessage<MessageType, MessageMetadataType>) => boolean;
-    processingScope?: MessageProcessingScope<HandlerContext>;
-    checkpoints?: Checkpointer<MessageType, MessageMetadataType, HandlerContext>;
-    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;
+  result: {
+    skip: (options?: {
+      reason?: string;
+    }) => SingleMessageHandlerResult;
+    stop: (options?: {
+      reason?: string;
+      error?: EmmettError;
+    }) => SingleMessageHandlerResult;
+  };
+};
+type MessageProcessingScope<HandlerContext extends MessageHandlerContext | undefined = undefined> = <Result = SingleMessageHandlerResult>(handler: (context: HandlerContext) => Result | Promise<Result>, partialContext: WithObservabilityScope<Partial<HandlerContext>>) => Result | Promise<Result>;
+type ProcessorHooks<HandlerContext extends MessageHandlerContext = MessageHandlerContext> = {
+  onInit?: OnReactorInitHook<HandlerContext>;
+  onStart?: OnReactorStartHook<HandlerContext>;
+  onClose?: OnReactorCloseHook<HandlerContext>;
+};
+type BaseMessageProcessorOptions<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends MessageHandlerContext = MessageHandlerContext> = {
+  type?: string;
+  processorId: string;
+  processorInstanceId?: string;
+  version?: number;
+  partition?: string;
+  startFrom?: MessageProcessorStartFrom;
+  stopAfter?: (message: RecordedMessage<MessageType, MessageMetadataType>) => boolean;
+  processingScope?: MessageProcessingScope<HandlerContext>;
+  checkpoints?: Checkpointer<MessageType, MessageMetadataType, HandlerContext>;
+  canHandle?: CanHandle<MessageType>;
+  hooks?: ProcessorHooks<HandlerContext>;
+} & JSONSerializationOptions & {
+  observability?: ProcessorObservabilityConfig;
+};
+type HandlerOptions<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends MessageHandlerContext = MessageHandlerContext> = {
+  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, MessagePayloadType extends AnyMessage = MessageType> = BaseMessageProcessorOptions<MessageType, MessageMetadataType, HandlerContext> & HandlerOptions<MessageType, MessageMetadataType, HandlerContext> & {
-    messageOptions?: {
-        schema?: {
-            versioning?: {
-                upcast?: (event: MessagePayloadType) => MessageType;
-            };
-        };
+  eachMessage?: never;
+  eachBatch: BatchRecordedMessageHandlerWithContext<MessageType, MessageMetadataType, HandlerContext>;
+};
+type OnReactorInitHook<HandlerContext extends MessageHandlerContext = MessageHandlerContext> = (context: HandlerContext) => Promise<void>;
+type OnReactorStartHook<HandlerContext extends MessageHandlerContext = MessageHandlerContext> = (context: HandlerContext) => Promise<void>;
+type OnReactorCloseHook<HandlerContext extends MessageHandlerContext = MessageHandlerContext> = (context: HandlerContext) => Promise<void>;
+type ReactorOptions<MessageType extends AnyMessage = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends MessageHandlerContext = MessageHandlerContext, MessagePayloadType extends AnyMessage = MessageType> = BaseMessageProcessorOptions<MessageType, MessageMetadataType, HandlerContext> & 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, EventPayloadType extends Event = EventType> = Omit<BaseMessageProcessorOptions<EventType, MessageMetadataType, HandlerContext>, 'type' | 'processorId'> & {
-    processorId?: string;
+type ProjectorOptions<EventType extends AnyEvent = AnyEvent, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends MessageHandlerContext = MessageHandlerContext, EventPayloadType extends Event = EventType> = Omit<BaseMessageProcessorOptions<EventType, MessageMetadataType, HandlerContext>, 'type' | 'processorId'> & {
+  processorId?: string;
 } & {
-    truncateOnStart?: boolean;
-    projection: ProjectionDefinition<EventType, MessageMetadataType, HandlerContext, EventPayloadType>;
+  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 ProcessorCheckpoint = Brand<string, 'ProcessorCheckpoint'>;
-declare const bigIntProcessorCheckpoint: (value: bigint) => ProcessorCheckpoint;
-declare const parseBigIntProcessorCheckpoint: (value: ProcessorCheckpoint) => bigint;
-type ReadProcessorCheckpointResult = {
-    lastCheckpoint: ProcessorCheckpoint | null;
-};
-type ReadProcessorCheckpoint<HandlerContext extends DefaultRecord = DefaultRecord> = (options: {
-    processorId: string;
-    partition?: string;
-}, context: HandlerContext) => Promise<ReadProcessorCheckpointResult>;
-type StoreProcessorCheckpointResult = {
-    success: true;
-    newCheckpoint: ProcessorCheckpoint | null;
-} | {
-    success: false;
-    reason: 'IGNORED' | 'MISMATCH' | 'CURRENT_AHEAD';
-};
-type StoreProcessorCheckpoint<MessageType extends Message = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends DefaultRecord | undefined = undefined> = (options: {
-    message: RecordedMessage<MessageType, MessageMetadataType>;
-    processorId: string;
-    version: number | undefined;
-    lastCheckpoint: ProcessorCheckpoint | null;
-    partition?: string;
-}, context: HandlerContext) => Promise<StoreProcessorCheckpointResult>;
+declare const defaultProcessingMessageProcessingScope: <HandlerContext = never, Result = SingleMessageHandlerResult>(handler: (context: WithObservabilityScope<HandlerContext>) => Result | Promise<Result>, partialContext: WithObservabilityScope<Partial<HandlerContext>>) => Result | Promise<Result>;
 declare const defaultProcessorVersion = 1;
 declare const defaultProcessorPartition = "emt:default";
 declare const getProcessorInstanceId: (processorId: string) => string;
 declare const getProjectorId: (options: {
-    projectionName: string;
+  projectionName: string;
 }) => string;
-declare const reactor: <MessageType extends Message = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends DefaultRecord = DefaultRecord, MessagePayloadType extends Message = MessageType>(options: ReactorOptions<MessageType, MessageMetadataType, HandlerContext, MessagePayloadType>) => MessageProcessor<MessageType, MessageMetadataType, HandlerContext>;
-declare const projector: <EventType extends Event = Event, EventMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends DefaultRecord = DefaultRecord, EventPayloadType extends Event = EventType>(options: ProjectorOptions<EventType, EventMetaDataType, HandlerContext, EventPayloadType>) => MessageProcessor<EventType, EventMetaDataType, HandlerContext>;
-
-type InMemoryProcessorHandlerContext = {
-    database: InMemoryDatabase;
-};
+declare const reactor: <MessageType extends Message = AnyMessage, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends MessageHandlerContext = MessageHandlerContext, MessagePayloadType extends Message = MessageType>(options: ReactorOptions<MessageType, MessageMetadataType, HandlerContext, MessagePayloadType>) => MessageProcessor<MessageType, MessageMetadataType, HandlerContext>;
+declare const projector: <EventType extends Event = Event, EventMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends MessageHandlerContext = MessageHandlerContext, EventPayloadType extends Event = EventType>(options: ProjectorOptions<EventType, EventMetaDataType, HandlerContext, EventPayloadType>) => MessageProcessor<EventType, EventMetaDataType, HandlerContext>;
+//#endregion
+//#region src/processors/inMemoryProcessors.d.ts
+type InMemoryProcessorHandlerContext = MessageHandlerContext<{
+  database: InMemoryDatabase;
+}>;
 type InMemoryProcessor<MessageType extends AnyMessage = AnyMessage> = MessageProcessor<MessageType, ReadEventMetadataWithGlobalPosition, InMemoryProcessorHandlerContext> & {
-    database: InMemoryDatabase;
+  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;
+  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;
+  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>;
-
+//#endregion
+//#region src/typing/message.d.ts
 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;
+  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>;
+  metadata: CombinedMessageMetadata<MessageType, MessageMetaDataType>;
 };
 type RecordedMessage<MessageType extends Message = Message, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata> = CombineMetadata<MessageType, MessageMetaDataType> & {
-    kind: NonNullable<MessageKindOf<Message>>;
+  kind: NonNullable<MessageKindOf<Message>>;
 };
 type CommonRecordedMessageMetadata = Readonly<{
-    messageId: string;
-    streamPosition: StreamPosition;
-    streamName: string;
-    checkpoint?: ProcessorCheckpoint | null;
+  messageId: string;
+  streamPosition: StreamPosition;
+  streamName: string;
+  checkpoint?: ProcessorCheckpoint | null;
+  correlationId?: string;
+  causationId?: string;
+  traceId?: string;
+  spanId?: string;
 }>;
 type WithGlobalPosition = Readonly<{
-    globalPosition: GlobalPosition;
+  globalPosition: GlobalPosition;
 }>;
 type RecordedMessageMetadata<HasGlobalPosition = undefined> = CommonRecordedMessageMetadata & (HasGlobalPosition extends undefined ? {} : WithGlobalPosition);
 type AnyRecordedMessage = Message<any, any, any>;
 type AnyRecordedMessageMetadata = RecordedMessageMetadata<any>;
 type RecordedMessageMetadataWithGlobalPosition = RecordedMessageMetadata<true>;
 type RecordedMessageMetadataWithoutGlobalPosition = RecordedMessageMetadata<undefined>;
-
+//#endregion
+//#region src/typing/event.d.ts
 type StreamPosition = bigint;
-type GlobalPosition = bigint;
+type GlobalPosition = string;
 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;
 } : {
-    type: EventType;
-    data: EventData;
-    metadata: EventMetaData;
+  type: EventType;
+  data: EventData;
+  metadata: EventMetaData;
 }> & {
-    readonly kind?: 'Event';
+  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;
+  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;
 } : {
-    type: EventType;
-    data: EventData;
-    metadata: EventMetaData;
+  type: EventType;
+  data: EventData;
+  metadata: EventMetaData;
 }> & {
-    readonly kind?: 'Event';
+  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>;
@@ -403,42 +709,60 @@ type ReadEventMetadata<HasGlobalPosition = undefined> = RecordedMessageMetadata<
 type AnyReadEventMetadata = AnyRecordedMessageMetadata;
 type ReadEventMetadataWithGlobalPosition = RecordedMessageMetadataWithGlobalPosition;
 type ReadEventMetadataWithoutGlobalPosition = RecordedMessageMetadataWithoutGlobalPosition;
-
-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;
+//#endregion
+//#region src/typing/messageHandling.d.ts
+type MessageHandlerContext<HandlerContext extends DefaultRecord = DefaultRecord> = WithObservabilityScope<HandlerContext>;
+type SingleRawMessageHandlerWithoutContext<MessageType extends Message = AnyMessage> = (message: MessageType) => Promise<SingleMessageHandlerResult> | SingleMessageHandlerResult;
+type SingleRecordedMessageHandlerWithoutContext<MessageType extends Message = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata> = (message: RecordedMessage<MessageType, MessageMetaDataType>) => Promise<SingleMessageHandlerResult> | SingleMessageHandlerResult;
 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 SingleRawMessageHandlerWithContext<MessageType extends Message = AnyMessage, HandlerContext extends DefaultRecord | undefined = undefined> = (message: MessageType, context: HandlerContext) => Promise<SingleMessageHandlerResult> | SingleMessageHandlerResult;
+type SingleRecordedMessageHandlerWithContext<MessageType extends Message = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends DefaultRecord | undefined = undefined> = (message: RecordedMessage<MessageType, MessageMetaDataType>, context: HandlerContext) => Promise<SingleMessageHandlerResult> | SingleMessageHandlerResult;
 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 BatchRawMessageHandlerWithoutContext<MessageType extends Message = AnyMessage> = (messages: MessageType[]) => Promise<BatchMessageHandlerResult> | BatchMessageHandlerResult;
+type BatchRecordedMessageHandlerWithoutContext<MessageType extends Message = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata> = (messages: RecordedMessage<MessageType, MessageMetaDataType>[]) => Promise<BatchMessageHandlerResult> | BatchMessageHandlerResult;
 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 BatchRawMessageHandlerWithContext<MessageType extends Message = AnyMessage, HandlerContext extends DefaultRecord | undefined = undefined> = (messages: MessageType[], context: HandlerContext) => Promise<BatchMessageHandlerResult> | BatchMessageHandlerResult;
+type BatchRecordedMessageHandlerWithContext<MessageType extends Message = AnyMessage, MessageMetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends DefaultRecord = DefaultRecord> = (messages: RecordedMessage<MessageType, MessageMetaDataType>[], context: HandlerContext) => Promise<BatchMessageHandlerResult> | BatchMessageHandlerResult;
 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 SingleMessageHandlerResult = void | {
+  type: 'ACK';
+} | {
+  type: 'SKIP';
+  reason?: string;
 } | {
-    type: 'STOP';
-    reason?: string;
-    error?: EmmettError;
+  type: 'STOP';
+  reason?: string;
+  error?: EmmettError;
 };
-
+type BatchMessageHandlerResult = void | {
+  type: 'ACK';
+} | {
+  type: 'SKIP';
+  reason?: string;
+  lastSuccessfulMessage: AnyRecordedMessage;
+} | {
+  type: 'STOP';
+  reason?: string;
+  error?: EmmettError;
+  lastSuccessfulMessage?: AnyRecordedMessage;
+};
+//#endregion
+//#region src/typing/decider.d.ts
 type Decider<State, CommandType extends Command, StreamEvent extends Event> = {
-    decide: (command: CommandType, state: State) => StreamEvent | StreamEvent[];
-    evolve: (currentState: State, event: StreamEvent) => State;
-    initialState: () => State;
+  decide: (command: CommandType, state: State) => StreamEvent | StreamEvent[];
+  evolve: (currentState: State, event: StreamEvent) => State;
+  initialState: () => State;
 };
-
+//#endregion
+//#region src/typing/index.d.ts
 type Brand<K, T> = K & {
-    readonly __brand: T;
+  readonly __brand: T;
 };
 type Flavour<K, T> = K & {
-    readonly __brand?: T;
+  readonly __brand?: T;
 };
 type DefaultRecord = Record<string, unknown>;
 type AnyRecord = Record<string, any>;
@@ -447,7 +771,8 @@ declare const emmettPrefix = "emt";
 declare const globalTag = "global";
 declare const defaultTag = "emt:default";
 declare const unknownTag = "emt:unknown";
-
+//#endregion
+//#region src/eventStore/expectedVersion.d.ts
 type ExpectedStreamVersion = ExpectedStreamVersionWithValue | ExpectedStreamVersionGeneral;
 type ExpectedStreamVersionWithValue = Flavour<StreamPosition, 'StreamVersion'>;
 type ExpectedStreamVersionGeneral = Flavour<'STREAM_EXISTS' | 'STREAM_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK', 'StreamVersion'>;
@@ -457,187 +782,198 @@ declare const NO_CONCURRENCY_CHECK: ExpectedStreamVersionGeneral;
 declare const matchesExpectedVersion: (current: StreamPosition | undefined, expected: ExpectedStreamVersion, defaultVersion: StreamPosition) => boolean;
 declare const assertExpectedVersionMatchesCurrent: (current: StreamPosition, expected: ExpectedStreamVersion | undefined, defaultVersion: StreamPosition) => void;
 declare class ExpectedVersionConflictError extends ConcurrencyError {
-    constructor(current: StreamPosition, expected: ExpectedStreamVersion);
+  constructor(current: StreamPosition, expected: ExpectedStreamVersion);
 }
 declare const isExpectedVersionConflictError: (error: unknown) => error is ExpectedVersionConflictError;
-
+//#endregion
+//#region src/eventStore/eventStore.d.ts
 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>>;
-    readStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, options?: ReadStreamOptions<EventType, EventPayloadType>): Promise<ReadStreamResult<EventType, ReadEventMetadataType>>;
-    appendToStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, events: EventType[], options?: AppendToStreamOptions<EventType, EventPayloadType>): Promise<AppendToStreamResult>;
-    streamExists(streamName: string): Promise<StreamExistsResult>;
+  aggregateStream<State, EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, options: AggregateStreamOptions<State, EventType, ReadEventMetadataType, EventPayloadType>): Promise<AggregateStreamResult<State>>;
+  readStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, options?: ReadStreamOptions<EventType, EventPayloadType>): Promise<ReadStreamResult<EventType, ReadEventMetadataType>>;
+  appendToStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, events: EventType[], options?: AppendToStreamOptions<EventType, EventPayloadType>): Promise<AppendToStreamResult>;
+  streamExists(streamName: string): Promise<StreamExistsResult>;
 }
 type EventStoreReadEventMetadata<Store extends EventStore> = Store extends EventStore<infer T> ? T extends CommonReadEventMetadata ? T extends WithGlobalPosition ? ReadEventMetadata<true> & T : ReadEventMetadata<undefined> & T : never : never;
 type EventStoreSession<EventStoreType extends EventStore> = {
-    eventStore: EventStoreType;
-    close: () => Promise<void>;
+  eventStore: EventStoreType;
+  close: () => Promise<void>;
 };
 interface EventStoreSessionFactory<EventStoreType extends EventStore> {
-    withSession<T = unknown>(callback: (session: EventStoreSession<EventStoreType>) => Promise<T>): Promise<T>;
+  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;
-    };
+  versioning?: {
+    upcast?: (event: StoredEvent) => StreamEvent;
+  };
 };
 type EventStoreAppendSchemaOptions<StreamEvent extends Event = Event, StoredEvent extends Event = StreamEvent> = {
-    versioning?: {
-        downcast?: (event: StreamEvent) => StoredEvent;
-    };
+  versioning?: {
+    downcast?: (event: StreamEvent) => StoredEvent;
+  };
 };
 type EventStoreSchemaOptions<StreamEvent extends Event = Event, StoredEvent extends Event = StreamEvent> = EventStoreReadSchemaOptions<StreamEvent, StoredEvent> & EventStoreAppendSchemaOptions<StreamEvent, StoredEvent>;
 type ReadStreamOptions<EventType extends Event = Event, EventPayloadType extends Event = EventType> = {
-    from?: StreamPosition;
-    to?: StreamPosition;
-    maxCount?: bigint;
-    expectedStreamVersion?: ExpectedStreamVersion;
-    schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
-};
+  from?: StreamPosition;
+  to?: StreamPosition;
+  maxCount?: bigint;
+  expectedStreamVersion?: ExpectedStreamVersion;
+  schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+} & JSONSerializationOptions;
 type ReadStreamResult<EventType extends Event, ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata> = {
-    currentStreamVersion: StreamPosition;
-    events: ReadEvent<EventType, ReadEventMetadataType>[];
-    streamExists: boolean;
+  currentStreamVersion: StreamPosition;
+  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<EventType, EventPayloadType>;
+  evolve: Evolve<State, EventType, ReadEventMetadataType>;
+  initialState: () => State;
+  read?: ReadStreamOptions<EventType, EventPayloadType>;
 };
 type AggregateStreamResult<State> = {
-    currentStreamVersion: StreamPosition;
-    state: State;
-    streamExists: boolean;
+  currentStreamVersion: StreamPosition;
+  state: State;
+  streamExists: boolean;
 };
 type AggregateStreamResultWithGlobalPosition<State> = (AggregateStreamResult<State> & {
-    streamExists: true;
-    lastEventGlobalPosition: GlobalPosition;
+  streamExists: true;
+  lastEventGlobalPosition: ProcessorCheckpoint;
 }) | (AggregateStreamResult<State> & {
-    streamExists: false;
+  streamExists: false;
 });
-type AggregateStreamResultOfEventStore<Store extends EventStore> = Store['aggregateStream'] extends (...args: any[]) => Promise<infer R> ? R : never;
+type AggregateStreamResultOfEventStore<Store extends EventStore> = Store['aggregateStream'] extends ((...args: any[]) => Promise<infer R>) ? R : never;
 type AppendToStreamOptions<EventType extends Event = Event, EventPayloadType extends Event = EventType> = {
-    expectedStreamVersion?: ExpectedStreamVersion;
-    schema?: EventStoreAppendSchemaOptions<EventType, EventPayloadType>;
+  expectedStreamVersion?: ExpectedStreamVersion;
+  schema?: EventStoreAppendSchemaOptions<EventType, EventPayloadType> & JSONSerializationOptions;
+  correlationId?: string;
+  causationId?: string;
+  traceId?: string;
+  spanId?: string;
 };
 type AppendToStreamResult = {
-    nextExpectedStreamVersion: StreamPosition;
-    createdNewStream: boolean;
+  nextExpectedStreamVersion: StreamPosition;
+  createdNewStream: boolean;
 };
 type AppendToStreamResultWithGlobalPosition = AppendToStreamResult & {
-    lastEventGlobalPosition: GlobalPosition;
+  lastEventGlobalPosition: ProcessorCheckpoint;
 };
-type AppendStreamResultOfEventStore<Store extends EventStore> = Store['appendToStream'] extends (...args: any[]) => Promise<infer R> ? R : never;
+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?: {
     /**
-     * Pluggable set of hooks informing about the event store internal behaviour.
+     * 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>}
      */
-    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>;
-    };
+    onAfterCommit?: AfterEventStoreCommitHandler<Store, HandlerContext>;
+  };
 };
-
+//#endregion
+//#region src/eventStore/afterCommit/afterEventStoreCommitHandler.d.ts
 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>;
+  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>;
-
+//#endregion
+//#region src/messageBus/index.d.ts
 interface CommandSender {
-    send<CommandType extends Command = Command>(command: CommandType): Promise<void>;
+  send<CommandType extends Command = Command>(command: CommandType): Promise<void>;
 }
 interface EventsPublisher {
-    publish<EventType extends Event = Event>(event: EventType): Promise<void>;
+  publish<EventType extends Event = Event>(event: EventType): Promise<void>;
 }
 type ScheduleOptions = {
-    afterInMs: number;
+  afterInMs: number;
 } | {
-    at: Date;
+  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> {
+  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;
+  schedule<MessageType extends Command | Event>(message: MessageType, when?: ScheduleOptions): void;
 }
 interface CommandProcessor {
-    handle<CommandType extends Command>(commandHandler: SingleMessageHandler<CommandType>, ...commandTypes: CommandTypeOf<CommandType>[]): void;
+  handle<CommandType extends Command>(commandHandler: SingleMessageHandler<CommandType>, ...commandTypes: CommandTypeOf<CommandType>[]): void;
 }
 interface EventSubscription {
-    subscribe<EventType extends Event>(eventHandler: SingleMessageHandler<EventType>, ...eventTypes: EventTypeOf<EventType>[]): void;
+  subscribe<EventType extends Event>(eventHandler: SingleMessageHandler<EventType>, ...eventTypes: EventTypeOf<EventType>[]): void;
 }
 type ScheduledMessage = {
-    message: Message;
-    options?: ScheduleOptions;
+  message: Message;
+  options?: ScheduleOptions;
 };
 interface ScheduledMessageProcessor {
-    dequeue(): ScheduledMessage[];
+  dequeue(): ScheduledMessage[];
 }
 type MessageSubscription = EventSubscription | CommandProcessor;
 declare const getInMemoryMessageBus: () => MessageBus & EventSubscription & CommandProcessor & ScheduledMessageProcessor;
-
+//#endregion
+//#region src/eventStore/afterCommit/forwardToMessageBus.d.ts
 declare const forwardToMessageBus: <Store extends EventStore, HandlerContext extends DefaultRecord | undefined = undefined>(eventPublisher: EventsPublisher) => AfterEventStoreCommitHandler<Store, HandlerContext>;
-
+//#endregion
+//#region src/eventStore/events/index.d.ts
 declare const GlobalStreamCaughtUpType = "__emt:GlobalStreamCaughtUp";
 type GlobalStreamCaughtUp = Event<'__emt:GlobalStreamCaughtUp', {
-    globalPosition: bigint;
+  globalPosition: GlobalPosition;
 }, {
-    globalPosition: bigint;
+  globalPosition: GlobalPosition;
 }>;
 declare const isGlobalStreamCaughtUp: (event: Event) => event is GlobalStreamCaughtUp;
-declare const caughtUpEventFrom: (position: bigint) => (event: ReadEvent<Event, ReadEventMetadataWithGlobalPosition>) => event is ReadEvent<GlobalStreamCaughtUp, ReadEventMetadataWithGlobalPosition>;
+declare const caughtUpEventFrom: (position: string) => (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;
-
+//#endregion
+//#region src/eventStore/inMemoryEventStore.d.ts
 declare const InMemoryEventStoreDefaultStreamVersion = 0n;
 type InMemoryEventStore = EventStore<ReadEventMetadataWithGlobalPosition> & {
-    database: InMemoryDatabase;
+  database: InMemoryDatabase;
 };
 type InMemoryReadEventMetadata = ReadEventMetadataWithGlobalPosition;
-type InMemoryProjectionHandlerContext = {
-    eventStore?: InMemoryEventStore;
-    database?: InMemoryDatabase;
-};
+type InMemoryProjectionHandlerContext = MessageHandlerContext<{
+  eventStore?: InMemoryEventStore;
+  database?: InMemoryDatabase;
+}>;
 type InMemoryEventStoreOptions = DefaultEventStoreOptions<InMemoryEventStore> & {
-    projections?: ProjectionRegistration<'inline', InMemoryReadEventMetadata, InMemoryProjectionHandlerContext>[];
-    database?: InMemoryDatabase;
+  projections?: ProjectionRegistration<'inline', InMemoryReadEventMetadata, InMemoryProjectionHandlerContext>[];
+  database?: InMemoryDatabase;
+  observability?: EventStoreObservabilityConfig;
 };
 type InMemoryReadEvent<EventType extends Event = Event> = ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>;
 declare const getInMemoryEventStore: (eventStoreOptions?: InMemoryEventStoreOptions) => InMemoryEventStore;
-
+//#endregion
+//#region src/eventStore/projections/inMemory/inMemoryProjection.d.ts
 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'];
+  projections: InMemoryProjectionDefinition<EventType>[];
+  events: ReadEvent<EventType, InMemoryReadEventMetadata>[];
+  database: InMemoryDatabase;
+  eventStore?: InMemoryProjectionHandlerContext['eventStore'];
+  observability: ResolvedEventStoreObservability;
 };
 /**
  * Handles projections for the InMemoryEventStore
@@ -648,30 +984,34 @@ type InMemoryWithNotNullDocumentEvolve<DocumentType extends Record<string, unkno
 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;
-    }>;
+  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>;
+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;
+  canHandle: CanHandle<EventType>;
+  collectionName: string;
+  getDocumentId: (event: ReadEvent<EventType>) => string;
 } & ({
-    evolve: InMemoryWithNullableDocumentEvolve<DocumentType, EventType>;
+  evolve: InMemoryWithNullableDocumentEvolve<DocumentType, EventType>;
 } | {
-    evolve: InMemoryWithNotNullDocumentEvolve<DocumentType, EventType>;
-    initialState: () => DocumentType;
+  evolve: InMemoryWithNotNullDocumentEvolve<DocumentType, EventType>;
+  initialState: () => DocumentType;
 });
 /**
  * Creates a projection that handles events across multiple streams
@@ -681,279 +1021,298 @@ declare const inMemoryMultiStreamProjection: <DocumentType extends Record<string
  * 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;
+  canHandle: CanHandle<EventType>;
+  getDocumentId?: (event: ReadEvent<EventType>) => string;
+  collectionName: string;
 } & ({
-    evolve: InMemoryWithNullableDocumentEvolve<DocumentType, EventType>;
+  evolve: InMemoryWithNullableDocumentEvolve<DocumentType, EventType>;
 } | {
-    evolve: InMemoryWithNotNullDocumentEvolve<DocumentType, EventType>;
-    initialState: () => DocumentType;
+  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>;
-
+//#endregion
+//#region src/testing/assertions.d.ts
 declare class AssertionError extends Error {
-    constructor(message: string);
+  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 assertThrowsAsync: <TError extends Error>(fun: () => Promise<unknown>, errorCheck?: (error: TError) => boolean) => Promise<TError>;
+declare const assertThrows: <TError extends Error>(fun: () => void, errorCheck?: (error: TError) => 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;
+  isEqualTo: (other: T) => void;
 };
-declare const assertDefined: (value: unknown, message?: string | Error) => asserts value;
+declare function assertDefined<T>(value: T, message?: string | Error): asserts value is NonNullable<T>;
+declare function assertUndefined<T>(value: T | undefined, message?: string | Error): asserts value is undefined;
 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;
+declare function assertIsNotNull<T extends object | string | bigint | boolean | number>(result: T | null): asserts result is T;
+declare function assertIsNull<T extends object | string | bigint | boolean | number>(result: T | null): asserts result is null;
 type Call = {
-    arguments: unknown[];
-    result: unknown;
-    target: unknown;
-    this: unknown;
+  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[];
-    };
+  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;
+  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>;
-};
-
+  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>;
+};
+//#endregion
+//#region src/testing/deciderSpecification.d.ts
 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;
-    };
+  when: (command: Command) => {
+    then: (expectedEvents: Event | Event[]) => void;
+    thenNothingHappened: () => void;
+    thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<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>;
+  };
 };
 declare const DeciderSpecification: {
-    for: typeof deciderSpecificationFor;
+  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;
+  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;
+  decide: (command: Command, state: State) => Promise<Event | Event[]>;
+  evolve: (state: State, event: Event) => State;
+  initialState: () => State;
 }): AsyncDeciderSpecification<Command, Event>;
-
+//#endregion
+//#region src/workflows/workflow.d.ts
+type Workflow<Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, Name extends string = string> = {
+  name: Name;
+  decide: (command: Input, state: State) => WorkflowOutput<Output>;
+  evolve: (currentState: State, event: WorkflowEvent<Input | Output>) => State;
+  initialState: () => State;
+};
 type WorkflowEvent<Output extends AnyEvent | AnyCommand> = Extract<Output, {
-    kind?: 'Event';
+  kind?: 'Event';
 }>;
 type WorkflowCommand<Output extends AnyEvent | AnyCommand> = Extract<Output, {
-    kind?: 'Command';
+  kind?: 'Command';
 }>;
 type WorkflowMessageAction = 'InitiatedBy' | 'Received' | 'Sent' | 'Published' | 'Scheduled';
 type WorkflowInputMessageMetadata = Readonly<{
-    originalMessageId: string | undefined;
-    input: true;
-    action?: Extract<WorkflowMessageAction, 'InitiatedBy' | 'Received'>;
+  originalMessageId: string | undefined;
+  input: true;
+  action?: Extract<WorkflowMessageAction, 'InitiatedBy' | 'Received'>;
 }>;
 type WorkflowOutputMessageMetadata = Readonly<{
-    action?: Extract<WorkflowMessageAction, 'Sent' | 'Published' | 'Scheduled'>;
+  action?: Extract<WorkflowMessageAction, 'Sent' | 'Published' | 'Scheduled'>;
 }>;
 type WorkflowOutput<Output extends AnyEvent | AnyCommand | EmmettError> = Output | Output[];
-type Workflow<Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, Name extends string = string> = {
-    name: Name;
-    decide: (command: Input, state: State) => WorkflowOutput<Output>;
-    evolve: (currentState: State, event: WorkflowEvent<Input | Output>) => State;
-    initialState: () => State;
-};
 declare const Workflow: <Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand>(workflow: Workflow<Input, State, Output>) => Workflow<Input, State, Output>;
-
+//#endregion
+//#region src/testing/workflowSpecification.d.ts
 type WorkflowSpecification<Input extends AnyEvent | AnyCommand, Output extends AnyEvent | AnyCommand> = (givenEvents: WorkflowEvent<Input | Output> | WorkflowEvent<Input | Output>[]) => {
-    when: (input: Input) => {
-        then: (expectedOutput: Output | Output[]) => void;
-        thenNothingHappened: () => void;
-        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => void;
-    };
+  when: (input: Input) => {
+    then: (expectedOutput: Output | Output[]) => void;
+    thenNothingHappened: () => void;
+    thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => void;
+  };
 };
 declare const WorkflowSpecification: {
-    for: typeof workflowSpecificationFor;
+  for: typeof workflowSpecificationFor;
 };
 declare function workflowSpecificationFor<Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand>(workflow: Workflow<Input, State, Output>): WorkflowSpecification<Input, Output>;
-
-type TestEventStream<EventType extends Event = Event> = [
-    string,
-    EventType[]
-];
+//#endregion
+//#region src/testing/wrapEventStore.d.ts
+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>;
+  appendedEvents: Map<string, TestEventStream>;
+  setup<EventType extends Event>(streamName: string, events: EventType[]): Promise<AppendToStreamResult>;
 };
 declare const WrapEventStore: <Store extends EventStore>(eventStore: Store) => EventStoreWrapper<Store>;
-
+//#endregion
+//#region src/eventStore/projections/inMemory/inMemoryProjectionSpec.d.ts
 type DocumentWithId = Document & {
-    _id?: string | number;
+  _id?: string | number;
 };
 type InMemoryProjectionSpecEvent<EventType extends Event, EventMetaDataType extends InMemoryReadEventMetadata = InMemoryReadEventMetadata> = EventType & {
-    metadata?: Partial<EventMetaDataType>;
+  metadata?: Partial<EventMetaDataType>;
 };
 type InMemoryProjectionSpecWhenOptions = {
-    numberOfTimes: number;
+  numberOfTimes: number;
+};
+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>;
+  };
 };
 type InMemoryProjectionAssert = (options: {
-    database: InMemoryDatabase;
+  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>;
-    };
+  projection: InMemoryProjectionDefinition<EventType>;
 };
 declare const InMemoryProjectionSpec: {
-    for: <EventType extends Event>(options: InMemoryProjectionSpecOptions<EventType>) => InMemoryProjectionSpec<EventType>;
+  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 = RecordedMessageMetadataWithGlobalPosition>(streamName: string, events: InMemoryProjectionSpecEvent<EventType, EventMetaDataType>[]) => InMemoryProjectionSpecEvent<EventType, EventMetaDataType>[];
 declare function documentExists<T extends DocumentWithId>(expected: Partial<T>, options: {
-    inCollection: string;
-    withId: string | number;
+  inCollection: string;
+  withId: string | number;
 }): InMemoryProjectionAssert;
 declare const expectInMemoryDocuments: {
-    fromCollection: <T extends DocumentWithId>(collectionName: string) => {
-        withId: (id: string | number) => {
-            toBeEqual: (expected: Partial<T>) => InMemoryProjectionAssert;
-        };
+  fromCollection: <T extends DocumentWithId>(collectionName: string) => {
+    withId: (id: string | number) => {
+      toBeEqual: (expected: Partial<T>) => InMemoryProjectionAssert;
     };
+  };
 };
-
+//#endregion
+//#region src/eventStore/versioning/downcasting.d.ts
 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>;
+  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>;
+  downcast?: MessageDowncast<MessageType, MessagePayloadType, RecordedMessageMetadataType>;
 }) => RecordedMessage<MessagePayloadType, RecordedMessageMetadataType>[];
-
+//#endregion
+//#region src/eventStore/versioning/upcasting.d.ts
 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>;
+  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>;
+  upcast?: MessageUpcast<MessageType, MessagePayloadType, RecordedMessageMetadataType>;
 }) => RecordedMessage<MessageType, RecordedMessageMetadataType>[];
-
+//#endregion
+//#region src/utils/async/mapAsync.d.ts
+declare function reduceAsync<T, R>(items: T[], fn: (accumulator: R, item: T, index: number) => Promise<R>, initial: R): Promise<R>;
+//#endregion
+//#region src/utils/closeable.d.ts
 type Closeable = {
-    /**
-     * Gracefully cleans up managed resources
-     *
-     * @memberof Closeable
-     */
-    close: () => Promise<void>;
-};
-
+  /**
+   * Gracefully cleans up managed resources
+   *
+   * @memberof Closeable
+   */
+  close: () => Promise<void>;
+};
+//#endregion
+//#region src/utils/collections/merge.d.ts
 declare const merge: <T>(array: T[], item: T, where: (current: T) => boolean, onExisting: (current: T) => T, onNotFound?: () => T | undefined) => T[];
-
+//#endregion
+//#region src/utils/collections/index.d.ts
 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[];
+  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[];
 };
-
+//#endregion
+//#region src/utils/deepEquals.d.ts
 declare const deepEquals: <T>(left: T, right: T) => boolean;
 type Equatable<T> = {
-    equals: (right: T) => boolean;
+  equals: (right: T) => boolean;
 } & T;
 declare const isEquatable: <T>(left: T) => left is Equatable<T>;
-
+//#endregion
+//#region src/utils/iterators.d.ts
 declare const sum: (iterator: Iterator<number, number, number> | Iterator<number>) => number;
-
+//#endregion
+//#region src/utils/locking/index.d.ts
 type LockOptions = {
-    lockId: number;
+  lockId: number;
 };
 type AcquireLockOptions = {
-    lockId: string;
+  lockId: string;
 };
 type ReleaseLockOptions = {
-    lockId: string;
+  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>;
+  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;
-
+//#endregion
+//#region src/utils/numbers/bigint.d.ts
 declare const toNormalizedString: (value: bigint) => string;
 declare const bigInt: {
-    toNormalizedString: (value: bigint) => string;
+  toNormalizedString: (value: bigint) => string;
 };
-
+//#endregion
+//#region src/utils/promises.d.ts
 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;
+  wait: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason?: any) => void;
+  reset: () => void;
 };
 declare const asyncAwaiter: <T = void>() => AsyncAwaiter<T>;
-
+//#endregion
+//#region src/utils/retry.d.ts
 type AsyncRetryOptions<T = unknown> = retry.Options & {
-    shouldRetryResult?: (result: T) => boolean;
-    shouldRetryError?: (error?: unknown) => boolean;
+  shouldRetryResult?: (result: T) => boolean;
+  shouldRetryError?: (error?: unknown) => boolean;
 };
 declare const NoRetries: AsyncRetryOptions;
 declare const asyncRetry: <T>(fn: () => Promise<T>, opts?: AsyncRetryOptions<T>) => Promise<T>;
-
+//#endregion
+//#region src/utils/shutdown/gracefulShutdown.d.ts
 type ShutdownHandler = () => void | Promise<void>;
 /**
  * Registers handlers for OS signals to enable graceful shutdown.
@@ -964,113 +1323,160 @@ type ShutdownHandler = () => void | Promise<void>;
  * @returns Cleanup function to unregister the handlers
  */
 declare const onShutdown: (handler: ShutdownHandler) => (() => void);
-
+//#endregion
+//#region src/utils/strings/hashText.d.ts
 declare const hashText: (text: string) => Promise<bigint>;
-
+//#endregion
+//#region src/commandHandling/observability/commandHandlerCollector.d.ts
+type CommandObservabilityConfig = Pick<EmmettObservabilityConfig, 'tracer' | 'meter' | 'attributeTarget' | 'includeMessagePayloads'>;
+//#endregion
+//#region src/commandHandling/handleCommand.d.ts
 declare const CommandHandlerStreamVersionConflictRetryOptions: AsyncRetryOptions;
 type CommandHandlerRetryOptions = AsyncRetryOptions | {
-    onVersionConflict: true | number | AsyncRetryOptions;
+  onVersionConflict: true | number | AsyncRetryOptions;
 };
 type CommandHandlerResult<State, StreamEvent extends Event, Store extends EventStore> = AppendStreamResultOfEventStore<Store> & {
-    newState: State;
-    newEvents: StreamEvent[];
+  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;
-        };
+  evolve: (state: State, event: StreamEvent) => State;
+  initialState: () => State;
+  mapToStreamId?: (id: string) => string;
+  retry?: CommandHandlerRetryOptions;
+  schema?: {
+    versioning?: {
+      upcast?: (event: StoredEvent) => StreamEvent;
+      downcast?: (event: StreamEvent) => StoredEvent;
     };
+  };
+  name?: string;
+  commandType?: string | string[];
+} & JSONSerializationOptions & {
+  observability?: CommandObservabilityConfig;
 };
 type HandleOptions<Store extends EventStore> = Parameters<Store['appendToStream']>[2] & ({
-    expectedStreamVersion?: ExpectedStreamVersion;
+  expectedStreamVersion?: ExpectedStreamVersion;
 } | {
-    retry?: CommandHandlerRetryOptions;
-});
+  retry?: CommandHandlerRetryOptions;
+}) & {
+  commandType?: string | string[];
+  observability?: {
+    traceId?: string;
+    spanId?: string;
+    correlationId?: string;
+    causationId?: string;
+  };
+};
 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>>;
-
+//#endregion
+//#region src/commandHandling/handleCommandWithDecider.d.ts
 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>>;
-
+//#endregion
+//#region src/consumers/consumers.d.ts
 type MessageConsumerOptions<ConsumerMessageType extends Message = any> = {
-    consumerId?: string;
-    processors?: Array<MessageProcessor<ConsumerMessageType, any, any>>;
+  consumerId?: string;
+  processors?: Array<MessageProcessor<ConsumerMessageType, 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>;
+  consumerId: string;
+  isRunning: boolean;
+  whenStarted: () => Promise<void>;
+  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;
-};
-
+//#endregion
+//#region src/taskProcessing/executionGuards.d.ts
+type ExclusiveAccessGuard = {
+  execute: <Result>(operation: () => Promise<Result>) => Promise<Result>;
+  waitForIdle: () => Promise<void>;
+  stop: (options?: {
+    force?: boolean;
+  }) => Promise<void>;
+};
+declare const guardExclusiveAccess: (options?: {
+  maxQueueSize?: number;
+}) => ExclusiveAccessGuard;
+type BoundedAccessGuard<Resource> = {
+  acquire: () => Promise<Resource>;
+  release: (resource: Resource) => void;
+  execute: <Result>(operation: (resource: Resource) => Promise<Result>) => Promise<Result>;
+  waitForIdle: () => Promise<void>;
+  stop: (options?: {
+    force?: boolean;
+  }) => Promise<void>;
+};
+declare const guardBoundedAccess: <Resource>(getResource: () => Resource | Promise<Resource>, options: {
+  maxResources: number;
+  maxQueueSize?: number;
+  reuseResources?: boolean;
+  closeResource?: (resource: Resource) => void | Promise<void>;
+}) => BoundedAccessGuard<Resource>;
+type InitializedOnceGuard<T> = {
+  ensureInitialized: () => Promise<T>;
+  reset: () => void;
+  stop: (options?: {
+    force?: boolean;
+  }) => Promise<void>;
+};
+declare const guardInitializedOnce: <T>(initialize: () => Promise<T>, options?: {
+  maxQueueSize?: number;
+  maxRetries?: number;
+}) => InitializedOnceGuard<T>;
+//#endregion
+//#region src/taskProcessing/taskProcessor.d.ts
 type TaskQueue = TaskQueueItem[];
 type TaskQueueItem = {
-    task: () => Promise<void>;
-    options?: EnqueueTaskOptions;
+  task: () => Promise<void>;
+  options?: EnqueueTaskOptions | undefined;
 };
 type TaskProcessorOptions = {
-    maxActiveTasks: number;
-    maxQueueSize: number;
-    maxTaskIdleTime?: number;
+  maxActiveTasks: number;
+  maxQueueSize: number;
+  maxTaskIdleTime?: number;
 };
 type Task<T> = (context: TaskContext) => Promise<T>;
 type TaskContext = {
-    ack: () => void;
+  ack: () => void;
 };
 type EnqueueTaskOptions = {
-    taskGroupId?: string;
+  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;
+  private queue;
+  private isProcessing;
+  private activeTasks;
+  private activeGroups;
+  private options;
+  private stopped;
+  constructor(options: TaskProcessorOptions);
+  enqueue<T>(task: Task<T>, options?: EnqueueTaskOptions): Promise<T>;
+  waitForEndOfProcessing(): Promise<void>;
+  stop(options?: {
+    force?: boolean;
+  }): Promise<void>;
+  private schedule;
+  private ensureProcessing;
+  private processQueue;
+  private executeItem;
+  private takeFirstAvailableItem;
+  private hasItemsToProcess;
 }
-
+//#endregion
+//#region src/validation/dates.d.ts
 declare const formatDateToUtcYYYYMMDD: (date: Date) => string;
 declare const isValidYYYYMMDD: (dateString: string) => boolean;
 declare const parseDateFromUtcYYYYMMDD: (dateString: string) => Date;
-
+//#endregion
+//#region src/validation/index.d.ts
 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"
+  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;
@@ -1078,59 +1484,85 @@ 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;
-
+//#endregion
+//#region src/workflows/workflowProcessor.d.ts
 type WorkflowOptions<Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, StoredMessage extends AnyEvent | AnyCommand = Output> = {
-    workflow: Workflow<Input, State, Output>;
-    getWorkflowId: (input: Input | RecordedMessage<Input, MessageMetadataType>) => string | null;
-    mapWorkflowId?: (workflowId: string) => string;
-    separateInputInboxFromProcessing?: boolean;
-    inputs: {
-        commands: CanHandle<WorkflowCommand<Input>>;
-        events: CanHandle<WorkflowEvent<Input>>;
-    };
-    outputs: {
-        commands: MessageTypeOf<WorkflowCommand<Output>>[];
-        events: MessageTypeOf<WorkflowEvent<Output>>[];
-    };
-    schema?: {
-        versioning?: {
-            upcast?: (event: StoredMessage) => Input;
-            downcast?: (event: Output) => StoredMessage;
-        };
-    };
-};
-type WorkflowProcessorContext = {
-    connection: {
-        messageStore: EventStore;
+  workflow: Workflow<Input, State, Output>;
+  getWorkflowId: (input: Input | RecordedMessage<Input, MessageMetadataType>) => string | null;
+  mapWorkflowId?: (workflowId: string) => string;
+  separateInputInboxFromProcessing?: boolean;
+  inputs: {
+    commands: CanHandle<WorkflowCommand<Input>>;
+    events: CanHandle<WorkflowEvent<Input>>;
+  };
+  outputs: {
+    commands: MessageTypeOf<WorkflowCommand<Output>>[];
+    events: MessageTypeOf<WorkflowEvent<Output>>[];
+  };
+  schema?: {
+    versioning?: {
+      upcast?: (event: StoredMessage) => Input;
+      downcast?: (event: Output) => StoredMessage;
     };
+  };
 };
-type WorkflowProcessorOptions<Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends WorkflowProcessorContext = WorkflowProcessorContext, StoredMessage extends AnyEvent | AnyCommand = Output> = Omit<BaseMessageProcessorOptions<Input | Output, MessageMetadataType, HandlerContext>, 'type' | 'canHandle' | 'processorId'> & {
-    processorId?: string;
+type WorkflowProcessorContext = MessageHandlerContext<{
+  connection: {
+    messageStore: EventStore;
+  };
+}>;
+type WorkflowOutputHandlerResult<Input extends AnyEvent | AnyCommand> = Promise<Input | Input[] | EmmettError | [] | void> | Input | Input[] | EmmettError | [] | void;
+type SingleWorkflowOutputHandler<Input extends AnyEvent | AnyCommand, Output extends AnyEvent | AnyCommand, MessageMetaDataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends WorkflowProcessorContext = WorkflowProcessorContext> = (message: Output | RecordedMessage<Output, MessageMetaDataType>, context: HandlerContext) => WorkflowOutputHandlerResult<Input>;
+type BatchWorkflowOutputHandler<Input extends AnyEvent | AnyCommand, Output extends AnyEvent | AnyCommand, MessageMetaDataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends WorkflowProcessorContext = WorkflowProcessorContext> = (messages: RecordedMessage<Output, MessageMetaDataType>[], context: HandlerContext) => WorkflowOutputHandlerResult<Input>;
+type WorkflowOutputHandlerOptions<Input extends AnyEvent | AnyCommand, Output extends AnyEvent | AnyCommand, MessageMetaDataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends WorkflowProcessorContext = WorkflowProcessorContext> = {
+  eachMessage: SingleWorkflowOutputHandler<Input, Output, MessageMetaDataType, HandlerContext>;
+  eachBatch?: never;
+} | {
+  eachMessage?: never;
+  eachBatch: BatchWorkflowOutputHandler<Input, Output, MessageMetaDataType, HandlerContext>;
+};
+type WorkflowOutputHandlerDefinition<Input extends AnyEvent | AnyCommand, Output extends AnyEvent | AnyCommand, HandledOutput extends Output = Output, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends WorkflowProcessorContext = WorkflowProcessorContext> = {
+  canHandle: CanHandle<HandledOutput>;
+} & WorkflowOutputHandlerOptions<Input, HandledOutput, MessageMetadataType, HandlerContext>;
+declare const workflowOutputHandler: <Input extends AnyEvent | AnyCommand, Output extends AnyEvent | AnyCommand, HandledOutput extends Output = Output, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends WorkflowProcessorContext = WorkflowProcessorContext>(handler: WorkflowOutputHandlerDefinition<Input, Output, HandledOutput, MessageMetadataType, HandlerContext>) => WorkflowOutputHandlerDefinition<Input, Output, HandledOutput, MessageMetadataType, HandlerContext>;
+type WorkflowProcessorOptions<Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends WorkflowProcessorContext = WorkflowProcessorContext, StoredMessage extends AnyEvent | AnyCommand = Output, HandledOutput extends Output = Output> = Omit<BaseMessageProcessorOptions<Input | Output, MessageMetadataType, HandlerContext>, 'type' | 'canHandle' | 'processorId'> & {
+  processorId?: string;
 } & WorkflowOptions<Input, State, Output, MessageMetadataType, StoredMessage> & {
-    retry?: WorkflowHandlerRetryOptions;
+  retry?: WorkflowHandlerRetryOptions;
+  outputHandler?: WorkflowOutputHandlerDefinition<Input, Output, HandledOutput, MessageMetadataType, HandlerContext>;
 };
 declare const getWorkflowId: (options: {
-    workflowName: string;
+  workflowName: string;
 }) => string;
-declare const workflowProcessor: <Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends WorkflowProcessorContext = WorkflowProcessorContext, StoredMessage extends AnyEvent | AnyCommand = Output>(options: WorkflowProcessorOptions<Input, State, Output, MetaDataType, HandlerContext, StoredMessage>) => MessageProcessor<Input, MetaDataType, HandlerContext>;
-
+declare const workflowProcessor: <Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends WorkflowProcessorContext = WorkflowProcessorContext, StoredMessage extends AnyEvent | AnyCommand = Output, HandledOutput extends Output = Output>(options: WorkflowProcessorOptions<Input, State, Output, MetaDataType, HandlerContext, StoredMessage, HandledOutput>) => MessageProcessor<Input, MetaDataType, HandlerContext>;
+//#endregion
+//#region src/workflows/handleWorkflow.d.ts
 declare const WorkflowHandlerStreamVersionConflictRetryOptions: AsyncRetryOptions;
 type WorkflowHandlerRetryOptions = AsyncRetryOptions | {
-    onVersionConflict: true | number | AsyncRetryOptions;
+  onVersionConflict: true | number | AsyncRetryOptions;
 };
 type WorkflowHandlerResult<Output extends AnyEvent | AnyCommand, Store extends EventStore> = AppendStreamResultOfEventStore<Store> & {
-    newMessages: Output[];
+  newMessages: Output[];
 };
 type WorkflowHandleOptions<Store extends EventStore> = Parameters<Store['appendToStream']>[2] & {
-    expectedStreamVersion?: ExpectedStreamVersion;
-    retry?: WorkflowHandlerRetryOptions;
-};
-declare const workflowStreamName: ({ workflowName, workflowId, }: {
-    workflowName: string;
-    workflowId: string;
+  expectedStreamVersion?: ExpectedStreamVersion;
+  retry?: WorkflowHandlerRetryOptions;
+};
+declare const workflowStreamName: ({
+  workflowName,
+  workflowId
+}: {
+  workflowName: string;
+  workflowId: string;
 }) => string;
-declare const WorkflowHandler: <Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, StoredMessage extends AnyEvent | AnyCommand = Output>(options: WorkflowOptions<Input, State, Output, MessageMetadataType, StoredMessage> & {
-    retry?: WorkflowHandlerRetryOptions;
-}) => <Store extends EventStore>(store: Store, message: Input | RecordedMessage<Input, MessageMetadataType>, handleOptions?: WorkflowHandleOptions<Store>) => Promise<WorkflowHandlerResult<Output, Store>>;
-
-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 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 GlobalPosition, 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 ProcessorCheckpoint, 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 StreamPosition, 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, Workflow, type WorkflowCommand, type WorkflowEvent, type WorkflowHandleOptions, WorkflowHandler, type WorkflowHandlerResult, type WorkflowHandlerRetryOptions, WorkflowHandlerStreamVersionConflictRetryOptions, type WorkflowInputMessageMetadata, type WorkflowMessageAction, type WorkflowOptions, type WorkflowOutput, type WorkflowOutputMessageMetadata, type WorkflowProcessorContext, type WorkflowProcessorOptions, WorkflowSpecification, WrapEventStore, 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, bigIntProcessorCheckpoint, canCreateEventStoreSession, caughtUpEventFrom, command, deepEquals, defaultProcessingMessageProcessingScope, defaultProcessorPartition, defaultProcessorVersion, defaultTag, delay, documentExists, downcastRecordedMessage, downcastRecordedMessages, emmettPrefix, event, eventInStream, eventsInStream, expectInMemoryDocuments, filterProjections, formatDateToUtcYYYYMMDD, forwardToMessageBus, getCheckpoint, getInMemoryDatabase, getInMemoryEventStore, getInMemoryMessageBus, getProcessorInstanceId, getProjectorId, getWorkflowId, globalStreamCaughtUp, globalTag, handleInMemoryProjections, hashText, inMemoryCheckpointer, inMemoryMultiStreamProjection, inMemoryProjection, inMemoryProjector, inMemoryReactor, inMemorySingleStreamProjection, inlineProjections, isBigint, isEquatable, isExpectedVersionConflictError, isGlobalStreamCaughtUp, isNotInternalEvent, isNumber, isString, isSubscriptionEvent, isSubset, isValidYYYYMMDD, matchesExpectedVersion, merge, message, newEventsInStream, nulloSessionFactory, onShutdown, parseBigIntProcessorCheckpoint, parseDateFromUtcYYYYMMDD, projection, projections, projector, reactor, sum, toNormalizedString, tryPublishMessagesAfterCommit, unknownTag, upcastRecordedMessage, upcastRecordedMessages, verifyThat, wasMessageHandled, workflowProcessor, workflowStreamName };
+type WorkflowHandlerOptions<Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, StoredMessage extends AnyEvent | AnyCommand = Output> = WorkflowOptions<Input, State, Output, MessageMetadataType, StoredMessage> & {
+  retry?: WorkflowHandlerRetryOptions;
+  observability?: WorkflowObservabilityConfig;
+};
+declare const WorkflowHandler: <Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MessageMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, StoredMessage extends AnyEvent | AnyCommand = Output>(options: WorkflowHandlerOptions<Input, State, Output, MessageMetadataType, StoredMessage>) => <Store extends EventStore>(store: Store, message: Input | RecordedMessage<Input, MessageMetadataType>, handleOptions?: WorkflowHandleOptions<Store>) => Promise<WorkflowHandlerResult<Output, Store>>;
+declare namespace index_d_exports {
+  export { AcquireLockOptions, AfterEventStoreCommitHandler, AggregateStreamOptions, AggregateStreamResult, AggregateStreamResultOfEventStore, AggregateStreamResultWithGlobalPosition, AnyCommand, AnyEvent, AnyMessage, AnyReadEvent, AnyReadEventMetadata, AnyRecord, AnyRecordedMessage, AnyRecordedMessageMetadata, AppendStreamResultOfEventStore, AppendToStreamOptions, AppendToStreamResult, AppendToStreamResultWithGlobalPosition, ArgumentMatcher, AssertionError, AsyncAwaiter, AsyncDeciderSpecification, AsyncRetryOptions, BaseMessageProcessorOptions, BatchMessageHandler, BatchMessageHandlerResult, BatchMessageHandlerWithContext, BatchMessageHandlerWithoutContext, BatchRawMessageHandlerWithContext, BatchRawMessageHandlerWithoutContext, BatchRecordedMessageHandlerWithContext, BatchRecordedMessageHandlerWithoutContext, BatchWorkflowOutputHandler, BeforeEventStoreCommitHandler, BoundedAccessGuard, Brand, CanHandle, Checkpointer, Closeable, CombineMetadata, CombinedMessageMetadata, CombinedReadEventMetadata, Command, CommandBus, CommandDataOf, CommandHandler, CommandHandlerOptions, CommandHandlerResult, CommandHandlerRetryOptions, CommandHandlerStreamVersionConflictRetryOptions, CommandMetaDataOf, CommandProcessor, CommandSender, CommandTypeOf, CommonReadEventMetadata, CommonRecordedMessageMetadata, ConcurrencyError, ConcurrencyInMemoryDatabaseError, ConsumerObservabilityConfig, CreateCommandType, CreateEventType, CurrentMessageProcessorPosition, DATABASE_REQUIRED_ERROR_MESSAGE, DatabaseHandleOptionErrors, DatabaseHandleOptions, DatabaseHandleResult, Decider, DeciderCommandHandler, DeciderCommandHandlerOptions, DeciderSpecification, DeepReadonly, DefaultCommandMetadata, DefaultEventStoreOptions, DefaultRecord, DeleteManyOptions, DeleteManyResult, DeleteOneOptions, DeleteResult, Document, DocumentHandler, EmmettAttributes, EmmettCliCommand, EmmettCliPlugin, EmmettCliPluginRegistration, EmmettError, EmmettMetrics, EmmettObservabilityConfig, EmmettObservabilityOptions, EmmettPlugin, EmmettPluginConfig, EmmettPluginRegistration, EmmettPluginType, EmmettPluginsConfig, EnhancedOmit, EnqueueTaskOptions, Equatable, ErrorConstructor, Event, EventBus, EventDataOf, EventMetaDataOf, EventStore, EventStoreAppendSchemaOptions, EventStoreObservabilityConfig, EventStoreReadEventMetadata, EventStoreReadSchemaOptions, EventStoreSchemaOptions, EventStoreSession, EventStoreSessionFactory, EventStoreWrapper, EventSubscription, EventTypeOf, EventsPublisher, ExclusiveAccessGuard, ExpectedDocumentVersion, ExpectedDocumentVersionGeneral, ExpectedDocumentVersionValue, ExpectedStreamVersion, ExpectedStreamVersionGeneral, ExpectedStreamVersionWithValue, ExpectedVersionConflictError, Flavour, FullId, GetCheckpoint, GlobalPosition, GlobalStreamCaughtUp, GlobalStreamCaughtUpType, GlobalSubscriptionEvent, HandleOptions, HandlerOptions, IllegalStateError, InMemoryCheckpointer, InMemoryDatabase, InMemoryDocumentEvolve, InMemoryDocumentsCollection, InMemoryEventStore, InMemoryEventStoreDefaultStreamVersion, InMemoryEventStoreOptions, InMemoryMultiStreamProjectionOptions, InMemoryProcessor, InMemoryProcessorConnectionOptions, InMemoryProcessorEachBatchHandler, InMemoryProcessorEachMessageHandler, InMemoryProcessorHandlerContext, InMemoryProcessorOptions, InMemoryProjectionAssert, InMemoryProjectionDefinition, InMemoryProjectionHandlerContext, InMemoryProjectionHandlerOptions, InMemoryProjectionOptions, InMemoryProjectionSpec, InMemoryProjectionSpecEvent, InMemoryProjectionSpecOptions, InMemoryProjectionSpecWhenOptions, InMemoryProjectorOptions, InMemoryReactorOptions, InMemoryReadEvent, InMemoryReadEventMetadata, InMemorySingleStreamProjectionOptions, InMemoryWithNotNullDocumentEvolve, InMemoryWithNullableDocumentEvolve, InProcessLock, InitializedOnceGuard, InsertManyOptions, InsertManyResult, InsertOneOptions, InsertOneResult, JSONCodec, JSONCodecOptions, JSONDeserializeOptions, JSONReplacer, JSONReplacers, JSONReviver, JSONReviverContext, JSONRevivers, JSONSerializationOptions, JSONSerializeOptions, JSONSerializer, JSONSerializerOptions, Lock, LockOptions, LogLevel, LogStyle, LogType, Message, MessageBus, MessageConsumer, MessageConsumerOptions, MessageDataOf, MessageDowncast, MessageHandler, MessageHandlerContext, MessageKindOf, MessageMetaDataOf, MessageProcessingScope, MessageProcessor, MessageProcessorStartFrom, MessageProcessorType, MessageScheduler, MessageSubscription, MessageTypeOf, MessageUpcast, MessagingSystemName, MockedFunction, Mutable, NO_CONCURRENCY_CHECK, NoRetries, NonNullable$1 as NonNullable, NotFoundError, OnReactorCloseHook, OnReactorInitHook, OnReactorStartHook, OperationResult, OptionalId, OptionalUnlessRequiredId, OptionalUnlessRequiredIdAndVersion, OptionalUnlessRequiredVersion, OptionalVersion, PollTracing, ProcessorCheckpoint, ProcessorCollectorContext, ProcessorHooks, ProcessorObservabilityConfig, ProjectionDefinition, ProjectionHandler, ProjectionHandlerContext, ProjectionHandlingType, ProjectionInitOptions, ProjectionRegistration, ProjectorOptions, ReactorOptions, ReadEvent, ReadEventMetadata, ReadEventMetadataWithGlobalPosition, ReadEventMetadataWithoutGlobalPosition, ReadProcessorCheckpoint, ReadProcessorCheckpointResult, ReadStreamOptions, ReadStreamResult, RecordedMessage, RecordedMessageMetadata, RecordedMessageMetadataWithGlobalPosition, RecordedMessageMetadataWithoutGlobalPosition, ReleaseLockOptions, ReplaceOneOptions, ResolvedConsumerObservability, ResolvedEventStoreObservability, ResolvedProcessorObservability, ResolvedWorkflowObservability, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, ScheduleOptions, ScheduledMessage, ScheduledMessageProcessor, ScopeTypes, SerializationCodec, Serializer, ShutdownHandler, SingleMessageHandler, SingleMessageHandlerResult, SingleMessageHandlerWithContext, SingleMessageHandlerWithoutContext, SingleRawMessageHandlerWithContext, SingleRawMessageHandlerWithoutContext, SingleRecordedMessageHandlerWithContext, SingleRecordedMessageHandlerWithoutContext, SingleWorkflowOutputHandler, StoreProcessorCheckpoint, StoreProcessorCheckpointResult, StreamExistsResult, StreamPosition, Task, TaskContext, TaskProcessor, TaskProcessorOptions, TaskQueue, TaskQueueItem, TestEventStream, ThenThrows, TruncateProjection, UpdateManyOptions, UpdateManyResult, UpdateOneOptions, UpdateResult, ValidationError, ValidationErrors, WithGlobalPosition, WithId, WithIdAndVersion, WithObservabilityScope, WithVersion, WithoutId, WithoutVersion, Workflow, WorkflowCollectorContext, WorkflowCommand, WorkflowEvent, WorkflowHandleOptions, WorkflowHandler, WorkflowHandlerOptions, WorkflowHandlerResult, WorkflowHandlerRetryOptions, WorkflowHandlerStreamVersionConflictRetryOptions, WorkflowInputMessageMetadata, WorkflowMessageAction, WorkflowObservabilityConfig, WorkflowOptions, WorkflowOutput, WorkflowOutputHandlerDefinition, WorkflowOutputHandlerOptions, WorkflowOutputHandlerResult, WorkflowOutputMessageMetadata, WorkflowProcessorContext, WorkflowProcessorOptions, WorkflowSpecification, WrapEventStore, argMatches, argValue, arrayUtils, assertDeepEqual, assertDefined, assertDoesNotThrow, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEmptyString, assertNotEqual, assertOk, assertPositiveNumber, assertRejects, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, assertUndefined, assertUnsignedBigInt, asyncAwaiter, asyncProjections, asyncRetry, bigInt, bigIntProcessorCheckpoint, canCreateEventStoreSession, caughtUpEventFrom, command, composeJSONReplacers, composeJSONRevivers, consumerCollector, deepEquals, defaultProcessingMessageProcessingScope, defaultProcessorPartition, defaultProcessorVersion, defaultTag, delay, documentExists, downcastRecordedMessage, downcastRecordedMessages, emmettPrefix, event, eventInStream, eventStoreCollector, eventsInStream, expectInMemoryDocuments, filterProjections, formatDateToUtcYYYYMMDD, forwardToMessageBus, getCheckpoint, getInMemoryDatabase, getInMemoryEventStore, getInMemoryMessageBus, getProcessorInstanceId, getProjectorId, getWorkflowId, globalStreamCaughtUp, globalTag, guardBoundedAccess, guardExclusiveAccess, guardInitializedOnce, handleInMemoryProjections, hashText, inMemoryCheckpointer, inMemoryMultiStreamProjection, inMemoryProjection, inMemoryProjector, inMemoryReactor, inMemorySingleStreamProjection, inlineProjections, isBigint, isEquatable, isErrorConstructor, isExpectedVersionConflictError, isGlobalStreamCaughtUp, isNotInternalEvent, isNumber, isPluginConfig, isString, isSubscriptionEvent, isSubset, isValidYYYYMMDD, jsonSerializer, matchesExpectedVersion, merge, message, newEventsInStream, nulloSessionFactory, onShutdown, parseBigIntProcessorCheckpoint, parseDateFromUtcYYYYMMDD, processorCollector, projection, projections, projector, reactor, reduceAsync, resolveConsumerObservability, resolveEventStoreObservability, resolveProcessorObservability, resolveWorkflowObservability, sum, toNormalizedString, tracer, tryPublishMessagesAfterCommit, unknownTag, upcastRecordedMessage, upcastRecordedMessages, verifyThat, wasMessageHandled, workflowCollector, workflowOutputHandler, workflowProcessor, workflowStreamName };
+}
+//#endregion
+export { AcquireLockOptions, AfterEventStoreCommitHandler, AggregateStreamOptions, AggregateStreamResult, AggregateStreamResultOfEventStore, AggregateStreamResultWithGlobalPosition, AnyCommand, AnyEvent, AnyMessage, AnyReadEvent, AnyReadEventMetadata, AnyRecord, AnyRecordedMessage, AnyRecordedMessageMetadata, AppendStreamResultOfEventStore, AppendToStreamOptions, AppendToStreamResult, AppendToStreamResultWithGlobalPosition, ArgumentMatcher, AssertionError, AsyncAwaiter, AsyncDeciderSpecification, AsyncRetryOptions, BaseMessageProcessorOptions, BatchMessageHandler, BatchMessageHandlerResult, BatchMessageHandlerWithContext, BatchMessageHandlerWithoutContext, BatchRawMessageHandlerWithContext, BatchRawMessageHandlerWithoutContext, BatchRecordedMessageHandlerWithContext, BatchRecordedMessageHandlerWithoutContext, BatchWorkflowOutputHandler, BeforeEventStoreCommitHandler, BoundedAccessGuard, Brand, CanHandle, Checkpointer, Closeable, CombineMetadata, CombinedMessageMetadata, CombinedReadEventMetadata, Command, CommandBus, CommandDataOf, CommandHandler, CommandHandlerOptions, CommandHandlerResult, CommandHandlerRetryOptions, CommandHandlerStreamVersionConflictRetryOptions, CommandMetaDataOf, CommandProcessor, CommandSender, CommandTypeOf, CommonReadEventMetadata, CommonRecordedMessageMetadata, ConcurrencyError, ConcurrencyInMemoryDatabaseError, ConsumerObservabilityConfig, CreateCommandType, CreateEventType, CurrentMessageProcessorPosition, DATABASE_REQUIRED_ERROR_MESSAGE, DatabaseHandleOptionErrors, DatabaseHandleOptions, DatabaseHandleResult, Decider, DeciderCommandHandler, DeciderCommandHandlerOptions, DeciderSpecification, DeepReadonly, DefaultCommandMetadata, DefaultEventStoreOptions, DefaultRecord, DeleteManyOptions, DeleteManyResult, DeleteOneOptions, DeleteResult, Document, DocumentHandler, EmmettAttributes, EmmettCliCommand, EmmettCliPlugin, EmmettCliPluginRegistration, EmmettError, EmmettMetrics, EmmettObservabilityConfig, EmmettObservabilityOptions, EmmettPlugin, EmmettPluginConfig, EmmettPluginRegistration, EmmettPluginType, EmmettPluginsConfig, EnhancedOmit, EnqueueTaskOptions, Equatable, ErrorConstructor, Event, EventBus, EventDataOf, EventMetaDataOf, EventStore, EventStoreAppendSchemaOptions, EventStoreObservabilityConfig, EventStoreReadEventMetadata, EventStoreReadSchemaOptions, EventStoreSchemaOptions, EventStoreSession, EventStoreSessionFactory, EventStoreWrapper, EventSubscription, EventTypeOf, EventsPublisher, ExclusiveAccessGuard, ExpectedDocumentVersion, ExpectedDocumentVersionGeneral, ExpectedDocumentVersionValue, ExpectedStreamVersion, ExpectedStreamVersionGeneral, ExpectedStreamVersionWithValue, ExpectedVersionConflictError, Flavour, FullId, GetCheckpoint, GlobalPosition, GlobalStreamCaughtUp, GlobalStreamCaughtUpType, GlobalSubscriptionEvent, HandleOptions, HandlerOptions, IllegalStateError, InMemoryCheckpointer, InMemoryDatabase, InMemoryDocumentEvolve, InMemoryDocumentsCollection, InMemoryEventStore, InMemoryEventStoreDefaultStreamVersion, InMemoryEventStoreOptions, InMemoryMultiStreamProjectionOptions, InMemoryProcessor, InMemoryProcessorConnectionOptions, InMemoryProcessorEachBatchHandler, InMemoryProcessorEachMessageHandler, InMemoryProcessorHandlerContext, InMemoryProcessorOptions, InMemoryProjectionAssert, InMemoryProjectionDefinition, InMemoryProjectionHandlerContext, InMemoryProjectionHandlerOptions, InMemoryProjectionOptions, InMemoryProjectionSpec, InMemoryProjectionSpecEvent, InMemoryProjectionSpecOptions, InMemoryProjectionSpecWhenOptions, InMemoryProjectorOptions, InMemoryReactorOptions, InMemoryReadEvent, InMemoryReadEventMetadata, InMemorySingleStreamProjectionOptions, InMemoryWithNotNullDocumentEvolve, InMemoryWithNullableDocumentEvolve, InProcessLock, InitializedOnceGuard, InsertManyOptions, InsertManyResult, InsertOneOptions, InsertOneResult, JSONCodec, type JSONCodecOptions, type JSONDeserializeOptions, JSONReplacer, JSONReplacers, JSONReviver, JSONReviverContext, JSONRevivers, type JSONSerializationOptions, type JSONSerializeOptions, JSONSerializer, type JSONSerializerOptions, Lock, LockOptions, LogLevel, LogStyle, LogType, Message, MessageBus, MessageConsumer, MessageConsumerOptions, MessageDataOf, MessageDowncast, MessageHandler, MessageHandlerContext, MessageKindOf, MessageMetaDataOf, MessageProcessingScope, MessageProcessor, MessageProcessorStartFrom, MessageProcessorType, MessageScheduler, MessageSubscription, MessageTypeOf, MessageUpcast, MessagingSystemName, MockedFunction, Mutable, NO_CONCURRENCY_CHECK, NoRetries, NonNullable$1 as NonNullable, NotFoundError, OnReactorCloseHook, OnReactorInitHook, OnReactorStartHook, OperationResult, OptionalId, OptionalUnlessRequiredId, OptionalUnlessRequiredIdAndVersion, OptionalUnlessRequiredVersion, OptionalVersion, PollTracing, ProcessorCheckpoint, ProcessorCollectorContext, ProcessorHooks, ProcessorObservabilityConfig, ProjectionDefinition, ProjectionHandler, ProjectionHandlerContext, ProjectionHandlingType, ProjectionInitOptions, ProjectionRegistration, ProjectorOptions, ReactorOptions, ReadEvent, ReadEventMetadata, ReadEventMetadataWithGlobalPosition, ReadEventMetadataWithoutGlobalPosition, ReadProcessorCheckpoint, ReadProcessorCheckpointResult, ReadStreamOptions, ReadStreamResult, RecordedMessage, RecordedMessageMetadata, RecordedMessageMetadataWithGlobalPosition, RecordedMessageMetadataWithoutGlobalPosition, ReleaseLockOptions, ReplaceOneOptions, ResolvedConsumerObservability, ResolvedEventStoreObservability, ResolvedProcessorObservability, ResolvedWorkflowObservability, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, ScheduleOptions, ScheduledMessage, ScheduledMessageProcessor, ScopeTypes, SerializationCodec, Serializer, ShutdownHandler, SingleMessageHandler, SingleMessageHandlerResult, SingleMessageHandlerWithContext, SingleMessageHandlerWithoutContext, SingleRawMessageHandlerWithContext, SingleRawMessageHandlerWithoutContext, SingleRecordedMessageHandlerWithContext, SingleRecordedMessageHandlerWithoutContext, SingleWorkflowOutputHandler, StoreProcessorCheckpoint, StoreProcessorCheckpointResult, StreamExistsResult, StreamPosition, Task, TaskContext, TaskProcessor, TaskProcessorOptions, TaskQueue, TaskQueueItem, TestEventStream, ThenThrows, TruncateProjection, UpdateManyOptions, UpdateManyResult, UpdateOneOptions, UpdateResult, ValidationError, ValidationErrors, WithGlobalPosition, WithId, WithIdAndVersion, WithObservabilityScope, WithVersion, WithoutId, WithoutVersion, Workflow, WorkflowCollectorContext, WorkflowCommand, WorkflowEvent, WorkflowHandleOptions, WorkflowHandler, WorkflowHandlerOptions, WorkflowHandlerResult, WorkflowHandlerRetryOptions, WorkflowHandlerStreamVersionConflictRetryOptions, WorkflowInputMessageMetadata, WorkflowMessageAction, WorkflowObservabilityConfig, WorkflowOptions, WorkflowOutput, WorkflowOutputHandlerDefinition, WorkflowOutputHandlerOptions, WorkflowOutputHandlerResult, WorkflowOutputMessageMetadata, WorkflowProcessorContext, WorkflowProcessorOptions, WorkflowSpecification, WrapEventStore, argMatches, argValue, arrayUtils, assertDeepEqual, assertDefined, assertDoesNotThrow, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEmptyString, assertNotEqual, assertOk, assertPositiveNumber, assertRejects, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, assertUndefined, assertUnsignedBigInt, asyncAwaiter, asyncProjections, asyncRetry, bigInt, bigIntProcessorCheckpoint, canCreateEventStoreSession, caughtUpEventFrom, command, composeJSONReplacers, composeJSONRevivers, consumerCollector, deepEquals, defaultProcessingMessageProcessingScope, defaultProcessorPartition, defaultProcessorVersion, defaultTag, delay, documentExists, downcastRecordedMessage, downcastRecordedMessages, emmettPrefix, event, eventInStream, eventStoreCollector, eventsInStream, expectInMemoryDocuments, filterProjections, formatDateToUtcYYYYMMDD, forwardToMessageBus, getCheckpoint, getInMemoryDatabase, getInMemoryEventStore, getInMemoryMessageBus, getProcessorInstanceId, getProjectorId, getWorkflowId, globalStreamCaughtUp, globalTag, guardBoundedAccess, guardExclusiveAccess, guardInitializedOnce, handleInMemoryProjections, hashText, inMemoryCheckpointer, inMemoryMultiStreamProjection, inMemoryProjection, inMemoryProjector, inMemoryReactor, inMemorySingleStreamProjection, inlineProjections, isBigint, isEquatable, isErrorConstructor, isExpectedVersionConflictError, isGlobalStreamCaughtUp, isNotInternalEvent, isNumber, isPluginConfig, isString, isSubscriptionEvent, isSubset, isValidYYYYMMDD, jsonSerializer, matchesExpectedVersion, merge, message, newEventsInStream, nulloSessionFactory, onShutdown, parseBigIntProcessorCheckpoint, parseDateFromUtcYYYYMMDD, processorCollector, projection, projections, projector, reactor, reduceAsync, resolveConsumerObservability, resolveEventStoreObservability, resolveProcessorObservability, resolveWorkflowObservability, sum, toNormalizedString, tracer, tryPublishMessagesAfterCommit, unknownTag, upcastRecordedMessage, upcastRecordedMessages, verifyThat, wasMessageHandled, workflowCollector, workflowOutputHandler, workflowProcessor, workflowStreamName };
+//# sourceMappingURL=index.d.cts.map