@event-driven-io/emmett-postgresql 0.43.0-beta.3 → 0.43.0-beta.30

package/dist/index.d.ts

@@ -1,214 +1,266 @@
-import { SQLExecutor, Dumbo, QueryResultRow, SQL, SQLMigration, RunSQLMigrationsResult, DatabaseTransaction, AnyConnection, MigrationStyle } from '@event-driven-io/dumbo';
-import * as _event_driven_io_emmett from '@event-driven-io/emmett';
-import { EmmettError, Message, BatchRecordedMessageHandlerWithoutContext, ReadEventMetadataWithGlobalPosition, ProcessorCheckpoint, ProjectionHandlingType, AnyReadEventMetadata, DefaultRecord, ProjectionRegistration, ProjectionDefinition, Event, ReadEvent, CanHandle, TruncateProjection, EventStoreReadSchemaOptions, ThenThrows, RecordedMessage, AppendToStreamOptions, RecordedMessageMetadata, RecordedMessageMetadataWithGlobalPosition, ReadStreamOptions, ReadStreamResult, StreamExistsResult, ProjectionHandler, ProjectionInitOptions, EventStore, EventStoreSessionFactory, AppendToStreamResultWithGlobalPosition, AnyMessage, ReactorOptions, MessageProcessor, AnyEvent, AnyCommand, AnyRecordedMessageMetadata, WorkflowProcessorContext, WorkflowProcessorOptions, ProjectorOptions, SingleRecordedMessageHandlerWithContext, BatchRecordedMessageHandlerWithContext, Checkpointer, MessageConsumerOptions, MessageConsumer } from '@event-driven-io/emmett';
-import { PgPoolOptions, PgTransaction, PgPool, PgClient, PgDriverType, PgPoolClientConnection, PgClientConnection } from '@event-driven-io/dumbo/pg';
-import pg from 'pg';
-import { PongoClient, PongoDocument, PongoDBCollectionOptions, WithId, PongoFilter } from '@event-driven-io/pongo';
+import * as _$_event_driven_io_emmett0 from "@event-driven-io/emmett";
+import { AnyCommand, AnyEvent, AnyMessage, AnyReadEventMetadata, AnyRecordedMessageMetadata, AppendToStreamOptions, AppendToStreamResultWithGlobalPosition, AsyncAwaiter, BatchRecordedMessageHandlerWithContext, BatchRecordedMessageHandlerWithoutContext, CanHandle, Checkpointer, CurrentMessageProcessorPosition, DefaultRecord, EmmettError, EmmettObservabilityConfig, Event, EventStore, EventStoreReadSchemaOptions, EventStoreSessionFactory, JSONSerializationOptions, Message, MessageConsumer, MessageConsumerOptions, MessageHandlerContext, MessageProcessor, ProcessorCheckpoint, ProjectionDefinition, ProjectionHandler, ProjectionHandlerContext, ProjectionHandlingType, ProjectionInitOptions, ProjectionRegistration, ProjectorOptions, ReactorOptions, ReadEvent, ReadEventMetadataWithGlobalPosition, ReadStreamOptions, ReadStreamResult, RecordedMessage, RecordedMessageMetadata, RecordedMessageMetadataWithGlobalPosition, SingleRecordedMessageHandlerWithContext, StreamExistsResult, ThenThrows, TruncateProjection, WorkflowProcessorContext, WorkflowProcessorOptions } from "@event-driven-io/emmett";
+import * as _$_event_driven_io_dumbo0 from "@event-driven-io/dumbo";
+import { AnyConnection, DatabaseTransaction, Dumbo, MigrationStyle, QueryResultRow, RunSQLMigrationsResult, SQL, SQLExecutor, SQLMigration } from "@event-driven-io/dumbo";
+import { PongoClient, PongoDBCollectionOptions, PongoDocument, PongoFilter, WithId } from "@event-driven-io/pongo";
+import { PgClient, PgClientConnection, PgConnection, PgDriverType, PgPool, PgPoolClientConnection, PgPoolOptions, PgTransaction } from "@event-driven-io/dumbo/pg";
+import pg from "pg";
 
+//#region src/eventStore/consumers/messageBatchProcessing/index.d.ts
 declare const DefaultPostgreSQLEventStoreProcessorBatchSize = 100;
 declare const DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = 50;
 type PostgreSQLEventStoreMessagesBatchHandlerResult = void | {
-    type: 'STOP';
-    reason?: string;
-    error?: EmmettError;
+  type: 'STOP';
+  reason?: string;
+  error?: EmmettError;
 };
 type PostgreSQLEventStoreMessageBatchPullerOptions<MessageType extends Message = Message> = {
-    executor: SQLExecutor;
-    pullingFrequencyInMs: number;
-    batchSize: number;
-    eachBatch: BatchRecordedMessageHandlerWithoutContext<MessageType, ReadEventMetadataWithGlobalPosition>;
-    stopWhen?: {
-        noMessagesLeft?: boolean;
-    };
-    signal: AbortSignal;
-};
-type PostgreSQLEventStoreMessageBatchPullerStartFrom = {
-    lastCheckpoint: ProcessorCheckpoint;
-} | 'BEGINNING' | 'END';
+  executor: SQLExecutor;
+  pullingFrequencyInMs: number;
+  batchSize: number;
+  eachBatch: BatchRecordedMessageHandlerWithoutContext<MessageType, ReadEventMetadataWithGlobalPosition>;
+  stopWhen?: {
+    noMessagesLeft?: boolean;
+  };
+  signal: AbortSignal;
+};
+type PostgreSQLEventStoreMessageBatchPullerStartFrom = CurrentMessageProcessorPosition;
 type PostgreSQLEventStoreMessageBatchPullerStartOptions = {
-    startFrom: PostgreSQLEventStoreMessageBatchPullerStartFrom;
-    signal?: AbortSignal;
+  startFrom: PostgreSQLEventStoreMessageBatchPullerStartFrom;
+  signal?: AbortSignal;
+  started?: AsyncAwaiter<void>;
 };
 type PostgreSQLEventStoreMessageBatchPuller = {
-    isRunning: boolean;
-    start(options: PostgreSQLEventStoreMessageBatchPullerStartOptions): Promise<void>;
-    stop(): Promise<void>;
-};
-declare const postgreSQLEventStoreMessageBatchPuller: <MessageType extends Message = Message>({ executor, batchSize, eachBatch, pullingFrequencyInMs, stopWhen, signal, }: PostgreSQLEventStoreMessageBatchPullerOptions<MessageType>) => PostgreSQLEventStoreMessageBatchPuller;
-declare const zipPostgreSQLEventStoreMessageBatchPullerStartFrom: (options: (PostgreSQLEventStoreMessageBatchPullerStartFrom | undefined)[]) => PostgreSQLEventStoreMessageBatchPullerStartFrom;
-
+  isRunning: boolean;
+  start(options: PostgreSQLEventStoreMessageBatchPullerStartOptions): Promise<void>;
+  stop(): Promise<void>;
+};
+declare const postgreSQLEventStoreMessageBatchPuller: <MessageType extends Message = Message>({
+  executor,
+  batchSize,
+  eachBatch,
+  pullingFrequencyInMs,
+  stopWhen,
+  signal
+}: PostgreSQLEventStoreMessageBatchPullerOptions<MessageType>) => PostgreSQLEventStoreMessageBatchPuller;
+//#endregion
+//#region src/eventStore/projections/locks/tryAcquireProcessorLock.d.ts
 type TryAcquireProcessorLockOptions = {
-    processorId: string;
+  processorId: string;
+  version: number;
+  partition: string;
+  processorInstanceId: string;
+  projection?: {
+    name: string;
+    handlingType: ProjectionHandlingType;
+    kind: string;
     version: number;
-    partition: string;
-    processorInstanceId: string;
-    projection?: {
-        name: string;
-        handlingType: ProjectionHandlingType;
-        kind: string;
-        version: number;
-    };
-    lockKey: string | bigint;
-    lockTimeoutSeconds?: number;
+  };
+  lockKey: string | bigint;
+  lockTimeoutSeconds?: number;
 };
 type LockAcquisitionPolicy = {
-    type: 'fail';
+  type: 'fail';
 } | {
-    type: 'skip';
+  type: 'skip';
 } | {
-    type: 'retry';
-    retries: number;
-    minTimeout?: number;
-    maxTimeout?: number;
+  type: 'retry';
+  retries: number;
+  minTimeout?: number;
+  maxTimeout?: number;
 };
-
+//#endregion
+//#region src/eventStore/projections/locks/postgreSQLProcessorLock.d.ts
 type PostgreSQLProcessorLockOptions = {
-    processorId: string;
+  processorId: string;
+  version: number;
+  partition: string;
+  processorInstanceId: string;
+  projection?: {
+    name: string;
+    handlingType: ProjectionHandlingType;
+    kind: string;
     version: number;
-    partition: string;
-    processorInstanceId: string;
-    projection?: {
-        name: string;
-        handlingType: ProjectionHandlingType;
-        kind: string;
-        version: number;
-    };
-    lockKey?: string | bigint;
-    lockTimeoutSeconds?: number;
-    lockAcquisitionPolicy?: LockAcquisitionPolicy;
+  };
+  lockKey?: string | bigint;
+  lockTimeoutSeconds?: number;
+  lockAcquisitionPolicy?: LockAcquisitionPolicy;
 };
 type PostgreSQLProcessorLockContext = {
-    execute: SQLExecutor;
+  execute: SQLExecutor;
 };
 type PostgreSQLProcessorLock = {
-    tryAcquire: (options: PostgreSQLProcessorLockContext) => Promise<boolean>;
-    release: (options: PostgreSQLProcessorLockContext) => Promise<void>;
+  tryAcquire: (options: PostgreSQLProcessorLockContext) => Promise<boolean>;
+  release: (options: PostgreSQLProcessorLockContext) => Promise<void>;
 };
 declare const DefaultPostgreSQLProcessorLockPolicy: LockAcquisitionPolicy;
 declare const postgreSQLProcessorLock: (options: PostgreSQLProcessorLockOptions) => PostgreSQLProcessorLock;
-declare const toProcessorLockKey: ({ projection, processorId, partition, version, }: Pick<TryAcquireProcessorLockOptions, "projection" | "processorId" | "version" | "partition">) => string;
-
+declare const toProcessorLockKey: ({
+  projection,
+  processorId,
+  partition,
+  version
+}: Pick<TryAcquireProcessorLockOptions, "projection" | "processorId" | "version" | "partition">) => string;
+//#endregion
+//#region src/eventStore/projections/locks/tryAcquireProjectionLock.d.ts
 type TryAcquireProjectionLockOptions = {
-    projectionName: string;
-    partition: string;
-    version: number;
-    lockKey: string | bigint;
+  projectionName: string;
+  partition: string;
+  version: number;
+  lockKey: string | bigint;
 };
-
+//#endregion
+//#region src/eventStore/projections/locks/postgreSQLProjectionLock.d.ts
 type PostgreSQLProjectionLockOptions = {
-    projectionName: string;
-    partition: string;
-    version: number;
-    lockKey?: string | bigint;
+  projectionName: string;
+  partition: string;
+  version: number;
+  lockKey?: string | bigint;
 };
 type PostgreSQLProjectionLockContext = {
-    execute: SQLExecutor;
+  execute: SQLExecutor;
 };
 type PostgreSQLProjectionLock = {
-    tryAcquire: (options: PostgreSQLProjectionLockContext) => Promise<boolean>;
-    release: (options: PostgreSQLProjectionLockContext) => void;
+  tryAcquire: (options: PostgreSQLProjectionLockContext) => Promise<boolean>;
+  release: (options: PostgreSQLProjectionLockContext) => void;
 };
 declare const postgreSQLProjectionLock: (options: PostgreSQLProjectionLockOptions) => PostgreSQLProjectionLock;
-declare const toProjectionLockKey: ({ projectionName, partition, version, }: Pick<TryAcquireProjectionLockOptions, "projectionName" | "partition" | "version">) => string;
-
-declare const registerProjection: <ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, ProjectionHandlerContext extends DefaultRecord = DefaultRecord>(execute: SQLExecutor, options: {
-    partition: string;
-    status: "active" | "inactive";
-    registration: ProjectionRegistration<ProjectionHandlingType, ReadEventMetadataType, ProjectionHandlerContext>;
+declare const toProjectionLockKey: ({
+  projectionName,
+  partition,
+  version
+}: Pick<TryAcquireProjectionLockOptions, "projectionName" | "partition" | "version">) => string;
+//#endregion
+//#region src/eventStore/projections/management/projectionManagement.d.ts
+declare const registerProjection: <ReadEventMetadataType extends AnyReadEventMetadata = AnyReadEventMetadata, HandlerContext extends ProjectionHandlerContext = ProjectionHandlerContext>(execute: SQLExecutor, options: {
+  partition: string;
+  status: "active" | "inactive";
+  registration: ProjectionRegistration<ProjectionHandlingType, ReadEventMetadataType, HandlerContext>;
 }) => Promise<{
-    registered: boolean;
+  registered: boolean;
 }>;
 declare const activateProjection: (execute: SQLExecutor, options: {
-    name: string;
-    partition: string;
-    version: number;
+  name: string;
+  partition: string;
+  version: number;
 }) => Promise<{
-    activated: boolean;
+  activated: boolean;
 }>;
 declare const deactivateProjection: (execute: SQLExecutor, options: {
-    name: string;
-    partition: string;
-    version: number;
+  name: string;
+  partition: string;
+  version: number;
 }) => Promise<{
-    deactivated: boolean;
+  deactivated: boolean;
 }>;
 type ProjectionRegistrationWithMandatoryData = ProjectionRegistration<ProjectionHandlingType> & {
-    projection: Required<Pick<ProjectionDefinition, 'kind' | 'version' | 'name'>>;
+  projection: Required<Pick<ProjectionDefinition, 'kind' | 'version' | 'name'>>;
 };
 type ReadProjectionInfoResult = {
-    partition: string;
-    status: 'active' | 'inactive';
-    registration: ProjectionRegistrationWithMandatoryData;
-    createdAt: Date;
-    lastUpdated: Date;
-};
-declare const readProjectionInfo: (execute: SQLExecutor, { name, partition, version, }: {
-    name: string;
-    partition: string;
-    version: number;
+  partition: string;
+  status: 'active' | 'inactive';
+  registration: ProjectionRegistrationWithMandatoryData;
+  createdAt: Date;
+  lastUpdated: Date;
+};
+declare const readProjectionInfo: (execute: SQLExecutor, {
+  name,
+  partition,
+  version
+}: {
+  name: string;
+  partition: string;
+  version: number;
 }) => Promise<ReadProjectionInfoResult | null>;
-
+//#endregion
+//#region src/eventStore/projections/pongo/pongoProjections.d.ts
 type PongoProjectionHandlerContext = PostgreSQLProjectionHandlerContext & {
-    pongo: PongoClient;
+  pongo: PongoClient;
 };
 type PongoWithNotNullDocumentEvolve<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = ((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 PostgresReadEventMetadata = PostgresReadEventMetadata> = ((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 PostgresReadEventMetadata = PostgresReadEventMetadata> = 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, PostgresReadEventMetadata>[], context: PongoProjectionHandlerContext) => Promise<void>;
-    canHandle: CanHandle<EventType>;
-    truncate?: TruncateProjection<PongoProjectionHandlerContext>;
-    init?: (context: PongoProjectionHandlerContext) => void | Promise<void>;
-    eventsOptions?: {
-        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
-    };
-};
-declare const pongoProjection: <EventType extends Event, EventPayloadType extends Event = EventType>({ name, kind, version, truncate, handle, canHandle, eventsOptions, }: PongoProjectionOptions<EventType, EventPayloadType>) => PostgreSQLProjectionDefinition<EventType, EventPayloadType>;
+  name: string;
+  kind?: string;
+  version?: number;
+  handle: (events: ReadEvent<EventType, PostgresReadEventMetadata>[], 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>) => PostgreSQLProjectionDefinition<EventType, EventPayloadType>;
 type PongoMultiStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata, 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;
+  kind?: string;
+  canHandle: CanHandle<EventType>;
+  version?: number;
+  collectionName: string;
+  collectionOptions?: PongoDBCollectionOptions<Document, DocumentPayload>;
+  eventsOptions?: {
+    schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+  };
 } & ({
-    evolve: PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+  getDocumentId: (event: ReadEvent<EventType>) => string | null;
+  getDocumentIds?: never;
 } | {
-    evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
-    initialState: () => Document;
-});
+  getDocumentId?: never;
+  getDocumentIds: (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 PostgresReadEventMetadata = PostgresReadEventMetadata, EventPayloadType extends Event = EventType>(options: PongoMultiStreamProjectionOptions<Document, EventType, EventMetaDataType, EventPayloadType>) => PostgreSQLProjectionDefinition<EventType, EventPayloadType>;
 type PongoSingleStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata, 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>;
-    };
+  canHandle: CanHandle<EventType>;
+  version?: number;
+  collectionName: string;
+  collectionOptions?: PongoDBCollectionOptions<Document, DocumentPayload>;
+  eventsOptions?: {
+    schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+  };
 } & ({
-    evolve: PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+  getDocumentId: (event: ReadEvent<EventType>) => string | null;
+  getDocumentIds?: never;
 } | {
-    evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
-    initialState: () => Document;
-});
-declare const pongoSingleStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata, EventPayloadType extends Event = EventType>(options: PongoSingleStreamProjectionOptions<Document, EventType, EventMetaDataType, EventPayloadType>) => PostgreSQLProjectionDefinition<EventType, EventPayloadType>;
-
+  getDocumentId?: never;
+  getDocumentIds: (event: ReadEvent<EventType>) => string[];
+} | {
+  getDocumentId?: never;
+  getDocumentIds?: never;
+}) & ({
+  evolve: PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+} | {
+  evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
+  initialState: () => Document;
+}) & JSONSerializationOptions;
+declare const pongoSingleStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata, EventPayloadType extends Event = EventType>({
+  getDocumentId,
+  getDocumentIds,
+  ...options
+}: PongoSingleStreamProjectionOptions<Document, EventType, EventMetaDataType, EventPayloadType>) => PostgreSQLProjectionDefinition<EventType, EventPayloadType>;
+//#endregion
+//#region src/eventStore/projections/pongo/pongoProjectionSpec.d.ts
 type PongoAssertOptions = {
-    inCollection: string;
-    inDatabase?: string;
+  inCollection: string;
+  inDatabase?: string;
 };
 type FilterOrId<Doc extends PongoDocument | WithId<PongoDocument>> = {
-    withId: string;
+  withId: string;
 } | {
-    matchingFilter: PongoFilter<Doc>;
+  matchingFilter: PongoFilter<Doc>;
 };
 declare const documentExists: <Doc extends PongoDocument | WithId<PongoDocument>>(document: Doc, options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
 declare const documentsAreTheSame: <Doc extends PongoDocument | WithId<PongoDocument>>(documents: Doc[], options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
@@ -216,259 +268,259 @@ declare const documentsMatchingHaveCount: <Doc extends PongoDocument | WithId<Po
 declare const documentMatchingExists: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
 declare const documentDoesNotExist: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
 declare const expectPongoDocuments: {
-    fromCollection: <Doc extends PongoDocument | WithId<PongoDocument>>(collectionName: string) => {
-        withId: (id: string) => {
-            toBeEqual: (document: Doc) => PostgreSQLProjectionAssert;
-            toExist: () => PostgreSQLProjectionAssert;
-            notToExist: () => PostgreSQLProjectionAssert;
-        };
-        matching: <Doc_1 extends PongoDocument | WithId<PongoDocument>>(filter: PongoFilter<Doc_1>) => {
-            toBeTheSame: (documents: Doc_1[]) => PostgreSQLProjectionAssert;
-            toHaveCount: (expectedCount: number) => PostgreSQLProjectionAssert;
-            toExist: () => PostgreSQLProjectionAssert;
-            notToExist: () => PostgreSQLProjectionAssert;
-        };
+  fromCollection: <Doc extends PongoDocument | WithId<PongoDocument>>(collectionName: string) => {
+    withId: (id: string) => {
+      toBeEqual: (document: Doc) => PostgreSQLProjectionAssert;
+      toExist: () => PostgreSQLProjectionAssert;
+      notToExist: () => PostgreSQLProjectionAssert;
+    };
+    matching: <Doc_1 extends PongoDocument | WithId<PongoDocument>>(filter: PongoFilter<Doc_1>) => {
+      toBeTheSame: (documents: Doc_1[]) => PostgreSQLProjectionAssert;
+      toHaveCount: (expectedCount: number) => PostgreSQLProjectionAssert;
+      toExist: () => PostgreSQLProjectionAssert;
+      notToExist: () => PostgreSQLProjectionAssert;
     };
+  };
 };
-
+//#endregion
+//#region src/eventStore/projections/postgresProjectionSpec.d.ts
 type PostgreSQLProjectionSpecEvent<EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = EventType & {
-    metadata?: Partial<EventMetaDataType>;
+  metadata?: Partial<EventMetaDataType>;
 };
 type PostgreSQLProjectionSpecWhenOptions = {
-    numberOfTimes: number;
+  numberOfTimes: number;
+};
+type PostgreSQLProjectionSpec<EventType extends Event> = (givenEvents: PostgreSQLProjectionSpecEvent<EventType>[]) => {
+  when: (events: PostgreSQLProjectionSpecEvent<EventType>[], options?: PostgreSQLProjectionSpecWhenOptions) => {
+    then: (assert: PostgreSQLProjectionAssert, message?: string) => Promise<void>;
+    thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
+  };
 };
 type PostgreSQLProjectionAssert = (options: {
-    pool: Dumbo;
-    connectionString: string;
+  pool: Dumbo;
+  connectionString: string;
 }) => Promise<void | boolean>;
 type PostgreSQLProjectionSpecOptions<EventType extends Event> = {
-    projection: PostgreSQLProjectionDefinition<EventType>;
+  projection: PostgreSQLProjectionDefinition<EventType>;
 } & PgPoolOptions;
-type PostgreSQLProjectionSpec<EventType extends Event> = (givenEvents: PostgreSQLProjectionSpecEvent<EventType>[]) => {
-    when: (events: PostgreSQLProjectionSpecEvent<EventType>[], options?: PostgreSQLProjectionSpecWhenOptions) => {
-        then: (assert: PostgreSQLProjectionAssert, message?: string) => Promise<void>;
-        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
-    };
-};
 declare const PostgreSQLProjectionSpec: {
-    for: <EventType extends Event>(options: PostgreSQLProjectionSpecOptions<EventType>) => PostgreSQLProjectionSpec<EventType>;
+  for: <EventType extends Event>(options: PostgreSQLProjectionSpecOptions<EventType>) => PostgreSQLProjectionSpec<EventType>;
 };
 declare const eventInStream: <EventType extends Event = Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata>(streamName: string, event: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>;
 declare const eventsInStream: <EventType extends Event = Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata>(streamName: string, events: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[]) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[];
-declare const newEventsInStream: <EventType extends Event = Event, EventMetaDataType extends PostgresReadEventMetadata = _event_driven_io_emmett.RecordedMessageMetadataWithGlobalPosition>(streamName: string, events: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[]) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[];
+declare const newEventsInStream: <EventType extends Event = Event, EventMetaDataType extends PostgresReadEventMetadata = _$_event_driven_io_emmett0.RecordedMessageMetadataWithGlobalPosition>(streamName: string, events: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[]) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[];
 declare const assertSQLQueryResultMatches: <T extends QueryResultRow>(sql: SQL, rows: T[]) => PostgreSQLProjectionAssert;
 declare const expectSQL: {
-    query: (sql: SQL) => {
-        resultRows: {
-            toBeTheSame: <T extends QueryResultRow>(rows: T[]) => PostgreSQLProjectionAssert;
-        };
-    };
-};
-
-declare const emmettPrefix = "emt";
-declare const globalTag = "global";
-declare const defaultTag = "emt:default";
-declare const unknownTag = "emt:unknown";
-declare const globalNames: {
-    module: string;
-    tenant: 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;
-        };
+  query: (sql: SQL) => {
+    resultRows: {
+      toBeTheSame: <T extends QueryResultRow>(rows: T[]) => PostgreSQLProjectionAssert;
     };
+  };
+};
+//#endregion
+//#region src/eventStore/schema/readMessagesBatch.d.ts
+declare const PostgreSQLEventStoreCheckpoint: {
+  default: {
+    transactionId: bigint;
+    globalPosition: bigint;
+  };
+  parse: (checkPoint: ProcessorCheckpoint | undefined | null) => PostgreSQLEventStoreCheckpoint;
+  toProcessorCheckpoint: (checkPoint: PostgreSQLEventStoreCheckpoint) => ProcessorCheckpoint;
+};
+type PostgreSQLEventStoreCheckpoint = {
+  transactionId: bigint;
+  globalPosition: bigint;
 };
-declare const processorsTable: {
-    name: string;
+type ReadMessagesBatchOptions = {
+  after: PostgreSQLEventStoreCheckpoint;
+  batchSize: number;
+} | {
+  from: PostgreSQLEventStoreCheckpoint;
+  batchSize: number;
+} | {
+  to: PostgreSQLEventStoreCheckpoint;
+  batchSize: number;
+} | {
+  from: PostgreSQLEventStoreCheckpoint;
+  to: PostgreSQLEventStoreCheckpoint;
 };
-declare const projectionsTable: {
-    name: string;
+type ReadMessagesBatchResult<MessageType extends Message, MessageMetadataType extends RecordedMessageMetadata = RecordedMessageMetadata> = {
+  currentCheckpoint: PostgreSQLEventStoreCheckpoint;
+  messages: RecordedMessage<MessageType, MessageMetadataType>[];
+  areMessagesLeft: boolean;
 };
-
+declare const readMessagesBatch: <MessageType extends Message, RecordedMessageMetadataType extends RecordedMessageMetadataWithGlobalPosition = RecordedMessageMetadataWithGlobalPosition>(execute: SQLExecutor, options: ReadMessagesBatchOptions & {
+  partition?: string;
+}) => Promise<ReadMessagesBatchResult<MessageType, RecordedMessageMetadataType>>;
+//#endregion
+//#region src/eventStore/schema/appendToStream.d.ts
 declare const appendToStreamSQL: SQL;
 type CallAppendToStreamParams = {
-    messageIds: string[];
-    messagesData: DefaultRecord[];
-    messagesMetadata: DefaultRecord[];
-    schemaVersions: string[];
-    messageTypes: string[];
-    messageKinds: string[];
-    streamId: string;
-    streamType: string;
-    expectedStreamPosition: bigint | null;
-    partition: string;
+  messageIds: string[];
+  messagesData: DefaultRecord[];
+  messagesMetadata: DefaultRecord[];
+  schemaVersions: string[];
+  messageTypes: string[];
+  messageKinds: string[];
+  streamId: string;
+  streamType: string;
+  expectedStreamPosition: bigint | null;
+  partition: string;
 };
 declare const callAppendToStream: (params: CallAppendToStreamParams) => SQL;
 type AppendToStreamResult = {
-    success: true;
-    nextStreamPosition: bigint;
-    globalPositions: bigint[];
-    transactionId: string;
+  success: true;
+  nextStreamPosition: bigint;
+  checkpoints: PostgreSQLEventStoreCheckpoint[];
 } | {
-    success: false;
+  success: false;
 };
 type AppendToStreamBeforeCommitHook = (messages: RecordedMessage[], context: {
-    transaction: PgTransaction;
+  transaction: PgTransaction;
 }) => Promise<void>;
-declare const appendToStream: (pool: PgPool, streamName: string, streamType: string, messages: Message[], options?: AppendToStreamOptions & {
-    partition?: string;
-    beforeCommitHook?: AppendToStreamBeforeCommitHook;
+declare const appendToStream: (connection: PgConnection, streamName: string, streamType: string, messages: Message[], options?: AppendToStreamOptions & {
+  partition?: string;
+  messageIdGenerator?: () => string;
+  beforeCommitHook?: AppendToStreamBeforeCommitHook;
 }) => Promise<AppendToStreamResult>;
-
-declare const cleanupLegacySubscriptionTables: (connectionString: string) => Promise<void>;
-
+type AppendToStreamSqlResult = {
+  success: boolean;
+  next_stream_position: string | null;
+  global_positions: string[] | null;
+  transaction_id: string | null | undefined;
+};
+declare const appentToStreamRaw: (execute: SQLExecutor, streamId: string, streamType: string, messages: RecordedMessage[], options?: {
+  expectedStreamVersion: bigint | null;
+  partition?: string;
+}) => Promise<AppendToStreamSqlResult>;
+//#endregion
+//#region src/eventStore/schema/migrations/index.d.ts
+declare const currentPostgreSQLEventStoreSchemaVersion = "0.43.0";
+declare const pastEventStoreSchemaMigrations: SQLMigration[];
+declare const eventStoreSchemaMigrations: SQLMigration[];
+//#endregion
+//#region src/eventStore/schema/processors/processorsLocks.d.ts
 declare const tryAcquireProcessorLockSQL: SQL;
 declare const releaseProcessorLockSQL: SQL;
 type CallTryAcquireProcessorLockParams = {
-    lockKey: string;
-    processorId: string;
-    version: number;
-    partition: string;
-    processorInstanceId: string;
-    projectionName: string | null;
-    projectionType: 'i' | 'a' | null;
-    projectionKind: string | null;
-    lockTimeoutSeconds: number;
+  lockKey: string;
+  processorId: string;
+  version: number;
+  partition: string;
+  processorInstanceId: string;
+  projectionName: string | null;
+  projectionType: 'i' | 'a' | null;
+  projectionKind: string | null;
+  lockTimeoutSeconds: number;
 };
 declare const callTryAcquireProcessorLock: (params: CallTryAcquireProcessorLockParams) => SQL;
 type CallReleaseProcessorLockParams = {
-    lockKey: string;
-    processorId: string;
-    partition: string;
-    version: number;
-    processorInstanceId: string;
-    projectionName: string | null;
+  lockKey: string;
+  processorId: string;
+  partition: string;
+  version: number;
+  processorInstanceId: string;
+  projectionName: string | null;
 };
 declare const callReleaseProcessorLock: (params: CallReleaseProcessorLockParams) => SQL;
-
+//#endregion
+//#region src/eventStore/schema/projections/projectionsLocks.d.ts
 declare const tryAcquireProjectionLockSQL: SQL;
 type CallTryAcquireProjectionLockParams = {
-    lockKey: string;
-    partition: string;
-    name: string;
-    version: number;
+  lockKey: string;
+  partition: string;
+  name: string;
+  version: number;
 };
 declare const callTryAcquireProjectionLock: (params: CallTryAcquireProjectionLockParams) => SQL;
-
+//#endregion
+//#region src/eventStore/schema/projections/registerProjection.d.ts
 declare const registerProjectionSQL: SQL;
 declare const activateProjectionSQL: SQL;
 declare const deactivateProjectionSQL: SQL;
 type CallRegisterProjectionParams = {
-    lockKey: string;
-    name: string;
-    partition: string;
-    version: number;
-    type: 'i' | 'a';
-    kind: string;
-    status: string;
-    definition: string;
+  lockKey: string;
+  name: string;
+  partition: string;
+  version: number;
+  type: 'i' | 'a';
+  kind: string;
+  status: string;
+  definition: string;
 };
 declare const callRegisterProjection: (params: CallRegisterProjectionParams) => SQL;
 type CallActivateProjectionParams = {
-    lockKey: string;
-    name: string;
-    partition: string;
-    version: number;
+  lockKey: string;
+  name: string;
+  partition: string;
+  version: number;
 };
 declare const callActivateProjection: (params: CallActivateProjectionParams) => SQL;
 type CallDeactivateProjectionParams = {
-    lockKey: string;
-    name: string;
-    partition: string;
-    version: number;
+  lockKey: string;
+  name: string;
+  partition: string;
+  version: number;
 };
 declare const callDeactivateProjection: (params: CallDeactivateProjectionParams) => SQL;
-
-type ReadLastMessageGlobalPositionResult = {
-    currentGlobalPosition: bigint | null;
-};
-declare const readLastMessageGlobalPosition: (execute: SQLExecutor, options?: {
-    partition?: string;
-}) => Promise<ReadLastMessageGlobalPositionResult>;
-
-type ReadMessagesBatchOptions = {
-    after: bigint;
-    batchSize: number;
-} | {
-    from: bigint;
-    batchSize: number;
-} | {
-    to: bigint;
-    batchSize: number;
-} | {
-    from: bigint;
-    to: bigint;
-};
-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 & {
-    partition?: string;
-}) => Promise<ReadMessagesBatchResult<MessageType, RecordedMessageMetadataType>>;
-
+//#endregion
+//#region src/eventStore/schema/readLastMessageCheckpoint.d.ts
+type ReadLastMessageCheckpointResult = {
+  currentCheckpoint: PostgreSQLEventStoreCheckpoint | null;
+};
+declare const readLastMessageCheckpoint: (execute: SQLExecutor, options?: {
+  partition?: string;
+}) => Promise<ReadLastMessageCheckpointResult>;
+//#endregion
+//#region src/eventStore/schema/readProcessorCheckpoint.d.ts
 type ReadProcessorCheckpointResult = {
-    lastProcessedCheckpoint: ProcessorCheckpoint | null;
+  lastProcessedCheckpoint: ProcessorCheckpoint | null;
 };
 declare const readProcessorCheckpoint: (execute: SQLExecutor, options: {
-    processorId: string;
-    partition?: string;
-    version?: number;
+  processorId: string;
+  partition?: string;
+  version?: number;
 }) => 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;
+  partition?: string;
 }) => Promise<ReadStreamResult<EventType, ReadEventMetadataWithGlobalPosition>>;
-
+//#endregion
+//#region src/eventStore/schema/storeProcessorCheckpoint.d.ts
 declare const storeSubscriptionCheckpointSQL: SQL;
 type CallStoreProcessorCheckpointParams = {
-    processorId: string;
-    version: number;
-    position: string | null;
-    checkPosition: string | null;
-    partition: string;
-    processorInstanceId: string;
+  processorId: string;
+  version: number;
+  position: string | null;
+  checkPosition: string | null;
+  partition: string;
+  processorInstanceId: string;
 };
 declare const callStoreProcessorCheckpoint: (params: CallStoreProcessorCheckpointParams) => SQL;
 type StoreProcessorCheckpointResult = {
-    success: true;
-    newCheckpoint: ProcessorCheckpoint | null;
+  success: true;
+  newCheckpoint: ProcessorCheckpoint | null;
 } | {
-    success: false;
-    reason: 'IGNORED' | 'MISMATCH' | 'CURRENT_AHEAD';
+  success: false;
+  reason: 'IGNORED' | 'MISMATCH' | 'CURRENT_AHEAD';
 };
 declare const storeProcessorCheckpoint: (execute: SQLExecutor, options: {
-    processorId: string;
-    version: number | undefined;
-    newCheckpoint: ProcessorCheckpoint | null;
-    lastProcessedCheckpoint: ProcessorCheckpoint | null;
-    partition?: string;
-    processorInstanceId?: string;
+  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 PostgresStreamExistsOptions = {
-    partition: string;
+  partition: string;
 };
 declare const streamExists: (execute: SQLExecutor, streamId: string, options?: PostgresStreamExistsOptions) => Promise<StreamExistsResult>;
-
+//#endregion
+//#region src/eventStore/schema/tables.d.ts
 declare const streamsTableSQL: SQL;
 declare const messagesTableSQL: SQL;
 declare const processorsTableSQL: SQL;
@@ -481,225 +533,229 @@ declare const addTenantSQL: SQL;
 declare const addModuleForAllTenantsSQL: SQL;
 declare const addTenantForAllModulesSQL: SQL;
 declare const addDefaultPartitionSQL: SQL;
-
+//#endregion
+//#region src/eventStore/schema/index.d.ts
 declare const schemaSQL: SQL[];
-declare const schemaMigration: SQLMigration;
-declare const eventStoreSchemaMigrations: SQLMigration[];
+declare const schemaMigration: _$_event_driven_io_dumbo0.SQLMigration;
 type CreateEventStoreSchemaOptions = {
-    dryRun?: boolean | undefined;
-    ignoreMigrationHashMismatch?: boolean | undefined;
-    migrationTimeoutMs?: number | undefined;
-};
+  dryRun?: boolean | undefined;
+  ignoreMigrationHashMismatch?: boolean | undefined;
+  migrationTimeoutMs?: number | undefined;
+} & JSONSerializationOptions;
 type EventStoreSchemaMigrationOptions = {
-    migrationOptions?: CreateEventStoreSchemaOptions;
+  migrationOptions?: CreateEventStoreSchemaOptions;
 };
 declare const createEventStoreSchema: (connectionString: string, pool: PgPool, hooks?: PostgresEventStoreOptions["hooks"], options?: CreateEventStoreSchemaOptions) => Promise<RunSQLMigrationsResult>;
-
-type PostgreSQLProjectionHandlerContext = {
-    execute: SQLExecutor;
-    connection: {
-        connectionString: string;
-        client: PgClient;
-        transaction: PgTransaction;
-        pool: Dumbo;
-    };
-} & EventStoreSchemaMigrationOptions;
+//#endregion
+//#region src/eventStore/projections/postgreSQLProjection.d.ts
+type PostgreSQLProjectionHandlerContext = ProjectionHandlerContext<{
+  execute: SQLExecutor;
+  connection: {
+    connectionString: string;
+    client: PgClient;
+    transaction: PgTransaction;
+    pool: Dumbo;
+  };
+} & EventStoreSchemaMigrationOptions>;
 declare const transactionToPostgreSQLProjectionHandlerContext: (connectionString: string, pool: Dumbo, transaction: PgTransaction | DatabaseTransaction<AnyConnection>) => Promise<PostgreSQLProjectionHandlerContext>;
 type PostgreSQLProjectionHandler<EventType extends Event = Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, PostgreSQLProjectionHandlerContext>;
 type PostgreSQLProjectionDefinition<EventType extends Event = Event, EventPayloadType extends Event = EventType> = ProjectionDefinition<EventType, PostgresReadEventMetadata, PostgreSQLProjectionHandlerContext, EventPayloadType>;
 type PostgreSQLProjectionHandlerOptions<EventType extends Event = Event> = {
-    events: ReadEvent<EventType, PostgresReadEventMetadata>[];
-    projections: PostgreSQLProjectionDefinition<EventType>[];
-    partition?: string;
+  events: ReadEvent<EventType, PostgresReadEventMetadata>[];
+  projections: PostgreSQLProjectionDefinition<EventType>[];
+  partition?: string;
 } & PostgreSQLProjectionHandlerContext;
 declare const handleProjections: <EventType extends Event = Event>(options: PostgreSQLProjectionHandlerOptions<EventType>) => Promise<void>;
 declare const postgreSQLProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(definition: PostgreSQLProjectionDefinition<EventType, EventPayloadType>) => PostgreSQLProjectionDefinition<EventType, EventPayloadType>;
 type PostgreSQLRawBatchSQLProjection<EventType extends Event, EventPayloadType extends Event = EventType> = {
-    name: string;
-    kind?: string;
-    version?: number;
-    evolve: (events: EventType[], context: PostgreSQLProjectionHandlerContext) => Promise<SQL[]> | SQL[];
-    canHandle: CanHandle<EventType>;
-    init?: (context: ProjectionInitOptions<PostgreSQLProjectionHandlerContext>) => void | Promise<void> | SQL | Promise<SQL> | Promise<SQL[]> | SQL[];
-    eventsOptions?: {
-        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
-    };
-};
+  name: string;
+  kind?: string;
+  version?: number;
+  evolve: (events: EventType[], context: PostgreSQLProjectionHandlerContext) => Promise<SQL[]> | SQL[];
+  canHandle: CanHandle<EventType>;
+  init?: (context: ProjectionInitOptions<PostgreSQLProjectionHandlerContext>) => void | Promise<void> | SQL | Promise<SQL> | Promise<SQL[]> | SQL[];
+  eventsOptions?: {
+    schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+  };
+} & JSONSerializationOptions;
 declare const postgreSQLRawBatchSQLProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(options: PostgreSQLRawBatchSQLProjection<EventType, EventPayloadType>) => PostgreSQLProjectionDefinition<EventType, EventPayloadType>;
 type PostgreSQLRawSQLProjection<EventType extends Event, EventPayloadType extends Event = EventType> = {
-    name: string;
-    kind?: string;
-    version?: number;
-    evolve: (events: EventType, context: PostgreSQLProjectionHandlerContext) => Promise<SQL[]> | SQL[] | Promise<SQL> | SQL;
-    canHandle: CanHandle<EventType>;
-    init?: (context: ProjectionInitOptions<PostgreSQLProjectionHandlerContext>) => void | Promise<void> | SQL | Promise<SQL> | Promise<SQL[]> | SQL[];
-    eventsOptions?: {
-        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
-    };
-};
+  name: string;
+  kind?: string;
+  version?: number;
+  evolve: (events: EventType, context: PostgreSQLProjectionHandlerContext) => Promise<SQL[]> | SQL[] | Promise<SQL> | SQL;
+  canHandle: CanHandle<EventType>;
+  init?: (context: ProjectionInitOptions<PostgreSQLProjectionHandlerContext>) => void | Promise<void> | SQL | Promise<SQL> | Promise<SQL[]> | SQL[];
+  eventsOptions?: {
+    schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+  };
+} & JSONSerializationOptions;
 declare const postgreSQLRawSQLProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(options: PostgreSQLRawSQLProjection<EventType, EventPayloadType>) => PostgreSQLProjectionDefinition<EventType, EventPayloadType>;
-
+//#endregion
+//#region src/eventStore/postgreSQLEventStore.d.ts
 interface PostgresEventStore extends EventStore<PostgresReadEventMetadata>, EventStoreSessionFactory<PostgresEventStore> {
-    appendToStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, events: EventType[], options?: AppendToStreamOptions<EventType, EventPayloadType>): Promise<AppendToStreamResultWithGlobalPosition>;
-    consumer<ConsumerEventType extends Event = Event>(options?: PostgreSQLEventStoreConsumerConfig<ConsumerEventType>): PostgreSQLEventStoreConsumer<ConsumerEventType>;
-    close(): Promise<void>;
-    streamExists(streamName: string, options?: PostgresStreamExistsOptions): Promise<StreamExistsResult>;
-    schema: {
-        sql(): string;
-        print(): void;
-        migrate(options?: CreateEventStoreSchemaOptions): Promise<RunSQLMigrationsResult>;
-        dangerous: {
-            truncate(options?: {
-                resetSequences?: boolean;
-                truncateProjections?: boolean;
-            }): Promise<void>;
-        };
+  appendToStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, events: EventType[], options?: AppendToStreamOptions<EventType, EventPayloadType>): Promise<AppendToStreamResultWithGlobalPosition>;
+  consumer<ConsumerEventType extends Event = Event>(options?: PostgreSQLEventStoreConsumerConfig<ConsumerEventType>): PostgreSQLEventStoreConsumer<ConsumerEventType>;
+  close(): Promise<void>;
+  streamExists(streamName: string, options?: PostgresStreamExistsOptions): Promise<StreamExistsResult>;
+  schema: {
+    sql(): string;
+    print(): void;
+    migrate(options?: CreateEventStoreSchemaOptions): Promise<RunSQLMigrationsResult>;
+    dangerous: {
+      truncate(options?: {
+        resetSequences?: boolean;
+        truncateProjections?: boolean;
+      }): Promise<void>;
     };
+  };
 }
 type PostgresReadEventMetadata = ReadEventMetadataWithGlobalPosition;
 type PostgresReadEvent<EventType extends Event = Event> = ReadEvent<EventType, PostgresReadEventMetadata>;
 type PostgresEventStorePooledOptions = {
-    connector?: PgDriverType;
-    connectionString?: string;
-    database?: string;
-    pooled: true;
-    pool: pg.Pool;
+  connector?: PgDriverType;
+  connectionString?: string;
+  database?: string;
+  pooled: true;
+  pool: pg.Pool;
 } | {
-    connector?: PgDriverType;
-    connectionString?: string;
-    database?: string;
-    pool: pg.Pool;
+  connector?: PgDriverType;
+  connectionString?: string;
+  database?: string;
+  pool: pg.Pool;
 } | {
-    connector?: PgDriverType;
-    connectionString?: string;
-    database?: string;
-    pooled: true;
+  connector?: PgDriverType;
+  connectionString?: string;
+  database?: string;
+  pooled: true;
 } | {
-    connector?: PgDriverType;
-    connectionString?: string;
-    database?: string;
+  connector?: PgDriverType;
+  connectionString?: string;
+  database?: string;
 };
 type PostgresEventStoreNotPooledOptions = {
-    connector?: PgDriverType;
-    connectionString?: string;
-    database?: string;
-    pooled: false;
-    client: pg.Client;
+  connector?: PgDriverType;
+  connectionString?: string;
+  database?: string;
+  pooled: false;
+  client: pg.Client;
 } | {
-    connector?: PgDriverType;
-    connectionString?: string;
-    database?: string;
-    client: pg.Client;
+  connector?: PgDriverType;
+  connectionString?: string;
+  database?: string;
+  client: pg.Client;
 } | {
-    connector?: PgDriverType;
-    connectionString?: string;
-    database?: string;
-    pooled: false;
+  connector?: PgDriverType;
+  connectionString?: string;
+  database?: string;
+  pooled: false;
 } | {
-    connector?: PgDriverType;
-    connectionString?: string;
-    database?: string;
-    connection: PgPoolClientConnection | PgClientConnection;
-    pooled?: false;
+  connector?: PgDriverType;
+  connectionString?: string;
+  database?: string;
+  connection: PgPoolClientConnection | PgClientConnection;
+  pooled?: false;
 } | {
-    connector?: PgDriverType;
-    connectionString?: string;
-    database?: string;
-    dumbo: PgPool;
-    pooled?: false;
+  connector?: PgDriverType;
+  connectionString?: string;
+  database?: string;
+  dumbo: PgPool;
+  pooled?: false;
 };
 type PostgresEventStoreConnectionOptions = PostgresEventStorePooledOptions | PostgresEventStoreNotPooledOptions;
 type PostgresEventStoreOptions = {
-    projections?: ProjectionRegistration<'inline', PostgresReadEventMetadata, PostgreSQLProjectionHandlerContext>[];
-    schema?: {
-        autoMigration?: MigrationStyle;
-    };
-    connectionOptions?: PostgresEventStoreConnectionOptions;
-    hooks?: {
-        /**
-         * This hook will be called **BEFORE** event store schema is created
-         */
-        onBeforeSchemaCreated?: (context: PostgreSQLProjectionHandlerContext) => Promise<void> | void;
-        /**
-         * This hook will be called **AFTER** event store schema was created but before transaction commits
-         */
-        onAfterSchemaCreated?: (context: PostgreSQLProjectionHandlerContext) => Promise<void> | void;
-    };
-};
+  projections?: ProjectionRegistration<'inline', PostgresReadEventMetadata, PostgreSQLProjectionHandlerContext>[];
+  observability?: EmmettObservabilityConfig;
+  schema?: {
+    autoMigration?: MigrationStyle;
+  };
+  connectionOptions?: PostgresEventStoreConnectionOptions;
+  hooks?: {
+    /**
+     * This hook will be called **BEFORE** event store schema is created
+     */
+    onBeforeSchemaCreated?: (context: PostgreSQLProjectionHandlerContext) => Promise<void> | void;
+    /**
+     * This hook will be called **AFTER** event store schema was created but before transaction commits
+     */
+    onAfterSchemaCreated?: (context: PostgreSQLProjectionHandlerContext) => Promise<void> | void;
+  };
+} & JSONSerializationOptions;
 declare const defaultPostgreSQLOptions: PostgresEventStoreOptions;
 declare const PostgreSQLEventStoreDefaultStreamVersion = 0n;
 declare const getPostgreSQLEventStore: (connectionString: string, options?: PostgresEventStoreOptions) => PostgresEventStore;
-
-type PostgreSQLProcessorHandlerContext = {
-    partition: string;
-    execute: SQLExecutor;
-    connection: {
-        connectionString: string;
-        client: PgClient;
-        transaction: PgTransaction;
-        pool: Dumbo;
-        messageStore: PostgresEventStore;
-    };
-} & EventStoreSchemaMigrationOptions;
+//#endregion
+//#region src/eventStore/consumers/postgreSQLProcessor.d.ts
+type PostgreSQLProcessorHandlerContext = MessageHandlerContext<{
+  partition: string;
+  execute: SQLExecutor;
+  connection: {
+    connectionString: string;
+    client: PgClient;
+    transaction: PgTransaction;
+    pool: Dumbo;
+    messageStore: PostgresEventStore;
+  };
+} & EventStoreSchemaMigrationOptions>;
 type PostgreSQLProcessor<MessageType extends Message = AnyMessage> = MessageProcessor<MessageType, ReadEventMetadataWithGlobalPosition, PostgreSQLProcessorHandlerContext>;
 type PostgreSQLProcessorEachMessageHandler<MessageType extends Message = Message> = SingleRecordedMessageHandlerWithContext<MessageType, ReadEventMetadataWithGlobalPosition, PostgreSQLProcessorHandlerContext>;
 type PostgreSQLProcessorEachBatchHandler<MessageType extends Message = Message> = BatchRecordedMessageHandlerWithContext<MessageType, ReadEventMetadataWithGlobalPosition, PostgreSQLProcessorHandlerContext>;
 type PostgreSQLProcessorStartFrom = PostgreSQLEventStoreMessageBatchPullerStartFrom | 'CURRENT';
 type PostgreSQLProcessorPooledOptions = {
-    connector?: PgDriverType;
-    database?: string;
-    pooled: true;
-    pool: pg.Pool;
+  connector?: PgDriverType;
+  database?: string;
+  pooled: true;
+  pool: pg.Pool;
 } | {
-    connector?: PgDriverType;
-    database?: string;
-    pool: pg.Pool;
+  connector?: PgDriverType;
+  database?: string;
+  pool: pg.Pool;
 } | {
-    connector?: PgDriverType;
-    database?: string;
-    pooled: true;
+  connector?: PgDriverType;
+  database?: string;
+  pooled: true;
 } | {
-    connector?: PgDriverType;
-    database?: string;
+  connector?: PgDriverType;
+  database?: string;
 };
 type PostgreSQLProcessorNotPooledOptions = {
-    connector?: PgDriverType;
-    database?: string;
-    pooled: false;
-    client: pg.Client;
+  connector?: PgDriverType;
+  database?: string;
+  pooled: false;
+  client: pg.Client;
 } | {
-    connector?: PgDriverType;
-    database?: string;
-    client: pg.Client;
+  connector?: PgDriverType;
+  database?: string;
+  client: pg.Client;
 } | {
-    connector?: PgDriverType;
-    database?: string;
-    pooled: false;
+  connector?: PgDriverType;
+  database?: string;
+  pooled: false;
 } | {
-    connector?: PgDriverType;
-    database?: string;
-    connection: PgPoolClientConnection | PgClientConnection;
-    pooled?: false;
+  connector?: PgDriverType;
+  database?: string;
+  connection: PgPoolClientConnection | PgClientConnection;
+  pooled?: false;
 } | {
-    connector?: PgDriverType;
-    database?: string;
-    dumbo: PgPool;
-    pooled?: false;
+  connector?: PgDriverType;
+  database?: string;
+  dumbo: PgPool;
+  pooled?: false;
 };
 type PostgreSQLProcessorConnectionOptions = {
-    connectionString: string;
+  connectionString: string;
 } & (PostgreSQLProcessorPooledOptions | PostgreSQLProcessorNotPooledOptions);
 type PostgreSQLCheckpointer<MessageType extends AnyMessage = AnyMessage> = Checkpointer<MessageType, ReadEventMetadataWithGlobalPosition, PostgreSQLProcessorHandlerContext>;
 declare const postgreSQLCheckpointer: <MessageType extends Message = Message>() => PostgreSQLCheckpointer<MessageType>;
 type PostgreSQLConnectionOptions = {
-    connectionOptions?: PostgreSQLProcessorConnectionOptions;
-};
+  connectionOptions?: PostgreSQLProcessorConnectionOptions;
+} & JSONSerializationOptions;
 type PostgreSQLProcessorOptionsBase = PostgreSQLConnectionOptions & {
-    lock?: {
-        acquisitionPolicy?: LockAcquisitionPolicy;
-        timeoutSeconds?: number;
-    };
-    partition?: string;
+  lock?: {
+    acquisitionPolicy?: LockAcquisitionPolicy;
+    timeoutSeconds?: number;
+  };
+  partition?: string;
 };
 type PostgreSQLReactorOptions<MessageType extends Message = Message, MessagePayloadType extends AnyMessage = MessageType> = ReactorOptions<MessageType, ReadEventMetadataWithGlobalPosition, PostgreSQLProcessorHandlerContext, MessagePayloadType> & PostgreSQLProcessorOptionsBase;
 type PostgreSQLProjectorOptions<EventType extends AnyEvent = AnyEvent, EventPayloadType extends Event = EventType> = ProjectorOptions<EventType, ReadEventMetadataWithGlobalPosition, PostgreSQLProcessorHandlerContext, EventPayloadType> & PostgreSQLProcessorOptionsBase & EventStoreSchemaMigrationOptions;
@@ -707,35 +763,38 @@ type PostgreSQLWorkflowProcessorOptions<Input extends AnyEvent | AnyCommand, Sta
 declare const postgreSQLProjector: <EventType extends Event = Event, EventPayloadType extends Event = EventType>(options: PostgreSQLProjectorOptions<EventType, EventPayloadType>) => PostgreSQLProcessor<EventType>;
 declare const postgreSQLWorkflowProcessor: <Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends PostgreSQLProcessorHandlerContext & WorkflowProcessorContext = PostgreSQLProcessorHandlerContext & WorkflowProcessorContext, StoredMessage extends AnyEvent | AnyCommand = Output>(options: PostgreSQLWorkflowProcessorOptions<Input, State, Output, MetaDataType, HandlerContext, StoredMessage>) => PostgreSQLProcessor<Input | Output>;
 declare const postgreSQLReactor: <MessageType extends Message = Message, MessagePayloadType extends AnyMessage = MessageType>(options: PostgreSQLReactorOptions<MessageType, MessagePayloadType>) => PostgreSQLProcessor<MessageType>;
-
+//#endregion
+//#region src/eventStore/consumers/postgreSQLEventStoreConsumer.d.ts
 type PostgreSQLEventStoreConsumerConfig<ConsumerMessageType extends Message = any> = MessageConsumerOptions<ConsumerMessageType> & {
-    stopWhen?: {
-        noMessagesLeft?: boolean;
-    };
-    pulling?: {
-        batchSize?: number;
-        pullingFrequencyInMs?: number;
-    };
-};
+  stopWhen?: {
+    noMessagesLeft?: boolean;
+  };
+  pulling?: {
+    batchSize?: number;
+    pullingFrequencyInMs?: number;
+  };
+} & JSONSerializationOptions;
 type PostgreSQLEventStoreConsumerOptions<ConsumerMessageType extends Message = Message> = PostgreSQLEventStoreConsumerConfig<ConsumerMessageType> & {
-    connectionString: string;
-    pool?: Dumbo;
+  connectionString: string;
+  pool?: Dumbo;
 };
 type PostgreSQLEventStoreConsumer<ConsumerMessageType extends AnyMessage = any> = MessageConsumer<ConsumerMessageType> & Readonly<{
-    reactor: <MessageType extends AnyMessage = ConsumerMessageType>(options: PostgreSQLReactorOptions<MessageType>) => PostgreSQLProcessor<MessageType>;
-    workflowProcessor: <Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends PostgreSQLProcessorHandlerContext & WorkflowProcessorContext = PostgreSQLProcessorHandlerContext & WorkflowProcessorContext, StoredMessage extends AnyEvent | AnyCommand = Output>(options: PostgreSQLWorkflowProcessorOptions<Input, State, Output, MetaDataType, HandlerContext, StoredMessage>) => PostgreSQLProcessor<Input | Output>;
+  reactor: <MessageType extends AnyMessage = ConsumerMessageType>(options: PostgreSQLReactorOptions<MessageType>) => PostgreSQLProcessor<MessageType>;
+  workflowProcessor: <Input extends AnyEvent | AnyCommand, State, Output extends AnyEvent | AnyCommand, MetaDataType extends AnyRecordedMessageMetadata = AnyRecordedMessageMetadata, HandlerContext extends PostgreSQLProcessorHandlerContext & WorkflowProcessorContext = PostgreSQLProcessorHandlerContext & WorkflowProcessorContext, StoredMessage extends AnyEvent | AnyCommand = Output>(options: PostgreSQLWorkflowProcessorOptions<Input, State, Output, MetaDataType, HandlerContext, StoredMessage>) => PostgreSQLProcessor<Input | Output>;
 }> & (AnyEvent extends ConsumerMessageType ? Readonly<{
-    projector: <EventType extends AnyEvent = ConsumerMessageType & AnyEvent>(options: PostgreSQLProjectorOptions<EventType>) => PostgreSQLProcessor<EventType>;
+  projector: <EventType extends AnyEvent = ConsumerMessageType & AnyEvent>(options: PostgreSQLProjectorOptions<EventType>) => PostgreSQLProcessor<EventType>;
 }> : object);
 declare const postgreSQLEventStoreConsumer: <ConsumerMessageType extends Message = AnyMessage>(options: PostgreSQLEventStoreConsumerOptions<ConsumerMessageType>) => PostgreSQLEventStoreConsumer<ConsumerMessageType>;
-
+//#endregion
+//#region src/eventStore/consumers/rebuildPostgreSQLProjections.d.ts
 declare const rebuildPostgreSQLProjections: <EventType extends AnyEvent = AnyEvent>(options: Omit<PostgreSQLEventStoreConsumerOptions<EventType>, "stopWhen" | "processors"> & {
-    lock?: {
-        acquisitionPolicy?: LockAcquisitionPolicy;
-        timeoutSeconds?: number;
-    };
+  lock?: {
+    acquisitionPolicy?: LockAcquisitionPolicy;
+    timeoutSeconds?: number;
+  };
 } & ({
-    projections: (ProjectorOptions<EventType, ReadEventMetadataWithGlobalPosition, PostgreSQLProcessorHandlerContext> | PostgreSQLProjectionDefinition<EventType>)[];
+  projections: (ProjectorOptions<EventType, ReadEventMetadataWithGlobalPosition, PostgreSQLProcessorHandlerContext> | PostgreSQLProjectionDefinition<EventType>)[];
 } | ProjectorOptions<EventType, ReadEventMetadataWithGlobalPosition, PostgreSQLProcessorHandlerContext>)) => PostgreSQLEventStoreConsumer<EventType>;
-
-export { type AppendToStreamBeforeCommitHook, type CreateEventStoreSchemaOptions, DefaultPostgreSQLEventStoreProcessorBatchSize, DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs, DefaultPostgreSQLProcessorLockPolicy, type EventStoreSchemaMigrationOptions, type LockAcquisitionPolicy, type PongoAssertOptions, type PongoDocumentEvolve, type PongoMultiStreamProjectionOptions, type PongoProjectionHandlerContext, type PongoProjectionOptions, type PongoSingleStreamProjectionOptions, type PongoWithNotNullDocumentEvolve, type PongoWithNullableDocumentEvolve, type PostgreSQLCheckpointer, type PostgreSQLEventStoreConsumer, type PostgreSQLEventStoreConsumerConfig, type PostgreSQLEventStoreConsumerOptions, PostgreSQLEventStoreDefaultStreamVersion, type PostgreSQLEventStoreMessageBatchPuller, type PostgreSQLEventStoreMessageBatchPullerOptions, type PostgreSQLEventStoreMessageBatchPullerStartFrom, type PostgreSQLEventStoreMessageBatchPullerStartOptions, type PostgreSQLEventStoreMessagesBatchHandlerResult, type PostgreSQLProcessor, type PostgreSQLProcessorConnectionOptions, type PostgreSQLProcessorEachBatchHandler, type PostgreSQLProcessorEachMessageHandler, type PostgreSQLProcessorHandlerContext, type PostgreSQLProcessorLock, type PostgreSQLProcessorLockContext, type PostgreSQLProcessorLockOptions, type PostgreSQLProcessorStartFrom, type PostgreSQLProjectionAssert, type PostgreSQLProjectionDefinition, type PostgreSQLProjectionHandler, type PostgreSQLProjectionHandlerContext, type PostgreSQLProjectionHandlerOptions, type PostgreSQLProjectionLock, type PostgreSQLProjectionLockContext, type PostgreSQLProjectionLockOptions, PostgreSQLProjectionSpec, type PostgreSQLProjectionSpecEvent, type PostgreSQLProjectionSpecOptions, type PostgreSQLProjectionSpecWhenOptions, type PostgreSQLProjectorOptions, type PostgreSQLRawBatchSQLProjection, type PostgreSQLRawSQLProjection, type PostgreSQLReactorOptions, type PostgreSQLWorkflowProcessorOptions, type PostgresEventStore, type PostgresEventStoreConnectionOptions, type PostgresEventStoreOptions, type PostgresReadEvent, type PostgresReadEventMetadata, type PostgresStreamExistsOptions, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, type ReadProjectionInfoResult, type StoreProcessorCheckpointResult, activateProjection, activateProjectionSQL, addDefaultPartitionSQL, addModuleForAllTenantsSQL, addModuleSQL, addPartitionSQL, addTablePartitions, addTenantForAllModulesSQL, addTenantSQL, appendToStream, appendToStreamSQL, assertSQLQueryResultMatches, callActivateProjection, callAppendToStream, callDeactivateProjection, callRegisterProjection, callReleaseProcessorLock, callStoreProcessorCheckpoint, callTryAcquireProcessorLock, callTryAcquireProjectionLock, cleanupLegacySubscriptionTables, createEventStoreSchema, deactivateProjection, deactivateProjectionSQL, defaultPostgreSQLOptions, defaultTag, documentDoesNotExist, documentExists, documentMatchingExists, documentsAreTheSame, documentsMatchingHaveCount, emmettPrefix, eventInStream, eventStoreSchemaMigrations, eventsInStream, expectPongoDocuments, expectSQL, getPostgreSQLEventStore, globalNames, globalTag, handleProjections, messagesTable, messagesTableSQL, newEventsInStream, pongoMultiStreamProjection, pongoProjection, pongoSingleStreamProjection, postgreSQLCheckpointer, postgreSQLEventStoreConsumer, postgreSQLEventStoreMessageBatchPuller, postgreSQLProcessorLock, postgreSQLProjection, postgreSQLProjectionLock, postgreSQLProjector, postgreSQLRawBatchSQLProjection, postgreSQLRawSQLProjection, postgreSQLReactor, postgreSQLWorkflowProcessor, processorsTable, processorsTableSQL, projectionsTable, projectionsTableSQL, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readProjectionInfo, readStream, rebuildPostgreSQLProjections, registerProjection, registerProjectionSQL, releaseProcessorLockSQL, sanitizeNameSQL, schemaMigration, schemaSQL, storeProcessorCheckpoint, storeSubscriptionCheckpointSQL, streamExists, streamsTable, streamsTableSQL, toProcessorLockKey, toProjectionLockKey, transactionToPostgreSQLProjectionHandlerContext, tryAcquireProcessorLockSQL, tryAcquireProjectionLockSQL, unknownTag, zipPostgreSQLEventStoreMessageBatchPullerStartFrom };
+//#endregion
+export { AppendToStreamBeforeCommitHook, CreateEventStoreSchemaOptions, DefaultPostgreSQLEventStoreProcessorBatchSize, DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs, DefaultPostgreSQLProcessorLockPolicy, EventStoreSchemaMigrationOptions, type LockAcquisitionPolicy, PongoAssertOptions, PongoDocumentEvolve, PongoMultiStreamProjectionOptions, PongoProjectionHandlerContext, PongoProjectionOptions, PongoSingleStreamProjectionOptions, PongoWithNotNullDocumentEvolve, PongoWithNullableDocumentEvolve, PostgreSQLCheckpointer, PostgreSQLEventStoreCheckpoint, PostgreSQLEventStoreConsumer, PostgreSQLEventStoreConsumerConfig, PostgreSQLEventStoreConsumerOptions, PostgreSQLEventStoreDefaultStreamVersion, PostgreSQLEventStoreMessageBatchPuller, PostgreSQLEventStoreMessageBatchPullerOptions, PostgreSQLEventStoreMessageBatchPullerStartFrom, PostgreSQLEventStoreMessageBatchPullerStartOptions, PostgreSQLEventStoreMessagesBatchHandlerResult, PostgreSQLProcessor, PostgreSQLProcessorConnectionOptions, PostgreSQLProcessorEachBatchHandler, PostgreSQLProcessorEachMessageHandler, PostgreSQLProcessorHandlerContext, PostgreSQLProcessorLock, PostgreSQLProcessorLockContext, PostgreSQLProcessorLockOptions, PostgreSQLProcessorStartFrom, PostgreSQLProjectionAssert, PostgreSQLProjectionDefinition, PostgreSQLProjectionHandler, PostgreSQLProjectionHandlerContext, PostgreSQLProjectionHandlerOptions, PostgreSQLProjectionLock, PostgreSQLProjectionLockContext, PostgreSQLProjectionLockOptions, PostgreSQLProjectionSpec, PostgreSQLProjectionSpecEvent, PostgreSQLProjectionSpecOptions, PostgreSQLProjectionSpecWhenOptions, PostgreSQLProjectorOptions, PostgreSQLRawBatchSQLProjection, PostgreSQLRawSQLProjection, PostgreSQLReactorOptions, PostgreSQLWorkflowProcessorOptions, PostgresEventStore, PostgresEventStoreConnectionOptions, PostgresEventStoreOptions, PostgresReadEvent, PostgresReadEventMetadata, PostgresStreamExistsOptions, ReadLastMessageCheckpointResult, ReadMessagesBatchOptions, ReadMessagesBatchResult, ReadProcessorCheckpointResult, ReadProjectionInfoResult, StoreProcessorCheckpointResult, activateProjection, activateProjectionSQL, addDefaultPartitionSQL, addModuleForAllTenantsSQL, addModuleSQL, addPartitionSQL, addTablePartitions, addTenantForAllModulesSQL, addTenantSQL, appendToStream, appendToStreamSQL, appentToStreamRaw, assertSQLQueryResultMatches, callActivateProjection, callAppendToStream, callDeactivateProjection, callRegisterProjection, callReleaseProcessorLock, callStoreProcessorCheckpoint, callTryAcquireProcessorLock, callTryAcquireProjectionLock, createEventStoreSchema, currentPostgreSQLEventStoreSchemaVersion, deactivateProjection, deactivateProjectionSQL, defaultPostgreSQLOptions, documentDoesNotExist, documentExists, documentMatchingExists, documentsAreTheSame, documentsMatchingHaveCount, eventInStream, eventStoreSchemaMigrations, eventsInStream, expectPongoDocuments, expectSQL, getPostgreSQLEventStore, handleProjections, messagesTableSQL, newEventsInStream, pastEventStoreSchemaMigrations, pongoMultiStreamProjection, pongoProjection, pongoSingleStreamProjection, postgreSQLCheckpointer, postgreSQLEventStoreConsumer, postgreSQLEventStoreMessageBatchPuller, postgreSQLProcessorLock, postgreSQLProjection, postgreSQLProjectionLock, postgreSQLProjector, postgreSQLRawBatchSQLProjection, postgreSQLRawSQLProjection, postgreSQLReactor, postgreSQLWorkflowProcessor, processorsTableSQL, projectionsTableSQL, readLastMessageCheckpoint, readMessagesBatch, readProcessorCheckpoint, readProjectionInfo, readStream, rebuildPostgreSQLProjections, registerProjection, registerProjectionSQL, releaseProcessorLockSQL, sanitizeNameSQL, schemaMigration, schemaSQL, storeProcessorCheckpoint, storeSubscriptionCheckpointSQL, streamExists, streamsTableSQL, toProcessorLockKey, toProjectionLockKey, transactionToPostgreSQLProjectionHandlerContext, tryAcquireProcessorLockSQL, tryAcquireProjectionLockSQL };
+//# sourceMappingURL=index.d.ts.map