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

package/dist/index-CqxXzmd1.d.cts

@@ -0,0 +1,415 @@
+import * as _$_event_driven_io_emmett0 from "@event-driven-io/emmett";
+import { AnyCommand, AnyEvent, AnyMessage, AnyRecordedMessageMetadata, AppendToStreamOptions, AppendToStreamResultWithGlobalPosition, BeforeEventStoreCommitHandler, CanHandle, Event, EventStore, EventStoreReadSchemaOptions, EventStoreSessionFactory, JSONSerializationOptions, JSONSerializer, Message, MessageConsumer, MessageConsumerOptions, MessageProcessor, ProcessorCheckpoint, ProjectionDefinition, ProjectionHandler, ProjectionInitOptions, ProjectionRegistration, ProjectorOptions, ReactorOptions, ReadEvent, ReadEventMetadataWithGlobalPosition, ReadStreamOptions, ReadStreamResult, RecordedMessage, RecordedMessageMetadata, RecordedMessageMetadataWithGlobalPosition, StreamExistsResult, ThenThrows, TruncateProjection, WorkflowProcessorContext, WorkflowProcessorOptions } from "@event-driven-io/emmett";
+import { PongoClient, PongoDBCollectionOptions, PongoDocument, PongoFilter, WithId } from "@event-driven-io/pongo";
+import { AnyDumboDatabaseDriver, DatabaseDriverType, Dumbo, ExtractDumboDatabaseDriverOptions, QueryResultRow, SQL, SQLExecutor } from "@event-driven-io/dumbo";
+import { AnySQLiteConnection } from "@event-driven-io/dumbo/sqlite";
+
+//#region src/eventStore/eventStoreDriver.d.ts
+interface EventStoreDriver<DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, DriverOptions extends AnyEventStoreDriverOptions = AnyEventStoreDriverOptions> {
+  driverType: DatabaseDriver['driverType'];
+  dumboDriver: DatabaseDriver;
+  mapToDumboOptions(driverOptions: DriverOptions): ExtractDumboDatabaseDriverOptions<DatabaseDriver>;
+}
+type EventStoreDriverOptions<Driver extends AnyEventStoreDriver = AnyEventStoreDriver> = {
+  connectionOptions?: ExtractDumboDatabaseDriverOptions<Driver['dumboDriver']> | undefined;
+};
+type AnyEventStoreDriverOptions = EventStoreDriverOptions<any>;
+type AnyEventStoreDriver = EventStoreDriver<AnyDumboDatabaseDriver, AnyEventStoreDriverOptions>;
+type InferOptionsFromEventStoreDriver<C extends AnyEventStoreDriver> = C extends EventStoreDriver<any, infer DO> ? DO : never;
+//#endregion
+//#region src/eventStore/schema/appendToStream.d.ts
+type AppendEventResult = {
+  success: true;
+  nextStreamPosition: bigint;
+  lastGlobalPosition: bigint;
+} | {
+  success: false;
+};
+declare const appendToStream: <MessageType extends Event>(connection: AnySQLiteConnection, streamName: string, streamType: string, messages: MessageType[], options?: AppendToStreamOptions & {
+  partition?: string;
+  onBeforeCommit?: BeforeEventStoreCommitHandler<SQLiteEventStore, {
+    connection: AnySQLiteConnection;
+  }>;
+}) => Promise<AppendEventResult>;
+//#endregion
+//#region src/eventStore/schema/migrations/0_41_0/0_41_0.snapshot.d.ts
+declare const schema_0_41_0: SQL[];
+//#endregion
+//#region src/eventStore/schema/migrations/0_42_0/0_42_0.migration.d.ts
+declare const migration_0_42_0_SQLs: SQL[];
+declare const migration_0_42_0_FromSubscriptionsToProcessors: (execute: SQLExecutor) => Promise<void>;
+//#endregion
+//#region src/eventStore/schema/migrations/0_42_0/0_42_0.snapshot.d.ts
+declare const schema_0_42_0: SQL[];
+//#endregion
+//#region src/eventStore/schema/readLastMessageGlobalPosition.d.ts
+type ReadLastMessageGlobalPositionResult = {
+  currentGlobalPosition: bigint | null;
+};
+declare const readLastMessageGlobalPosition: (execute: SQLExecutor, options?: {
+  partition?: string;
+}) => Promise<ReadLastMessageGlobalPositionResult>;
+//#endregion
+//#region src/eventStore/schema/readMessagesBatch.d.ts
+type ReadMessagesBatchOptions = ({
+  after: bigint;
+  batchSize: number;
+} | {
+  from: bigint;
+  batchSize: number;
+} | {
+  to: bigint;
+  batchSize: number;
+} | {
+  from: bigint;
+  to: bigint;
+}) & {
+  partition?: string;
+  serializer: JSONSerializer;
+};
+type ReadMessagesBatchResult<MessageType extends Message, MessageMetadataType extends RecordedMessageMetadata = RecordedMessageMetadata> = {
+  currentGlobalPosition: bigint;
+  messages: RecordedMessage<MessageType, MessageMetadataType>[];
+  areMessagesLeft: boolean;
+};
+declare const readMessagesBatch: <MessageType extends Message, RecordedMessageMetadataType extends RecordedMessageMetadataWithGlobalPosition = RecordedMessageMetadataWithGlobalPosition>(execute: SQLExecutor, options: ReadMessagesBatchOptions) => Promise<ReadMessagesBatchResult<MessageType, RecordedMessageMetadataType>>;
+//#endregion
+//#region src/eventStore/schema/readProcessorCheckpoint.d.ts
+type ReadProcessorCheckpointResult = {
+  lastProcessedCheckpoint: ProcessorCheckpoint | null;
+};
+declare const readProcessorCheckpoint: (execute: SQLExecutor, options: {
+  processorId: string;
+  partition?: string;
+}) => Promise<ReadProcessorCheckpointResult>;
+//#endregion
+//#region src/eventStore/schema/readStream.d.ts
+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>>;
+//#endregion
+//#region src/eventStore/schema/storeProcessorCheckpoint.d.ts
+type StoreProcessorCheckpointResult = {
+  success: true;
+  newCheckpoint: ProcessorCheckpoint | null;
+} | {
+  success: false;
+  reason: 'IGNORED' | 'MISMATCH';
+};
+declare function storeProcessorCheckpoint(execute: SQLExecutor, options: {
+  processorId: string;
+  version: number | undefined;
+  newCheckpoint: ProcessorCheckpoint | null;
+  lastProcessedCheckpoint: ProcessorCheckpoint | null;
+  partition?: string;
+  processorInstanceId?: string;
+}): Promise<StoreProcessorCheckpointResult>;
+//#endregion
+//#region src/eventStore/schema/streamExists.d.ts
+type SQLiteStreamExistsOptions = {
+  partition: string;
+};
+declare const streamExists: (execute: SQLExecutor, streamId: string, options?: SQLiteStreamExistsOptions) => Promise<StreamExistsResult>;
+//#endregion
+//#region src/eventStore/schema/tables.d.ts
+declare const streamsTableSQL: SQL;
+declare const messagesTableSQL: SQL;
+declare const processorsTableSQL: SQL;
+declare const projectionsTableSQL: SQL;
+declare const schemaSQL: SQL[];
+type CreateEventStoreSchemaOptions = {
+  dryRun?: boolean | undefined;
+  ignoreMigrationHashMismatch?: boolean | undefined;
+  migrationTimeoutMs?: number | undefined;
+};
+type EventStoreSchemaMigrationOptions = {
+  migrationOptions?: CreateEventStoreSchemaOptions;
+};
+declare const createEventStoreSchema: (pool: AnySQLiteConnection, hooks?: SQLiteEventStoreOptions["hooks"]) => Promise<void>;
+//#endregion
+//#region src/eventStore/schema/typing.d.ts
+declare const emmettPrefix = "emt";
+declare const globalTag = "global";
+declare const defaultTag = "emt:default";
+declare const unknownTag = "emt:unknown";
+declare const globalNames: {
+  module: string;
+};
+declare const streamsTable: {
+  name: string;
+  columns: {
+    partition: {
+      name: string;
+    };
+    isArchived: {
+      name: string;
+    };
+  };
+};
+declare const messagesTable: {
+  name: string;
+  columns: {
+    partition: {
+      name: string;
+    };
+    isArchived: {
+      name: string;
+    };
+  };
+};
+declare const processorsTable: {
+  name: string;
+};
+declare const projectionsTable: {
+  name: string;
+};
+//#endregion
+//#region src/eventStore/consumers/sqliteProcessor.d.ts
+type SQLiteProcessorHandlerContext = {
+  execute: SQLExecutor;
+  connection: AnySQLiteConnection;
+} & EventStoreSchemaMigrationOptions;
+type SQLiteProcessor<MessageType extends Message = AnyMessage> = MessageProcessor<MessageType, ReadEventMetadataWithGlobalPosition, SQLiteProcessorHandlerContext>;
+type SQLiteProcessorConnectionOptions = {
+  connection?: AnySQLiteConnection;
+};
+type SQLiteReactorOptions<MessageType extends Message = Message, MessagePayloadType extends AnyMessage = MessageType> = ReactorOptions<MessageType, ReadEventMetadataWithGlobalPosition, SQLiteProcessorHandlerContext, MessagePayloadType> & SQLiteProcessorConnectionOptions;
+type SQLiteProjectorOptions<EventType extends AnyEvent = AnyEvent, EventPayloadType extends Event = EventType> = ProjectorOptions<EventType, ReadEventMetadataWithGlobalPosition, SQLiteProcessorHandlerContext, EventPayloadType> & SQLiteProcessorConnectionOptions & EventStoreSchemaMigrationOptions;
+type SQLiteWorkflowProcessorOptions<Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends WorkflowProcessorContext = WorkflowProcessorContext, StoredMessage extends AnyEvent | AnyCommand = Output> = WorkflowProcessorOptions<Input, State, Output, MetaDataType, HandlerContext, StoredMessage> & SQLiteProcessorConnectionOptions & {
+  messageStore: WorkflowProcessorContext['connection']['messageStore'];
+};
+//#endregion
+//#region src/eventStore/consumers/sqliteEventStoreConsumer.d.ts
+type SQLiteEventStoreConsumerConfig<ConsumerMessageType extends Message = any> = MessageConsumerOptions<ConsumerMessageType> & {
+  stopWhen?: {
+    noMessagesLeft?: boolean;
+  };
+  pulling?: {
+    batchSize?: number;
+    pullingFrequencyInMs?: number;
+  };
+};
+type SQLiteEventStoreConsumer<ConsumerMessageType extends AnyMessage = any> = MessageConsumer<ConsumerMessageType> & Readonly<{
+  reactor: <MessageType extends AnyMessage = ConsumerMessageType>(options: SQLiteReactorOptions<MessageType>) => SQLiteProcessor<MessageType>;
+  workflowProcessor: <Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends SQLiteProcessorHandlerContext & WorkflowProcessorContext = SQLiteProcessorHandlerContext & WorkflowProcessorContext, StoredMessage extends AnyEvent | AnyCommand = Output>(options: Omit<SQLiteWorkflowProcessorOptions<Input, State, Output, MetaDataType, HandlerContext, StoredMessage>, 'messageStore'>) => SQLiteProcessor<Input | Output>;
+}> & (AnyEvent extends ConsumerMessageType ? Readonly<{
+  projector: <EventType extends AnyEvent = ConsumerMessageType & AnyEvent>(options: SQLiteProjectorOptions<EventType>) => SQLiteProcessor<EventType>;
+}> : object);
+//#endregion
+//#region src/eventStore/SQLiteEventStore.d.ts
+type EventHandler<E extends Event = Event> = (eventEnvelope: ReadEvent<E>) => void;
+declare const SQLiteEventStoreDefaultStreamVersion = 0n;
+interface SQLiteEventStore extends EventStore<SQLiteReadEventMetadata>, EventStoreSessionFactory<SQLiteEventStore> {
+  appendToStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, events: EventType[], options?: AppendToStreamOptions<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 SQLiteReadEventMetadata = ReadEventMetadataWithGlobalPosition;
+type SQLiteReadEvent<EventType extends Event = Event> = ReadEvent<EventType, SQLiteReadEventMetadata>;
+type SQLiteEventStoreOptions<EventStoreDriver extends AnyEventStoreDriver = AnyEventStoreDriver> = {
+  driver: EventStoreDriver;
+  projections?: ProjectionRegistration<'inline', SQLiteReadEventMetadata, SQLiteProjectionHandlerContext>[];
+  schema?: {
+    autoMigration?: 'None' | 'CreateOrUpdate';
+  };
+  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;
+  };
+} & {
+  pool?: Dumbo;
+} & InferOptionsFromEventStoreDriver<EventStoreDriver> & JSONSerializationOptions;
+declare const getSQLiteEventStore: <Driver extends AnyEventStoreDriver = AnyEventStoreDriver>(options: SQLiteEventStoreOptions<Driver>) => SQLiteEventStore;
+//#endregion
+//#region src/eventStore/projections/pongo/pongoProjections.d.ts
+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>;
+  };
+} & 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>;
+  };
+  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>;
+  };
+} & ({
+  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>;
+//#endregion
+//#region src/eventStore/projections/pongo/pongoProjectionSpec.d.ts
+type PongoAssertOptions = {
+  inCollection: string;
+  inDatabase?: string;
+};
+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;
+    };
+  };
+};
+//#endregion
+//#region src/eventStore/projections/sqliteProjection.d.ts
+type SQLiteProjectionHandlerContext = {
+  execute: SQLExecutor;
+  connection: AnySQLiteConnection;
+  driverType: DatabaseDriverType;
+};
+type SQLiteProjectionHandler<EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, SQLiteProjectionHandlerContext>;
+type SQLiteProjectionDefinition<EventType extends Event = Event, EventPayloadType extends Event = EventType> = ProjectionDefinition<EventType, SQLiteReadEventMetadata, SQLiteProjectionHandlerContext, EventPayloadType>;
+type SQLiteProjectionHandlerOptions<EventType extends Event = Event> = {
+  events: ReadEvent<EventType, SQLiteReadEventMetadata>[];
+  projections: SQLiteProjectionDefinition<EventType>[];
+} & SQLiteProjectionHandlerContext;
+declare const handleProjections: <EventType extends Event = Event>(options: SQLiteProjectionHandlerOptions<EventType>) => Promise<void>;
+declare const sqliteProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(definition: SQLiteProjectionDefinition<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type SQLiteRawBatchSQLProjection<EventType extends Event, EventPayloadType extends Event = EventType> = {
+  name: string;
+  kind?: string;
+  version?: number;
+  evolve: (events: EventType[], context: SQLiteProjectionHandlerContext) => Promise<SQL[]> | SQL[];
+  canHandle: CanHandle<EventType>;
+  init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void> | SQL | Promise<SQL> | Promise<SQL[]> | SQL[];
+  eventsOptions?: {
+    schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+  };
+} & JSONSerializationOptions;
+declare const sqliteRawBatchSQLProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(options: SQLiteRawBatchSQLProjection<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type SQLiteRawSQLProjection<EventType extends Event, EventPayloadType extends Event = EventType> = {
+  name: string;
+  kind?: string;
+  version?: number;
+  evolve: (events: EventType, context: SQLiteProjectionHandlerContext) => Promise<SQL[]> | SQL[] | Promise<SQL> | SQL;
+  canHandle: CanHandle<EventType>;
+  init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void> | SQL | Promise<SQL> | Promise<SQL[]> | SQL[];
+  eventsOptions?: {
+    schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+  };
+} & JSONSerializationOptions;
+declare const sqliteRawSQLProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(options: SQLiteRawSQLProjection<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+//#endregion
+//#region src/eventStore/projections/sqliteProjectionSpec.d.ts
+type SQLiteProjectionSpecEvent<EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = EventType & {
+  metadata?: Partial<EventMetaDataType>;
+};
+type SQLiteProjectionSpecWhenOptions = {
+  numberOfTimes: number;
+};
+type SQLiteProjectionSpec<EventType extends Event> = (givenEvents: SQLiteProjectionSpecEvent<EventType>[]) => {
+  when: (events: SQLiteProjectionSpecEvent<EventType>[], options?: SQLiteProjectionSpecWhenOptions) => {
+    then: (assert: SQLiteProjectionAssert, message?: string) => Promise<void>;
+    thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
+  };
+};
+type SQLiteProjectionAssert = (options: {
+  connection: AnySQLiteConnection;
+}) => Promise<void | boolean>;
+type SQLiteProjectionSpecOptions<EventType extends Event, Driver extends AnyEventStoreDriver = AnyEventStoreDriver> = {
+  projection: SQLiteProjectionDefinition<EventType>;
+  driver: Driver;
+  pool?: Dumbo;
+} & InferOptionsFromEventStoreDriver<Driver> & JSONSerializationOptions;
+declare const SQLiteProjectionSpec: {
+  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 = _$_event_driven_io_emmett0.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) => {
+    resultRows: {
+      toBeTheSame: <T extends QueryResultRow>(rows: T[]) => SQLiteProjectionAssert;
+    };
+  };
+};
+//#endregion
+export { unknownTag as $, PongoProjectionHandlerContext as A, SQLiteEventStoreDefaultStreamVersion as B, documentExists as C, schema_0_41_0 as Ct, expectPongoDocuments as D, documentsMatchingHaveCount as E, EventStoreDriver as Et, pongoMultiStreamProjection as F, defaultTag as G, SQLiteReadEvent as H, pongoProjection as I, globalTag as J, emmettPrefix as K, pongoSingleStreamProjection as L, PongoSingleStreamProjectionOptions as M, PongoWithNotNullDocumentEvolve as N, PongoDocumentEvolve as O, PongoWithNullableDocumentEvolve as P, streamsTable as Q, EventHandler as R, documentDoesNotExist as S, migration_0_42_0_SQLs as St, documentsAreTheSame as T, appendToStream as Tt, SQLiteReadEventMetadata as U, SQLiteEventStoreOptions as V, getSQLiteEventStore as W, processorsTable as X, messagesTable as Y, projectionsTable as Z, handleProjections as _, readMessagesBatch as _t, SQLiteProjectionSpecWhenOptions as a, projectionsTableSQL as at, sqliteRawSQLProjection as b, schema_0_42_0 as bt, eventsInStream as c, SQLiteStreamExistsOptions as ct, SQLiteProjectionDefinition as d, storeProcessorCheckpoint as dt, CreateEventStoreSchemaOptions as et, SQLiteProjectionHandler as f, readStream as ft, SQLiteRawSQLProjection as g, ReadMessagesBatchResult as gt, SQLiteRawBatchSQLProjection as h, ReadMessagesBatchOptions as ht, SQLiteProjectionSpecOptions as i, processorsTableSQL as it, PongoProjectionOptions as j, PongoMultiStreamProjectionOptions as k, expectSQL as l, streamExists as lt, SQLiteProjectionHandlerOptions as m, readProcessorCheckpoint as mt, SQLiteProjectionSpec as n, createEventStoreSchema as nt, assertSQLQueryResultMatches as o, schemaSQL as ot, SQLiteProjectionHandlerContext as p, ReadProcessorCheckpointResult as pt, globalNames as q, SQLiteProjectionSpecEvent as r, messagesTableSQL as rt, eventInStream as s, streamsTableSQL as st, SQLiteProjectionAssert as t, EventStoreSchemaMigrationOptions as tt, newEventsInStream as u, StoreProcessorCheckpointResult as ut, sqliteProjection as v, ReadLastMessageGlobalPositionResult as vt, documentMatchingExists as w, AppendEventResult as wt, PongoAssertOptions as x, migration_0_42_0_FromSubscriptionsToProcessors as xt, sqliteRawBatchSQLProjection as y, readLastMessageGlobalPosition as yt, SQLiteEventStore as z };
+//# sourceMappingURL=index-CqxXzmd1.d.cts.map