@event-driven-io/emmett-mongodb 0.43.0-beta.13 → 0.43.0-beta.14

package/dist/index.d.cts

@@ -1,240 +1,244 @@
-import { Event, ReadEvent, ProjectionDefinition, ProjectionHandler, CanHandle, ThenThrows, ReadEventMetadataWithoutGlobalPosition, EventStore, ProjectionRegistration, DefaultEventStoreOptions, Closeable } from '@event-driven-io/emmett';
-import { UpdateFilter, Collection, Document, MongoClient, Filter, MongoClientOptions } from 'mongodb';
+import { CanHandle, Closeable, DefaultEventStoreOptions, Event, EventStore, ProjectionDefinition, ProjectionHandler, ProjectionRegistration, ReadEvent, ReadEventMetadataWithoutGlobalPosition, ThenThrows } from "@event-driven-io/emmett";
+import { Collection, Document, Filter, MongoClient, MongoClientOptions, UpdateFilter } from "mongodb";
 
+//#region src/eventStore/projections/mongoDBInlineProjection.d.ts
 declare const MongoDBDefaultInlineProjectionName = "_default";
 type MongoDBProjectionInlineHandlerContext<EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = {
-    document: MongoDBReadModel | null;
-    streamId: string;
-    updates: UpdateFilter<EventStream<EventType, EventMetaDataType>>;
-    collection: Collection<EventStream<EventType, EventMetaDataType>>;
+  document: MongoDBReadModel | null;
+  streamId: string;
+  updates: UpdateFilter<EventStream<EventType, EventMetaDataType>>;
+  collection: Collection<EventStream<EventType, EventMetaDataType>>;
 };
 type MongoDBInlineProjectionHandler<EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, MongoDBProjectionInlineHandlerContext>;
 type MongoDBInlineProjectionDefinition<EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = ProjectionDefinition<EventType, EventMetaDataType, MongoDBProjectionInlineHandlerContext> & {
-    name: string;
+  name: string;
 };
 type InlineProjectionHandlerOptions<EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = {
-    readModels: Record<string, MongoDBReadModel>;
-    events: Array<ReadEvent<EventType, EventMetaDataType>>;
-    projections: MongoDBInlineProjectionDefinition<EventType, EventMetaDataType>[];
-    streamId: string;
-    collection: Collection<EventStream>;
-    updates: UpdateFilter<EventStream<Event>>;
-    client: {};
+  readModels: Record<string, MongoDBReadModel>;
+  events: Array<ReadEvent<EventType, EventMetaDataType>>;
+  projections: MongoDBInlineProjectionDefinition<EventType, EventMetaDataType>[];
+  streamId: string;
+  collection: Collection<EventStream>;
+  updates: UpdateFilter<EventStream<Event>>;
+  client: {};
 };
 declare const handleInlineProjections: <EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata>(options: InlineProjectionHandlerOptions<EventType, EventMetaDataType>) => Promise<void>;
 type MongoDBWithNotNullDocumentEvolve<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = ((document: Doc, event: ReadEvent<EventType, EventMetaDataType>) => Doc | null) | ((document: Doc, event: ReadEvent<EventType>) => Promise<Doc | null>);
 type MongoDBWithNullableDocumentEvolve<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = ((document: Doc | null, event: ReadEvent<EventType, EventMetaDataType>) => Doc | null) | ((document: Doc | null, event: ReadEvent<EventType>) => Promise<Doc | null>);
 type MongoDBInlineProjectionOptions<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = {
-    name?: string;
-    schemaVersion?: number;
-    canHandle: CanHandle<EventType>;
+  name?: string;
+  schemaVersion?: number;
+  canHandle: CanHandle<EventType>;
 } & ({
-    evolve: MongoDBWithNullableDocumentEvolve<Doc, EventType, EventMetaDataType>;
+  evolve: MongoDBWithNullableDocumentEvolve<Doc, EventType, EventMetaDataType>;
 } | {
-    evolve: MongoDBWithNotNullDocumentEvolve<Doc, EventType, EventMetaDataType>;
-    initialState: () => Doc;
+  evolve: MongoDBWithNotNullDocumentEvolve<Doc, EventType, EventMetaDataType>;
+  initialState: () => Doc;
 });
 declare const mongoDBInlineProjection: <Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata>(options: MongoDBInlineProjectionOptions<Doc, EventType, EventMetaDataType>) => MongoDBInlineProjectionDefinition;
-
+//#endregion
+//#region src/eventStore/projections/mongoDBInlineProjectionSpec.d.ts
 type MongoDBInlineProjectionSpecGivenEvents<StreamNameType extends StreamName, EventType extends Event> = {
-    streamName: StreamNameType;
-    events: EventType[];
+  streamName: StreamNameType;
+  events: EventType[];
+};
+type MongoDBInlineProjectionSpec<StreamNameType extends StreamName, EventType extends Event> = (givenStream: MongoDBInlineProjectionSpecGivenEvents<StreamNameType, EventType>) => {
+  when: (events: EventType[]) => {
+    then: (assert: MongoDBInlineProjectionAssert, message?: string) => Promise<void>;
+    thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
+  };
 };
 type MongoDBInlineProjectionAssertOptions<StreamNameType extends StreamName = StreamName> = {
-    streamName: StreamNameType;
-    eventStore: MongoDBEventStore;
+  streamName: StreamNameType;
+  eventStore: MongoDBEventStore;
 };
 type MongoDBInlineProjectionAssert<StreamNameType extends StreamName = StreamName> = (options: MongoDBInlineProjectionAssertOptions<StreamNameType>) => Promise<void | boolean>;
 type MongoDBInlineProjectionSpecOptions = {
-    projection: MongoDBInlineProjectionDefinition;
+  projection: MongoDBInlineProjectionDefinition;
 } & MongoDBEventStoreConnectionOptions;
-type MongoDBInlineProjectionSpec<StreamNameType extends StreamName, EventType extends Event> = (givenStream: MongoDBInlineProjectionSpecGivenEvents<StreamNameType, EventType>) => {
-    when: (events: EventType[]) => {
-        then: (assert: MongoDBInlineProjectionAssert, message?: string) => Promise<void>;
-        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
-    };
-};
 declare const MongoDBInlineProjectionSpec: {
-    for: <StreamNameType extends StreamName, EventType extends Event>(options: MongoDBInlineProjectionSpecOptions) => MongoDBInlineProjectionSpec<StreamNameType, EventType>;
+  for: <StreamNameType extends StreamName, EventType extends Event>(options: MongoDBInlineProjectionSpecOptions) => MongoDBInlineProjectionSpec<StreamNameType, EventType>;
 };
 declare const eventInStream: <StreamNameType extends StreamName, EventType extends Event>(streamName: StreamNameType, event: EventType) => MongoDBInlineProjectionSpecGivenEvents<StreamNameType, EventType>;
 declare const eventsInStream: <StreamNameType extends StreamName, EventType extends Event>(streamName: StreamNameType, events: EventType[]) => MongoDBInlineProjectionSpecGivenEvents<StreamNameType, EventType>;
 declare const expectInlineReadModel: {
+  toHave: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(expected: Partial<MongoDBReadModel<Doc>> | null) => MongoDBInlineProjectionAssert<StreamNameType>;
+  toDeepEquals: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(expected: MongoDBReadModel<Doc> | null) => MongoDBInlineProjectionAssert<StreamNameType>;
+  toMatch: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(match: (readModel: MongoDBReadModel<Doc> | null) => boolean) => MongoDBInlineProjectionAssert<StreamNameType>;
+  notToExist: <StreamNameType extends StreamName = `${string}:${string}`>() => MongoDBInlineProjectionAssert<StreamNameType>;
+  toExist: () => MongoDBInlineProjectionAssert;
+  withName: (name: string) => {
     toHave: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(expected: Partial<MongoDBReadModel<Doc>> | null) => MongoDBInlineProjectionAssert<StreamNameType>;
     toDeepEquals: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(expected: MongoDBReadModel<Doc> | null) => MongoDBInlineProjectionAssert<StreamNameType>;
     toMatch: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(match: (readModel: MongoDBReadModel<Doc> | null) => boolean) => MongoDBInlineProjectionAssert<StreamNameType>;
     notToExist: <StreamNameType extends StreamName = `${string}:${string}`>() => MongoDBInlineProjectionAssert<StreamNameType>;
     toExist: () => MongoDBInlineProjectionAssert;
-    withName: (name: string) => {
-        toHave: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(expected: Partial<MongoDBReadModel<Doc>> | null) => MongoDBInlineProjectionAssert<StreamNameType>;
-        toDeepEquals: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(expected: MongoDBReadModel<Doc> | null) => MongoDBInlineProjectionAssert<StreamNameType>;
-        toMatch: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(match: (readModel: MongoDBReadModel<Doc> | null) => boolean) => MongoDBInlineProjectionAssert<StreamNameType>;
-        notToExist: <StreamNameType extends StreamName = `${string}:${string}`>() => MongoDBInlineProjectionAssert<StreamNameType>;
-        toExist: () => MongoDBInlineProjectionAssert;
-    };
+  };
 };
-
+//#endregion
+//#region src/eventStore/storage/mongoDBEventStoreStorage.d.ts
 type MongoDBEventStoreCollectionPerStreamTypeStorageOptions = {
-    /**
-     * The recommended setting where each stream type will be kept
-     * in a separate collection type using the format: `emt_${streamType}`.
-     */
-    type: 'COLLECTION_PER_STREAM_TYPE';
-    databaseName?: string;
+  /**
+   * The recommended setting where each stream type will be kept
+   * in a separate collection type using the format: `emt_${streamType}`.
+   */
+  type: 'COLLECTION_PER_STREAM_TYPE';
+  databaseName?: string;
 };
 type MongoDBEventStoreSingleCollectionStorageOptions = {
-    /**
-     * All streams will be kept withing a single MongDB collection
-     * It'll either use default collection name ("emt_streams")
-     * or provided name through 'collection' param.
-     */
-    type: 'SINGLE_COLLECTION';
-    collectionName?: string;
-    databaseName?: string;
+  /**
+   * All streams will be kept withing a single MongDB collection
+   * It'll either use default collection name ("emt_streams")
+   * or provided name through 'collection' param.
+   */
+  type: 'SINGLE_COLLECTION';
+  collectionName?: string;
+  databaseName?: string;
 };
 type MongoDBEventStoreCollectionResolution = {
-    databaseName?: string;
-    collectionName: string;
+  databaseName?: string;
+  collectionName: string;
 };
 type MongoDBEventStoreCustomStorageOptions = {
-    /**
-     * This is advanced option, where you specify your own collection
-     * resolution function. You can do that by specifying the `collectionFor` function.
-     */
-    type: 'CUSTOM';
-    databaseName?: string;
-    collectionFor: <T extends StreamType>(streamType: T) => string | MongoDBEventStoreCollectionResolution;
+  /**
+   * This is advanced option, where you specify your own collection
+   * resolution function. You can do that by specifying the `collectionFor` function.
+   */
+  type: 'CUSTOM';
+  databaseName?: string;
+  collectionFor: <T extends StreamType>(streamType: T) => string | MongoDBEventStoreCollectionResolution;
 };
 type MongoDBEventStoreStorageOptions = 'COLLECTION_PER_STREAM_TYPE' | 'SINGLE_COLLECTION' | MongoDBEventStoreSingleCollectionStorageOptions | MongoDBEventStoreCollectionPerStreamTypeStorageOptions | MongoDBEventStoreCustomStorageOptions;
 declare const DefaultMongoDBEventStoreStorageOptions = "COLLECTION_PER_STREAM_TYPE";
 type MongoDBEventStoreStorage = {
-    collectionFor: <T extends StreamType, EventType extends Event = Event>(streamType: T) => Promise<Collection<EventStream<EventType>>>;
+  collectionFor: <T extends StreamType, EventType extends Event = Event>(streamType: T) => Promise<Collection<EventStream<EventType>>>;
 };
 declare const DefaultMongoDBEventStoreCollectionName = "emt:streams";
 declare const mongoDBEventStoreStorage: (options: {
-    storage?: MongoDBEventStoreStorageOptions | undefined;
-    getConnectedClient: () => Promise<MongoClient>;
+  storage?: MongoDBEventStoreStorageOptions | undefined;
+  getConnectedClient: () => Promise<MongoClient>;
 }) => MongoDBEventStoreStorage;
-
+//#endregion
+//#region src/eventStore/mongoDBEventStore.d.ts
 declare const MongoDBEventStoreDefaultStreamVersion = 0n;
 type StreamType = string;
 type StreamName<T extends StreamType = StreamType> = `${T}:${string}`;
 type StreamNameParts<T extends StreamType = StreamType> = {
-    streamType: T;
-    streamId: string;
+  streamType: T;
+  streamId: string;
 };
 type StreamCollectionName<T extends StreamType = StreamType> = `emt:${T}`;
 type StreamCollectionNameParts<T extends StreamType = StreamType> = {
-    streamType: T;
+  streamType: T;
 };
 type MongoDBReadModelMetadata = {
-    streamId: string;
-    name: string;
-    schemaVersion: number;
-    streamPosition: bigint;
+  streamId: string;
+  name: string;
+  schemaVersion: number;
+  streamPosition: bigint;
 };
 type MongoDBReadModel<Doc extends Document = Document> = Doc & {
-    _metadata: MongoDBReadModelMetadata;
+  _metadata: MongoDBReadModelMetadata;
 };
 interface EventStream<EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> {
-    streamName: string;
-    messages: Array<ReadEvent<EventType, EventMetaDataType>>;
-    metadata: {
-        streamId: string;
-        streamType: StreamType;
-        streamPosition: bigint;
-        createdAt: Date;
-        updatedAt: Date;
-    };
-    projections: Record<string, MongoDBReadModel>;
+  streamName: string;
+  messages: Array<ReadEvent<EventType, EventMetaDataType>>;
+  metadata: {
+    streamId: string;
+    streamType: StreamType;
+    streamPosition: bigint;
+    createdAt: Date;
+    updatedAt: Date;
+  };
+  projections: Record<string, MongoDBReadModel>;
 }
 type MongoDBReadEventMetadata = ReadEventMetadataWithoutGlobalPosition;
 type MongoDBReadEvent<EventType extends Event = Event> = ReadEvent<EventType, MongoDBReadEventMetadata>;
 type SingleProjectionQueryStreamFilter<T extends StreamType> = {
-    projectionName?: string;
+  projectionName?: string;
 } & ({
-    streamName: StreamName<T>;
+  streamName: StreamName<T>;
 } | {
-    streamType: T;
-    streamId?: string;
+  streamType: T;
+  streamId?: string;
 });
 type MultiProjectionQueryStreamFilter<T extends StreamType> = {
-    projectionName?: string;
+  projectionName?: string;
 } & ({
-    streamNames: StreamName<T>[];
+  streamNames: StreamName<T>[];
 } | {
-    streamType: T;
-    streamIds?: string[];
+  streamType: T;
+  streamIds?: string[];
 });
 type MultiProjectionQueryOptions = {
-    skip?: number;
-    limit?: number;
-    sort?: [string, 1 | -1][] | Record<string, 1 | -1>;
+  skip?: number;
+  limit?: number;
+  sort?: [string, 1 | -1][] | Record<string, 1 | -1>;
 };
 /**
  * Helpers for querying inline projections on event streams.
  */
 type InlineProjectionQueries<T extends StreamType> = {
-    /**
-     * Helper for querying for a single projection. Similar to `collection.findOne`.
-     * @param streamFilter - A filter object for stream level fields. If `streamType` is required if `streamName` is not provided. If `projectionName` is not provided, the default projection will be used (`MongoDBDefaultInlineProjectionName`).
-     * @param projectionQuery - A MongoDB filter query based on the projection schema. Internally, this function will prepend each object key with the necessary projection name.
-     */
-    findOne: <Doc extends Document>(streamFilter: SingleProjectionQueryStreamFilter<T>, projectionQuery?: Filter<MongoDBReadModel<Doc>>) => Promise<MongoDBReadModel<Doc> | null>;
-    /**
-     * Helper for querying for multiple projections. Similar to `collection.find`.
-     *
-     * ***NOTE***: If `streamFilter.streamNames` is an empty array, this function will return an empty array. If `streamFilter.streamIds` is an empty array, the `streamIds` filter will not be used.
-     *
-     * @param streamFilter - A filter object for stream level fields. If `streamType` is required if `streamNames` is not provided. If `projectionName` is not provided, the default projection will be used (`MongoDBDefaultInlineProjectionName`).
-     * @param projectionQuery - A MongoDB filter query based on the projection schema. Internally, this function will prepend each object key with the necessary projection name.
-     * @param queryOptions - Additional query options like `skip`, `limit`, and `sort`. `sort`, similar to `projectionQuery`, will prepend each object key with the necessary projection name.
-     */
-    find: <Doc extends Document>(streamFilter: MultiProjectionQueryStreamFilter<T>, projectionQuery?: Filter<MongoDBReadModel<Doc>>, queryOptions?: MultiProjectionQueryOptions) => Promise<MongoDBReadModel<Doc>[]>;
-    /**
-     * Returns the total number of documents matching the provided filter options. Similar to `collection.countDocuments`.
-     *
-     * ***NOTE***: If `streamFilter.streamNames` is an empty array, this function will return `0`. If `streamFilter.streamIds` is an empty array, the `streamIds` filter will not be used.
-     *
-     * @param streamFilter - A filter object for stream level fields. If `streamType` is required if `streamNames` is not provided. If `projectionName` is not provided, the default projection will be used (`MongoDBDefaultInlineProjectionName`).
-     * @param projectionQuery - A MongoDB filter query based on the projection schema. Internally, this function will prepend each object key with the necessary projection name.
-     */
-    count: <Doc extends Document>(streamFilter: MultiProjectionQueryStreamFilter<T>, projectionQuery?: Filter<MongoDBReadModel<Doc>>) => Promise<number>;
+  /**
+   * Helper for querying for a single projection. Similar to `collection.findOne`.
+   * @param streamFilter - A filter object for stream level fields. If `streamType` is required if `streamName` is not provided. If `projectionName` is not provided, the default projection will be used (`MongoDBDefaultInlineProjectionName`).
+   * @param projectionQuery - A MongoDB filter query based on the projection schema. Internally, this function will prepend each object key with the necessary projection name.
+   */
+  findOne: <Doc extends Document>(streamFilter: SingleProjectionQueryStreamFilter<T>, projectionQuery?: Filter<MongoDBReadModel<Doc>>) => Promise<MongoDBReadModel<Doc> | null>;
+  /**
+   * Helper for querying for multiple projections. Similar to `collection.find`.
+   *
+   * ***NOTE***: If `streamFilter.streamNames` is an empty array, this function will return an empty array. If `streamFilter.streamIds` is an empty array, the `streamIds` filter will not be used.
+   *
+   * @param streamFilter - A filter object for stream level fields. If `streamType` is required if `streamNames` is not provided. If `projectionName` is not provided, the default projection will be used (`MongoDBDefaultInlineProjectionName`).
+   * @param projectionQuery - A MongoDB filter query based on the projection schema. Internally, this function will prepend each object key with the necessary projection name.
+   * @param queryOptions - Additional query options like `skip`, `limit`, and `sort`. `sort`, similar to `projectionQuery`, will prepend each object key with the necessary projection name.
+   */
+  find: <Doc extends Document>(streamFilter: MultiProjectionQueryStreamFilter<T>, projectionQuery?: Filter<MongoDBReadModel<Doc>>, queryOptions?: MultiProjectionQueryOptions) => Promise<MongoDBReadModel<Doc>[]>;
+  /**
+   * Returns the total number of documents matching the provided filter options. Similar to `collection.countDocuments`.
+   *
+   * ***NOTE***: If `streamFilter.streamNames` is an empty array, this function will return `0`. If `streamFilter.streamIds` is an empty array, the `streamIds` filter will not be used.
+   *
+   * @param streamFilter - A filter object for stream level fields. If `streamType` is required if `streamNames` is not provided. If `projectionName` is not provided, the default projection will be used (`MongoDBDefaultInlineProjectionName`).
+   * @param projectionQuery - A MongoDB filter query based on the projection schema. Internally, this function will prepend each object key with the necessary projection name.
+   */
+  count: <Doc extends Document>(streamFilter: MultiProjectionQueryStreamFilter<T>, projectionQuery?: Filter<MongoDBReadModel<Doc>>) => Promise<number>;
 };
 /**
  * Helpers for querying projections on event streams.
  */
 type ProjectionQueries<T extends StreamType> = {
-    inline: InlineProjectionQueries<T>;
+  inline: InlineProjectionQueries<T>;
 };
 type MongoDBEventStoreClientOptions = {
-    client: MongoClient;
-    connectionString?: never;
-    clientOptions?: never;
+  client: MongoClient;
+  connectionString?: never;
+  clientOptions?: never;
 };
 type MongoDBEventStoreConnectionStringOptions = {
-    client?: never;
-    connectionString: string;
-    clientOptions?: MongoClientOptions;
+  client?: never;
+  connectionString: string;
+  clientOptions?: MongoClientOptions;
 };
 type MongoDBEventStoreConnectionOptions = MongoDBEventStoreClientOptions | MongoDBEventStoreConnectionStringOptions;
 type MongoDBEventStoreOptions = {
-    projections?: ProjectionRegistration<'inline', MongoDBReadEventMetadata, MongoDBProjectionInlineHandlerContext>[];
-    storage?: MongoDBEventStoreStorageOptions;
+  projections?: ProjectionRegistration<'inline', MongoDBReadEventMetadata, MongoDBProjectionInlineHandlerContext>[];
+  storage?: MongoDBEventStoreStorageOptions;
 } & MongoDBEventStoreConnectionOptions & DefaultEventStoreOptions<MongoDBEventStore>;
 type MongoDBEventStore = EventStore<MongoDBReadEventMetadata> & {
-    projections: ProjectionQueries<StreamType>;
-    collectionFor: <EventType extends Event>(streamType: StreamType) => Promise<Collection<EventStream<EventType>>>;
+  projections: ProjectionQueries<StreamType>;
+  collectionFor: <EventType extends Event>(streamType: StreamType) => Promise<Collection<EventStream<EventType>>>;
 };
 /**
  * Prepends `prefix` to all object keys that don't start with a '$'
  */
 declare function prependMongoFilterWithProjectionPrefix<T, Result = T>(obj: T, prefix: string): Result;
 declare function getMongoDBEventStore(options: MongoDBEventStoreOptions & {
-    client: MongoClient;
+  client: MongoClient;
 }): MongoDBEventStore;
 declare function getMongoDBEventStore(options: MongoDBEventStoreOptions & {
-    connectionString: string;
+  connectionString: string;
 }): MongoDBEventStore & Closeable;
 /**
  * Accepts a `streamType` (the type/category of the event stream) and an `streamId`
@@ -256,5 +260,6 @@ declare function toStreamCollectionName<T extends StreamType>(streamType: T): St
  * Accepts a fully formatted `streamCollectionName` and returns the parsed `streamType`.
  */
 declare function fromStreamCollectionName<T extends StreamType>(streamCollectionName: StreamCollectionName<T>): StreamCollectionNameParts<T>;
-
-export { DefaultMongoDBEventStoreCollectionName, DefaultMongoDBEventStoreStorageOptions, type EventStream, type InlineProjectionHandlerOptions, MongoDBDefaultInlineProjectionName, type MongoDBEventStore, type MongoDBEventStoreClientOptions, type MongoDBEventStoreCollectionPerStreamTypeStorageOptions, type MongoDBEventStoreCollectionResolution, type MongoDBEventStoreConnectionOptions, type MongoDBEventStoreConnectionStringOptions, type MongoDBEventStoreCustomStorageOptions, MongoDBEventStoreDefaultStreamVersion, type MongoDBEventStoreOptions, type MongoDBEventStoreSingleCollectionStorageOptions, type MongoDBEventStoreStorage, type MongoDBEventStoreStorageOptions, type MongoDBInlineProjectionAssert, type MongoDBInlineProjectionAssertOptions, type MongoDBInlineProjectionDefinition, type MongoDBInlineProjectionHandler, type MongoDBInlineProjectionOptions, MongoDBInlineProjectionSpec, type MongoDBInlineProjectionSpecGivenEvents, type MongoDBInlineProjectionSpecOptions, type MongoDBProjectionInlineHandlerContext, type MongoDBReadEvent, type MongoDBReadEventMetadata, type MongoDBReadModel, type MongoDBReadModelMetadata, type MongoDBWithNotNullDocumentEvolve, type MongoDBWithNullableDocumentEvolve, type StreamCollectionName, type StreamCollectionNameParts, type StreamName, type StreamNameParts, type StreamType, eventInStream, eventsInStream, expectInlineReadModel, fromStreamCollectionName, fromStreamName, getMongoDBEventStore, handleInlineProjections, mongoDBEventStoreStorage, mongoDBInlineProjection, prependMongoFilterWithProjectionPrefix, toStreamCollectionName, toStreamName };
+//#endregion
+export { DefaultMongoDBEventStoreCollectionName, DefaultMongoDBEventStoreStorageOptions, EventStream, InlineProjectionHandlerOptions, MongoDBDefaultInlineProjectionName, MongoDBEventStore, MongoDBEventStoreClientOptions, MongoDBEventStoreCollectionPerStreamTypeStorageOptions, MongoDBEventStoreCollectionResolution, MongoDBEventStoreConnectionOptions, MongoDBEventStoreConnectionStringOptions, MongoDBEventStoreCustomStorageOptions, MongoDBEventStoreDefaultStreamVersion, MongoDBEventStoreOptions, MongoDBEventStoreSingleCollectionStorageOptions, MongoDBEventStoreStorage, MongoDBEventStoreStorageOptions, MongoDBInlineProjectionAssert, MongoDBInlineProjectionAssertOptions, MongoDBInlineProjectionDefinition, MongoDBInlineProjectionHandler, MongoDBInlineProjectionOptions, MongoDBInlineProjectionSpec, MongoDBInlineProjectionSpecGivenEvents, MongoDBInlineProjectionSpecOptions, MongoDBProjectionInlineHandlerContext, MongoDBReadEvent, MongoDBReadEventMetadata, MongoDBReadModel, MongoDBReadModelMetadata, MongoDBWithNotNullDocumentEvolve, MongoDBWithNullableDocumentEvolve, StreamCollectionName, StreamCollectionNameParts, StreamName, StreamNameParts, StreamType, eventInStream, eventsInStream, expectInlineReadModel, fromStreamCollectionName, fromStreamName, getMongoDBEventStore, handleInlineProjections, mongoDBEventStoreStorage, mongoDBInlineProjection, prependMongoFilterWithProjectionPrefix, toStreamCollectionName, toStreamName };
+//# sourceMappingURL=index.d.cts.map