@event-driven-io/emmett-sqlite 0.43.0-apha.2 → 0.43.0-beta.10

package/dist/index.d.cts

@@ -1,84 +1,10 @@
-import { SQL, SQLExecutor, AnyDumboDatabaseDriver, Dumbo, DumboConnectionOptions, QueryResultRow } from '@event-driven-io/dumbo';
+import * as _event_driven_io_emmett from '@event-driven-io/emmett';
+import { Event, AppendToStreamOptions, BeforeEventStoreCommitHandler, JSONSerializer, Message, RecordedMessageMetadata, RecordedMessage, RecordedMessageMetadataWithGlobalPosition, ProcessorCheckpoint, ReadStreamOptions, ReadStreamResult, ReadEventMetadataWithGlobalPosition, ReadEvent, CanHandle, EventStoreReadSchemaOptions, JSONSerializationOptions, TruncateProjection, ThenThrows } from '@event-driven-io/emmett';
+import { PongoDocument, PongoDBCollectionOptions, PongoClient, WithId, PongoFilter } from '@event-driven-io/pongo';
+import { a as SQLiteEventStore, b as SQLiteReadEventMetadata, c as SQLiteProjectionHandlerContext, d as SQLiteProjectionDefinition, A as AnyEventStoreDriver, I as InferOptionsFromEventStoreDriver } from './sqliteProjection-BrbKryzB.cjs';
+export { C as CreateEventStoreSchemaOptions, e as EventHandler, f as EventStoreSchemaMigrationOptions, g as SQLiteEventStoreDefaultStreamVersion, S as SQLiteEventStoreOptions, h as SQLiteProjectionHandler, i as SQLiteProjectionHandlerOptions, j as SQLiteRawBatchSQLProjection, k as SQLiteRawSQLProjection, l as SQLiteReadEvent, m as SQLiteStreamExistsOptions, n as createEventStoreSchema, o as getSQLiteEventStore, p as handleProjections, q as messagesTableSQL, r as processorsTableSQL, s as projectionsTableSQL, t as schemaSQL, u as sqliteProjection, v as sqliteRawBatchSQLProjection, w as sqliteRawSQLProjection, x as streamExists, y as streamsTableSQL } from './sqliteProjection-BrbKryzB.cjs';
+import { SQL, SQLExecutor, Dumbo, QueryResultRow } from '@event-driven-io/dumbo';
 import { AnySQLiteConnection } from '@event-driven-io/dumbo/sqlite';
-import { Event, ReadEvent, ReadEventMetadataWithGlobalPosition, EmmettError, AppendToStreamOptions, BeforeEventStoreCommitHandler, ReadEventMetadata, ReadStreamOptions, BigIntStreamPosition, ReadStreamResult, StreamExistsResult, EventStore, AppendToStreamResultWithGlobalPosition, ProjectionRegistration, ProjectionHandler, ProjectionDefinition, CanHandle, ProjectionInitOptions, ThenThrows } from '@event-driven-io/emmett';
-
-type SQLiteEventStoreMessageBatchPullerStartFrom = {
-    globalPosition: bigint;
-} | 'BEGINNING' | 'END';
-
-type SQLiteProcessorEventsBatch<EventType extends Event = Event> = {
-    messages: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>[];
-};
-type SQLiteProcessorHandlerContext = {
-    connection: AnySQLiteConnection;
-};
-type SQLiteProcessor<EventType extends Event = Event> = {
-    id: string;
-    start: (connection: AnySQLiteConnection) => Promise<SQLiteEventStoreMessageBatchPullerStartFrom | undefined>;
-    isActive: boolean;
-    handle: (messagesBatch: SQLiteProcessorEventsBatch<EventType>, context: {
-        connection?: AnySQLiteConnection;
-    }) => Promise<SQLiteProcessorMessageHandlerResult>;
-};
-declare const SQLiteProcessor: {
-    result: {
-        skip: (options?: {
-            reason?: string;
-        }) => SQLiteProcessorMessageHandlerResult;
-        stop: (options?: {
-            reason?: string;
-            error?: EmmettError;
-        }) => SQLiteProcessorMessageHandlerResult;
-    };
-};
-type SQLiteProcessorMessageHandlerResult = void | {
-    type: 'SKIP';
-    reason?: string;
-} | {
-    type: 'STOP';
-    reason?: string;
-    error?: EmmettError;
-};
-type SQLiteProcessorEachMessageHandler<EventType extends Event = Event> = (event: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>, context: SQLiteProcessorHandlerContext) => Promise<SQLiteProcessorMessageHandlerResult> | SQLiteProcessorMessageHandlerResult;
-type SQLiteProcessorStartFrom = SQLiteEventStoreMessageBatchPullerStartFrom | 'CURRENT';
-type SQLiteProcessorConnectionOptions = {
-    fileName: string;
-    connection?: AnySQLiteConnection;
-};
-type GenericSQLiteProcessorOptions<EventType extends Event = Event> = {
-    processorId: string;
-    version?: number;
-    partition?: string;
-    startFrom?: SQLiteProcessorStartFrom;
-    stopAfter?: (message: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>) => boolean;
-    eachMessage: SQLiteProcessorEachMessageHandler<EventType>;
-    connectionOptions?: SQLiteProcessorConnectionOptions;
-};
-type SQLiteProjectionProcessorOptions<EventType extends Event = Event> = {
-    processorId?: string;
-    version?: number;
-    projection: SQLiteProjectionDefinition<EventType>;
-    partition?: string;
-    startFrom?: SQLiteProcessorStartFrom;
-    stopAfter?: (message: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>) => boolean;
-};
-type SQLiteProcessorOptions<EventType extends Event = Event> = GenericSQLiteProcessorOptions<EventType> | SQLiteProjectionProcessorOptions<EventType>;
-
-type SQLiteEventStoreConsumerConfig<ConsumerEventType extends Event = Event> = {
-    processors?: SQLiteProcessor<ConsumerEventType>[];
-    pulling?: {
-        batchSize?: number;
-        pullingFrequencyInMs?: number;
-    };
-};
-type SQLiteEventStoreConsumer<ConsumerEventType extends Event = Event> = Readonly<{
-    isRunning: boolean;
-    processors: SQLiteProcessor<ConsumerEventType>[];
-    processor: <EventType extends ConsumerEventType = ConsumerEventType>(options: SQLiteProcessorOptions<EventType>) => SQLiteProcessor<EventType>;
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
-    close: () => Promise<void>;
-}>;
 
 type AppendEventResult = {
     success: true;
@@ -108,7 +34,7 @@ declare const readLastMessageGlobalPosition: (execute: SQLExecutor, options?: {
     partition?: string;
 }) => Promise<ReadLastMessageGlobalPositionResult>;
 
-type ReadMessagesBatchOptions = {
+type ReadMessagesBatchOptions = ({
     after: bigint;
     batchSize: number;
 } | {
@@ -120,31 +46,33 @@ type ReadMessagesBatchOptions = {
 } | {
     from: bigint;
     to: bigint;
+}) & {
+    partition?: string;
+    serializer: JSONSerializer;
 };
-type ReadMessagesBatchResult<EventType extends Event, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> = {
+type ReadMessagesBatchResult<MessageType extends Message, MessageMetadataType extends RecordedMessageMetadata = RecordedMessageMetadata> = {
     currentGlobalPosition: bigint;
-    messages: ReadEvent<EventType, ReadEventMetadataType>[];
-    areEventsLeft: boolean;
+    messages: RecordedMessage<MessageType, MessageMetadataType>[];
+    areMessagesLeft: boolean;
 };
-declare const readMessagesBatch: <MessageType extends Event, ReadEventMetadataType extends ReadEventMetadataWithGlobalPosition = ReadEventMetadataWithGlobalPosition>(execute: SQLExecutor, options: ReadMessagesBatchOptions & {
-    partition?: string;
-}) => Promise<ReadMessagesBatchResult<MessageType, ReadEventMetadataType>>;
+declare const readMessagesBatch: <MessageType extends Message, RecordedMessageMetadataType extends RecordedMessageMetadataWithGlobalPosition = RecordedMessageMetadataWithGlobalPosition>(execute: SQLExecutor, options: ReadMessagesBatchOptions) => Promise<ReadMessagesBatchResult<MessageType, RecordedMessageMetadataType>>;
 
 type ReadProcessorCheckpointResult = {
-    lastProcessedPosition: bigint | null;
+    lastProcessedCheckpoint: ProcessorCheckpoint | null;
 };
 declare const readProcessorCheckpoint: (execute: SQLExecutor, options: {
     processorId: string;
     partition?: string;
 }) => Promise<ReadProcessorCheckpointResult>;
 
-declare const readStream: <EventType extends Event, EventPayloadType extends Event = EventType>(execute: SQLExecutor, streamId: string, options?: ReadStreamOptions<BigIntStreamPosition, EventType, EventPayloadType> & {
+declare const readStream: <EventType extends Event, EventPayloadType extends Event = EventType>(execute: SQLExecutor, streamId: string, options: ReadStreamOptions<EventType, EventPayloadType> & {
     partition?: string;
+    serializer: JSONSerializer;
 }) => Promise<ReadStreamResult<EventType, ReadEventMetadataWithGlobalPosition>>;
 
-type StoreLastProcessedProcessorPositionResult<Position extends bigint | null = bigint> = {
+type StoreProcessorCheckpointResult = {
     success: true;
-    newPosition: Position;
+    newCheckpoint: ProcessorCheckpoint | null;
 } | {
     success: false;
     reason: 'IGNORED' | 'MISMATCH';
@@ -152,22 +80,11 @@ type StoreLastProcessedProcessorPositionResult<Position extends bigint | null =
 declare function storeProcessorCheckpoint(execute: SQLExecutor, options: {
     processorId: string;
     version: number | undefined;
-    newPosition: bigint | null;
-    lastProcessedPosition: bigint | null;
+    newCheckpoint: ProcessorCheckpoint | null;
+    lastProcessedCheckpoint: ProcessorCheckpoint | null;
     partition?: string;
-}): Promise<StoreLastProcessedProcessorPositionResult<bigint | null>>;
-
-type SQLiteStreamExistsOptions = {
-    partition: string;
-};
-declare const streamExists: (execute: SQLExecutor, streamId: string, options?: SQLiteStreamExistsOptions) => Promise<StreamExistsResult>;
-
-declare const streamsTableSQL: SQL;
-declare const messagesTableSQL: SQL;
-declare const processorsTableSQL: SQL;
-declare const projectionsTableSQL: SQL;
-declare const schemaSQL: SQL[];
-declare const createEventStoreSchema: (pool: AnySQLiteConnection, hooks?: SQLiteEventStoreOptions["hooks"]) => Promise<void>;
+    processorInstanceId?: string;
+}): Promise<StoreProcessorCheckpointResult>;
 
 declare const emmettPrefix = "emt";
 declare const globalTag = "global";
@@ -205,77 +122,88 @@ declare const projectionsTable: {
     name: string;
 };
 
-type EventHandler<E extends Event = Event> = (eventEnvelope: ReadEvent<E>) => void;
-declare const SQLiteEventStoreDefaultStreamVersion = 0n;
-interface SQLiteEventStore extends EventStore<SQLiteReadEventMetadata> {
-    appendToStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, events: EventType[], options?: AppendToStreamOptions<BigIntStreamPosition, EventType, EventPayloadType>): Promise<AppendToStreamResultWithGlobalPosition>;
-    consumer<ConsumerEventType extends Event = Event>(options?: SQLiteEventStoreConsumerConfig<ConsumerEventType>): SQLiteEventStoreConsumer<ConsumerEventType>;
-    streamExists(streamName: string, options?: SQLiteStreamExistsOptions): Promise<StreamExistsResult>;
-    close(): Promise<void>;
-    schema: {
-        sql(): string;
-        print(): void;
-        migrate(): Promise<void>;
+type PongoProjectionHandlerContext = SQLiteProjectionHandlerContext & {
+    pongo: PongoClient;
+};
+type PongoWithNotNullDocumentEvolve<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ((document: Document, event: ReadEvent<EventType, EventMetaDataType>) => Document | null) | ((document: Document, event: ReadEvent<EventType>) => Promise<Document | null>);
+type PongoWithNullableDocumentEvolve<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ((document: Document | null, event: ReadEvent<EventType, EventMetaDataType>) => Document | null) | ((document: Document | null, event: ReadEvent<EventType>) => Promise<Document | null>);
+type PongoDocumentEvolve<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType> | PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+type PongoProjectionOptions<EventType extends Event, EventPayloadType extends Event = EventType> = {
+    name: string;
+    kind?: string;
+    version?: number;
+    handle: (events: ReadEvent<EventType, SQLiteReadEventMetadata>[], context: PongoProjectionHandlerContext) => Promise<void>;
+    canHandle: CanHandle<EventType>;
+    truncate?: TruncateProjection<PongoProjectionHandlerContext>;
+    init?: (context: PongoProjectionHandlerContext) => void | Promise<void>;
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
     };
-}
-type SQLiteReadEventMetadata = ReadEventMetadataWithGlobalPosition;
-type SQLiteReadEvent<EventType extends Event = Event> = ReadEvent<EventType, SQLiteReadEventMetadata>;
-type SQLiteEventStoreOptions<DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver> = {
-    driver: DatabaseDriver;
-    projections?: ProjectionRegistration<'inline', SQLiteReadEventMetadata, SQLiteProjectionHandlerContext>[];
-    schema?: {
-        autoMigration?: 'None' | 'CreateOrUpdate';
+} & JSONSerializationOptions;
+declare const pongoProjection: <EventType extends Event, EventPayloadType extends Event = EventType>({ name, kind, version, truncate, handle, canHandle, eventsOptions, }: PongoProjectionOptions<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type PongoMultiStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType, DocumentPayload extends PongoDocument = Document> = {
+    kind?: string;
+    canHandle: CanHandle<EventType>;
+    version?: number;
+    collectionName: string;
+    collectionOptions?: PongoDBCollectionOptions<Document, DocumentPayload>;
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
     };
-    hooks?: {
-        /**
-         * This hook will be called **BEFORE** event store schema is created
-         */
-        onBeforeSchemaCreated?: (context: {
-            connection: AnySQLiteConnection;
-        }) => Promise<void> | void;
-        /**
-         * This hook will be called **BEFORE** events were stored in the event store.
-         * @type {BeforeEventStoreCommitHandler<SQLiteEventStore, HandlerContext>}
-         */
-        onBeforeCommit?: BeforeEventStoreCommitHandler<SQLiteEventStore, {
-            connection: AnySQLiteConnection;
-        }>;
-        /**
-         * This hook will be called **AFTER** event store schema was created
-         */
-        onAfterSchemaCreated?: () => Promise<void> | void;
+    getDocumentId: (event: ReadEvent<EventType>) => string;
+} & ({
+    evolve: PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+} | {
+    evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
+    initialState: () => Document;
+}) & JSONSerializationOptions;
+declare const pongoMultiStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType>(options: PongoMultiStreamProjectionOptions<Document, EventType, EventMetaDataType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type PongoSingleStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType, DocumentPayload extends PongoDocument = Document> = {
+    canHandle: CanHandle<EventType>;
+    getDocumentId?: (event: ReadEvent<EventType>) => string;
+    version?: number;
+    collectionName: string;
+    collectionOptions?: PongoDBCollectionOptions<Document, DocumentPayload>;
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
     };
-} & {
-    pool?: Dumbo;
-} & DumboConnectionOptions<DatabaseDriver>;
-declare const getSQLiteEventStore: <DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver>(options: SQLiteEventStoreOptions<DatabaseDriver>) => SQLiteEventStore;
+} & ({
+    evolve: PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+} | {
+    evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
+    initialState: () => Document;
+}) & JSONSerializationOptions;
+declare const pongoSingleStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType>(options: PongoSingleStreamProjectionOptions<Document, EventType, EventMetaDataType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
 
-type SQLiteProjectionHandlerContext = {
-    connection: AnySQLiteConnection;
-};
-type SQLiteProjectionHandler<EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, SQLiteProjectionHandlerContext>;
-type SQLiteProjectionDefinition<EventType extends Event = Event> = ProjectionDefinition<EventType, SQLiteReadEventMetadata, SQLiteProjectionHandlerContext>;
-type SQLiteProjectionHandlerOptions<EventType extends Event = Event> = {
-    events: ReadEvent<EventType, SQLiteReadEventMetadata>[];
-    projections: SQLiteProjectionDefinition<EventType>[];
-    connection: AnySQLiteConnection;
-};
-declare const handleProjections: <EventType extends Event = Event>(options: SQLiteProjectionHandlerOptions<EventType>) => Promise<void>;
-declare const sqliteProjection: <EventType extends Event>(definition: SQLiteProjectionDefinition<EventType>) => SQLiteProjectionDefinition<EventType>;
-type SQLiteRawBatchSQLProjection<EventType extends Event> = {
-    evolve: (events: EventType[], context: SQLiteProjectionHandlerContext) => Promise<SQL[]> | SQL[];
-    canHandle: CanHandle<EventType>;
-    initSQL?: SQL | SQL[];
-    init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void>;
+type PongoAssertOptions = {
+    inCollection: string;
+    inDatabase?: string;
 };
-declare const sqliteRawBatchSQLProjection: <EventType extends Event>(options: SQLiteRawBatchSQLProjection<EventType>) => SQLiteProjectionDefinition<EventType>;
-type SQLiteRawSQLProjection<EventType extends Event> = {
-    evolve: (events: EventType, context: SQLiteProjectionHandlerContext) => Promise<SQL[]> | SQL[] | Promise<SQL> | SQL;
-    canHandle: CanHandle<EventType>;
-    initSQL?: SQL | SQL[];
-    init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void>;
+type FilterOrId<Doc extends PongoDocument | WithId<PongoDocument>> = {
+    withId: string;
+} | {
+    matchingFilter: PongoFilter<Doc>;
+};
+declare const documentExists: <Doc extends PongoDocument | WithId<PongoDocument>>(document: Doc, options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const documentsAreTheSame: <Doc extends PongoDocument | WithId<PongoDocument>>(documents: Doc[], options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const documentsMatchingHaveCount: <Doc extends PongoDocument | WithId<PongoDocument>>(expectedCount: number, options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const documentMatchingExists: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const documentDoesNotExist: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const expectPongoDocuments: {
+    fromCollection: <Doc extends PongoDocument | WithId<PongoDocument>>(collectionName: string) => {
+        withId: (id: string) => {
+            toBeEqual: (document: Doc) => SQLiteProjectionAssert;
+            toExist: () => SQLiteProjectionAssert;
+            notToExist: () => SQLiteProjectionAssert;
+        };
+        matching: <Doc_1 extends PongoDocument | WithId<PongoDocument>>(filter: PongoFilter<Doc_1>) => {
+            toBeTheSame: (documents: Doc_1[]) => SQLiteProjectionAssert;
+            toHaveCount: (expectedCount: number) => SQLiteProjectionAssert;
+            toExist: () => SQLiteProjectionAssert;
+            notToExist: () => SQLiteProjectionAssert;
+        };
+    };
 };
-declare const sqliteRawSQLProjection: <EventType extends Event>(options: SQLiteRawSQLProjection<EventType>) => SQLiteProjectionDefinition<EventType>;
 
 type SQLiteProjectionSpecEvent<EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = EventType & {
     metadata?: Partial<EventMetaDataType>;
@@ -286,11 +214,11 @@ type SQLiteProjectionSpecWhenOptions = {
 type SQLiteProjectionAssert = (options: {
     connection: AnySQLiteConnection;
 }) => Promise<void | boolean>;
-type SQLiteProjectionSpecOptions<EventType extends Event, DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver> = {
+type SQLiteProjectionSpecOptions<EventType extends Event, Driver extends AnyEventStoreDriver = AnyEventStoreDriver> = {
     projection: SQLiteProjectionDefinition<EventType>;
-    driver: DatabaseDriver;
+    driver: Driver;
     pool?: Dumbo;
-} & DumboConnectionOptions<DatabaseDriver>;
+} & InferOptionsFromEventStoreDriver<Driver> & JSONSerializationOptions;
 type SQLiteProjectionSpec<EventType extends Event> = (givenEvents: SQLiteProjectionSpecEvent<EventType>[]) => {
     when: (events: SQLiteProjectionSpecEvent<EventType>[], options?: SQLiteProjectionSpecWhenOptions) => {
         then: (assert: SQLiteProjectionAssert, message?: string) => Promise<void>;
@@ -298,11 +226,11 @@ type SQLiteProjectionSpec<EventType extends Event> = (givenEvents: SQLiteProject
     };
 };
 declare const SQLiteProjectionSpec: {
-    for: <EventType extends Event, DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver>(options: SQLiteProjectionSpecOptions<EventType, DatabaseDriver>) => SQLiteProjectionSpec<EventType>;
+    for: <EventType extends Event, Driver extends AnyEventStoreDriver = AnyEventStoreDriver>(options: SQLiteProjectionSpecOptions<EventType, Driver>) => SQLiteProjectionSpec<EventType>;
 };
 declare const eventInStream: <EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata>(streamName: string, event: SQLiteProjectionSpecEvent<EventType, EventMetaDataType>) => SQLiteProjectionSpecEvent<EventType, EventMetaDataType>;
 declare const eventsInStream: <EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata>(streamName: string, events: SQLiteProjectionSpecEvent<EventType, EventMetaDataType>[]) => SQLiteProjectionSpecEvent<EventType, EventMetaDataType>[];
-declare const newEventsInStream: <EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata>(streamName: string, events: SQLiteProjectionSpecEvent<EventType, EventMetaDataType>[]) => SQLiteProjectionSpecEvent<EventType, EventMetaDataType>[];
+declare const newEventsInStream: <EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = _event_driven_io_emmett.RecordedMessageMetadataWithGlobalPosition>(streamName: string, events: SQLiteProjectionSpecEvent<EventType, EventMetaDataType>[]) => SQLiteProjectionSpecEvent<EventType, EventMetaDataType>[];
 declare const assertSQLQueryResultMatches: <T extends QueryResultRow>(sql: SQL, rows: T[]) => SQLiteProjectionAssert;
 declare const expectSQL: {
     query: (sql: SQL) => {
@@ -312,4 +240,4 @@ declare const expectSQL: {
     };
 };
 
-export { type AppendEventResult, type EventHandler, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, type SQLiteEventStore, SQLiteEventStoreDefaultStreamVersion, type SQLiteEventStoreOptions, type SQLiteProjectionAssert, type SQLiteProjectionDefinition, type SQLiteProjectionHandler, type SQLiteProjectionHandlerContext, type SQLiteProjectionHandlerOptions, SQLiteProjectionSpec, type SQLiteProjectionSpecEvent, type SQLiteProjectionSpecOptions, type SQLiteProjectionSpecWhenOptions, type SQLiteRawBatchSQLProjection, type SQLiteRawSQLProjection, type SQLiteReadEvent, type SQLiteReadEventMetadata, type SQLiteStreamExistsOptions, type StoreLastProcessedProcessorPositionResult, appendToStream, assertSQLQueryResultMatches, createEventStoreSchema, defaultTag, emmettPrefix, eventInStream, eventsInStream, expectSQL, getSQLiteEventStore, globalNames, globalTag, handleProjections, messagesTable, messagesTableSQL, migration_0_42_0_FromSubscriptionsToProcessors, migration_0_42_0_SQLs, newEventsInStream, processorsTable, processorsTableSQL, projectionsTable, projectionsTableSQL, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, schemaSQL, schema_0_41_0, schema_0_42_0, sqliteProjection, sqliteRawBatchSQLProjection, sqliteRawSQLProjection, storeProcessorCheckpoint, streamExists, streamsTable, streamsTableSQL, unknownTag };
+export { type AppendEventResult, type PongoAssertOptions, type PongoDocumentEvolve, type PongoMultiStreamProjectionOptions, type PongoProjectionHandlerContext, type PongoProjectionOptions, type PongoSingleStreamProjectionOptions, type PongoWithNotNullDocumentEvolve, type PongoWithNullableDocumentEvolve, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, SQLiteEventStore, type SQLiteProjectionAssert, SQLiteProjectionDefinition, SQLiteProjectionHandlerContext, SQLiteProjectionSpec, type SQLiteProjectionSpecEvent, type SQLiteProjectionSpecOptions, type SQLiteProjectionSpecWhenOptions, SQLiteReadEventMetadata, type StoreProcessorCheckpointResult, appendToStream, assertSQLQueryResultMatches, defaultTag, documentDoesNotExist, documentExists, documentMatchingExists, documentsAreTheSame, documentsMatchingHaveCount, emmettPrefix, eventInStream, eventsInStream, expectPongoDocuments, expectSQL, globalNames, globalTag, messagesTable, migration_0_42_0_FromSubscriptionsToProcessors, migration_0_42_0_SQLs, newEventsInStream, pongoMultiStreamProjection, pongoProjection, pongoSingleStreamProjection, processorsTable, projectionsTable, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, schema_0_41_0, schema_0_42_0, storeProcessorCheckpoint, streamsTable, unknownTag };