@event-driven-io/pongo 0.17.0-beta.42 → 0.17.0-beta.43

package/dist/index.d.cts

@@ -1,5 +1,721 @@
-import { $ as HasId, $t as AnyPongoDriverOptions, A as MaybePromise, An as hasOperators, At as PongoSession, B as DOCUMENT_DOES_NOT_EXIST, Bn as DocumentCommandHandler, Bt as UpdateOneOptions, C as PongoCacheType, Cn as pongoSchema, Ct as PongoFilter, D as LRUCacheOptions, Dn as toDbSchemaMetadata, Dt as PongoInsertOneResult, E as noopCacheProvider, En as toClientSchemaMetadata, Et as PongoInsertManyResult, F as AlternativeType, Fn as PongoCollectionURNType, Ft as RegExpOrString, G as DocumentHandler, Gn as NonPartial, Gt as WithoutIdAndVersion, H as DeleteManyOptions, Hn as DocumentCommandHandlerOptions, Ht as WithIdAndVersion, I as AnyPongoDb, In as PongoCollectionSQLBuilder, It as ReplaceManyOptions, J as ExpectedDocumentVersionGeneral, Jt as expectedVersionPredicate, K as EnhancedOmit, Kn as objectEntries, Kt as WithoutVersion, L as BatchHandleOptions, Ln as PongoCollectionOptions, Lt as ReplaceOneOptions, M as $push, Mn as PongoCollectionSchemaComponent, Mt as PongoUpdate, N as $set, Nn as PongoCollectionSchemaComponentOptions, Nt as PongoUpdateManyResult, O as lruCache, On as OperatorMap, Ot as PongoMigrationOptions, P as $unset, Pn as PongoCollectionURN, Pt as PongoUpdateResult, Q as HandleOptions, Qt as AnyPongoDriver, R as CollectionOperationOptions, Rn as pongoCollection, Rt as RootFilterOperators, S as PongoCacheSetEntry, Sn as PongoSchemaConfig, St as PongoDocument, T as pongoCache, Tn as proxyPongoDbWithSchema, Tt as PongoHandleResult, U as DeleteOneOptions, Un as getIdsFromIdOnlyFilter, Ut as WithVersion, V as DOCUMENT_EXISTS, Vn as DocumentCommandHandlerInput, Vt as WithId, W as Document, Wn as idFromFilter, Wt as WithoutId, X as ExpectedVersionPredicate, Xt as isGeneralExpectedDocumentVersion, Y as ExpectedDocumentVersionValue, Yt as expectedVersionValue, Z as FindOptions, Zt as operationResult, _ as CacheHooks, _n as PongoCollectionSchema, _t as PongoDb, a as ConcurrencyError, an as PongoDriverRegistry, at as ObjectId, b as CacheType, bn as PongoDbSchemaMetadata, bt as PongoDeleteManyResult, c as isString, cn as PongoDatabaseSchemaComponent, ct as OptionalId, d as PongoDatabaseCache, dn as PongoDatabaseURNType, dt as OptionalUnlessRequiredVersion, en as ExtractPongoDatabaseTypeFromDriver, et as InferIdType, f as PongoTransactionCache, fn as CollectionsMap, ft as OptionalVersion, g as CacheConfig, gn as PongoClientWithSchema, gt as PongoDBCollectionOptions, h as pongoCacheWrapper, hn as PongoClientSchemaMetadata, ht as PongoCollection, i as pongoClient, in as PongoDriverOptions, it as NonObjectIdLikeDocument, j as $inc, jn as isOperator, jt as PongoTransactionOptions, k as identityMapCache, kn as QueryOperators, kt as PongoReplaceManyResult, l as PongoDatabase, ln as PongoDatabaseSchemaComponentOptions, lt as OptionalUnlessRequiredId, m as pongoTransactionCache, mn as PongoClientSchema, mt as PongoClientOptions, n as PongoSessionOptions, nn as PongoDatabaseFactoryOptions, nt as InsertOneOptions, o as PongoError, on as pongoDriverRegistry, ot as ObjectIdLike, p as PongoTransactionCacheOperationOptions, pn as DBsMap, pt as PongoClient, q as ExpectedDocumentVersion, qt as expectedVersion, r as pongoSession, rn as PongoDriver, rt as NO_CONCURRENCY_CHECK, s as isNumber, sn as PongoDatabaseSQLBuilder, st as OperationResult, t as pongoTransaction, tn as ExtractPongoDriverOptions, tt as InsertManyOptions, u as PongoDatabaseOptions, un as PongoDatabaseURN, ut as OptionalUnlessRequiredIdAndVersion, v as CacheOptions, vn as PongoCollectionSchemaMetadata, vt as PongoDbOptions, w as PongoDocumentCacheKey, wn as proxyClientWithSchema, wt as PongoFilterOperator, x as PongoCache, xn as PongoDbWithSchema, xt as PongoDeleteResult, y as CacheSettings, yn as PongoDbSchema, yt as PongoDbTransaction, z as Condition, zn as transactionExecutorOrDefault, zt as UpdateManyOptions } from "./index-C3pnS1S_.cjs";
+import { AnyConnection, DatabaseDriverType, DatabaseTransaction, Dumbo, JSONSerializationOptions, JSONSerializer, MigrationStyle, QueryResult, QueryResultRow, RunSQLMigrationsResult, SQL, SQLCommandOptions, SQLExecutor, SQLQueryOptions, SchemaComponent, SchemaComponentOptions, WithDatabaseTransactionFactory } from "@event-driven-io/dumbo";
+import { LRUCache } from "lru-cache";
 
+//#region src/core/typing/entries.d.ts
+type Entry<T> = { [K in keyof Required<T>]: [K, Required<T>[K]] }[keyof Required<T>];
+type IterableEntry<T> = Entry<T> & {
+  [Symbol.iterator](): Iterator<Entry<T>>;
+};
+declare const objectEntries: <T extends object>(obj: T) => IterableEntry<T>[];
+type NonPartial<T> = { [K in keyof Required<T>]: T[K] };
+//#endregion
+//#region src/core/collection/filters/filters.d.ts
+declare const idFromFilter: <T>(filter: PongoFilter<T> | SQL | undefined) => string | undefined;
+declare const getIdsFromIdOnlyFilter: <T>(filter: PongoFilter<T> | SQL | undefined) => string[] | undefined;
+//#endregion
+//#region src/core/collection/handle.d.ts
+type DocumentCommandHandlerOptions<T extends PongoDocument> = {
+  collectionName: string;
+  serializer: JSONSerializer;
+  errors?: {
+    throwOnOperationFailures?: boolean;
+  } | undefined;
+  storage: {
+    ensureCollectionCreated: (options?: CollectionOperationOptions) => Promise<unknown>;
+    fetchByIds: (ids: string[], options?: CollectionOperationOptions) => Promise<(WithIdAndVersion<T> | null)[]>;
+    insertMany: (docs: OptionalUnlessRequiredIdAndVersion<T>[], options?: CollectionOperationOptions) => Promise<PongoInsertManyResult>;
+    replaceMany: (docs: Array<WithIdAndVersion<T>>, options?: CollectionOperationOptions) => Promise<PongoReplaceManyResult>;
+    deleteManyByIds: (ids: Array<{
+      _id: string;
+      _version?: bigint;
+    }>, options?: CollectionOperationOptions) => Promise<PongoDeleteResult & {
+      deletedIds: Set<string>;
+    }>;
+  };
+};
+type DocumentCommandHandlerInput = {
+  _id: string;
+  expectedVersion?: ExpectedDocumentVersion;
+};
+declare function DocumentCommandHandler<T extends PongoDocument>(deps: DocumentCommandHandlerOptions<T>): {
+  (id: string | DocumentCommandHandlerInput, handler: DocumentHandler<T> | DocumentHandler<T>[], options?: HandleOptions): Promise<PongoHandleResult<T>>;
+  (ids: string[] | DocumentCommandHandlerInput[], handler: DocumentHandler<T> | DocumentHandler<T>[], options?: HandleOptions & BatchHandleOptions): Promise<PongoHandleResult<T>[]>;
+};
+//#endregion
+//#region src/core/collection/pongoCollection.d.ts
+type PongoCollectionOptions<T extends PongoDocument = PongoDocument, DriverType extends DatabaseDriverType = DatabaseDriverType, Payload extends PongoDocument = T> = {
+  db: PongoDb<DriverType>;
+  collectionName: string;
+  pool: Dumbo<DatabaseDriverType>;
+  schemaComponent: PongoCollectionSchemaComponent;
+  schema?: {
+    autoMigration?: MigrationStyle;
+    versioning?: {
+      upcast?: (doc: Payload) => T;
+      downcast?: (doc: T) => Payload;
+    };
+  };
+  errors?: {
+    throwOnOperationFailures?: boolean;
+  };
+  serializer: JSONSerializer;
+  cache?: CacheConfig | 'disabled' | PongoCache | undefined;
+};
+declare const transactionExecutorOrDefault: <DriverType extends DatabaseDriverType = DatabaseDriverType>(db: PongoDb<DriverType>, options: CollectionOperationOptions | undefined, defaultSqlExecutor: SQLExecutor) => Promise<SQLExecutor>;
+declare const pongoCollection: <T extends PongoDocument, DriverType extends DatabaseDriverType = DatabaseDriverType, Payload extends PongoDocument = T>({
+  db,
+  collectionName,
+  pool,
+  schemaComponent,
+  schema,
+  errors,
+  serializer,
+  cache: cacheOptions
+}: PongoCollectionOptions<T, DriverType, Payload>) => PongoCollection<T>;
+//#endregion
+//#region src/core/collection/pongoCollectionSchema.d.ts
+type PongoCollectionSQLBuilder = {
+  createCollection: () => SQL;
+  insertOne: <T>(document: OptionalUnlessRequiredIdAndVersion<T>) => SQL;
+  insertMany: <T>(documents: OptionalUnlessRequiredIdAndVersion<T>[]) => SQL;
+  insertOrReplace: <T>(documents: Array<WithId<T>>) => SQL;
+  updateOne: <T>(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateOneOptions) => SQL;
+  replaceOne: <T>(filter: PongoFilter<T> | SQL, document: WithoutId<T>, options?: ReplaceOneOptions) => SQL;
+  updateMany: <T>(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL) => SQL;
+  deleteOne: <T>(filter: PongoFilter<T> | SQL, options?: DeleteOneOptions) => SQL;
+  deleteMany: <T>(filter: PongoFilter<T> | SQL) => SQL;
+  replaceMany: <T>(documents: Array<WithIdAndVersion<T>> | Array<WithId<T>>) => SQL;
+  deleteManyByIds: (ids: Array<{
+    _id: string;
+    _version?: bigint;
+  }>) => SQL;
+  findOne: <T>(filter: PongoFilter<T> | SQL) => SQL;
+  find: <T>(filter: PongoFilter<T> | SQL, options?: FindOptions) => SQL;
+  countDocuments: <T>(filter: PongoFilter<T> | SQL) => SQL;
+  rename: (newName: string) => SQL;
+  drop: () => SQL;
+};
+//#endregion
+//#region src/core/collection/pongoCollectionSchemaComponent.d.ts
+type PongoCollectionURNType = 'sc:pongo:collection';
+type PongoCollectionURN = `${PongoCollectionURNType}:${string}`;
+type PongoCollectionSchemaComponent = SchemaComponent<PongoCollectionURN> & {
+  collectionName: string;
+  definition: PongoCollectionSchema;
+  sqlBuilder: PongoCollectionSQLBuilder;
+};
+type PongoCollectionSchemaComponentOptions<DriverType extends DatabaseDriverType = DatabaseDriverType> = Readonly<{
+  driverType: DriverType;
+  definition: PongoCollectionSchema;
+  migrationsOrSchemaComponents: SchemaComponentOptions;
+  sqlBuilder: PongoCollectionSQLBuilder;
+}>;
+declare const PongoCollectionSchemaComponent: <DriverType extends DatabaseDriverType = DatabaseDriverType>({
+  definition,
+  migrationsOrSchemaComponents,
+  sqlBuilder
+}: PongoCollectionSchemaComponentOptions<DriverType>) => PongoCollectionSchemaComponent;
+//#endregion
+//#region src/core/collection/query.d.ts
+declare const QueryOperators: {
+  $eq: string;
+  $gt: string;
+  $gte: string;
+  $lt: string;
+  $lte: string;
+  $ne: string;
+  $in: string;
+  $nin: string;
+  $elemMatch: string;
+  $all: string;
+  $size: string;
+};
+declare const OperatorMap: {
+  $gt: string;
+  $gte: string;
+  $lt: string;
+  $lte: string;
+  $ne: string;
+};
+declare const isOperator: (key: string) => boolean;
+declare const hasOperators: (value: Record<string, unknown>) => boolean;
+//#endregion
+//#region src/core/schema/index.d.ts
+interface PongoCollectionSchema<T extends PongoDocument = PongoDocument> {
+  name: string;
+}
+interface PongoDbSchema<T extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>> {
+  name?: string;
+  collections: T;
+}
+interface PongoClientSchema<T extends Record<string, PongoDbSchema> = Record<string, PongoDbSchema>> {
+  dbs: T;
+}
+type CollectionsMap<T extends Record<string, PongoCollectionSchema>> = { [K in keyof T]: PongoCollection<T[K] extends PongoCollectionSchema<infer U> ? U : PongoDocument> };
+type PongoDbWithSchema<T extends Record<string, PongoCollectionSchema>, DriverType extends DatabaseDriverType = DatabaseDriverType> = CollectionsMap<T> & PongoDb<DriverType>;
+type DBsMap<T extends Record<string, PongoDbSchema>, DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>> = { [K in keyof T]: CollectionsMap<T[K]['collections']> & Database };
+type PongoClientWithSchema<T extends PongoClientSchema, DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>> = DBsMap<T['dbs'], DriverType, Database> & PongoClient<DriverType, Database>;
+declare function pongoDbSchema<T extends Record<string, PongoCollectionSchema>>(collections: T): PongoDbSchema<T>;
+declare function pongoDbSchema<T extends Record<string, PongoCollectionSchema>>(name: string, collections: T): PongoDbSchema<T>;
+declare namespace pongoDbSchema {
+  var from: (databaseName: string | undefined, collectionNames: string[]) => PongoDbSchema;
+}
+declare const pongoSchema: {
+  client: <T extends Record<string, PongoDbSchema>>(dbs: T) => PongoClientSchema<T>;
+  db: typeof pongoDbSchema;
+  collection: {
+    <T extends PongoDocument>(name: string): PongoCollectionSchema<T>;
+    from(collectionNames: string[]): Record<string, PongoCollectionSchema>;
+  };
+};
+declare const proxyPongoDbWithSchema: <Collections extends Record<string, PongoCollectionSchema>, DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>>(pongoDb: Database, dbSchema: PongoDbSchema<Collections>, collections: Map<string, PongoCollection<Document>>) => PongoDbWithSchema<Collections, DriverType> & Database;
+declare const proxyClientWithSchema: <TypedClientSchema extends PongoClientSchema, DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>>(client: PongoClient<DriverType, Database>, schema: TypedClientSchema | undefined) => PongoClientWithSchema<TypedClientSchema, DriverType, Database>;
+type PongoCollectionSchemaMetadata = {
+  name: string;
+};
+type PongoDbSchemaMetadata = {
+  name?: string | undefined;
+  collections: PongoCollectionSchemaMetadata[];
+};
+type PongoClientSchemaMetadata = {
+  databases: PongoDbSchemaMetadata[];
+  database: (name?: string) => PongoDbSchemaMetadata | undefined;
+};
+declare const toDbSchemaMetadata: <TypedDbSchema extends PongoDbSchema>(schema: TypedDbSchema) => PongoDbSchemaMetadata;
+declare const toClientSchemaMetadata: <TypedClientSchema extends PongoClientSchema>(schema: TypedClientSchema) => PongoClientSchemaMetadata;
+interface PongoSchemaConfig<TypedClientSchema extends PongoClientSchema = PongoClientSchema> {
+  schema: TypedClientSchema;
+}
+//#endregion
+//#region src/core/database/pongoDatabaseSchemaComponent.d.ts
+type PongoDatabaseURNType = 'sc:dumbo:database';
+type PongoDatabaseURN = `${PongoDatabaseURNType}:${string}`;
+type PongoDatabaseSchemaComponent<DriverType extends DatabaseDriverType = DatabaseDriverType, T extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>> = SchemaComponent<PongoDatabaseURN> & {
+  definition: PongoDbSchema<T>;
+  collections: ReadonlyArray<PongoCollectionSchemaComponent>;
+  collection: <T extends PongoDocument = PongoDocument>(schema: PongoCollectionSchema<T>) => PongoCollectionSchemaComponent;
+};
+type PongoDatabaseSchemaComponentOptions<DriverType extends DatabaseDriverType = DatabaseDriverType, T extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>> = Readonly<{
+  driverType: DriverType;
+  definition: PongoDbSchema<T>;
+  collectionFactory: <T extends PongoDocument = PongoDocument>(schema: PongoCollectionSchema<T>) => PongoCollectionSchemaComponent;
+}>;
+declare const PongoDatabaseSchemaComponent: <DriverType extends DatabaseDriverType = DatabaseDriverType>({
+  definition,
+  collectionFactory
+}: PongoDatabaseSchemaComponentOptions<DriverType>) => PongoDatabaseSchemaComponent;
+type PongoDatabaseSQLBuilder<DriverType extends DatabaseDriverType = DatabaseDriverType> = {
+  driverType: DriverType;
+  collection: PongoCollectionSQLBuilder;
+};
+//#endregion
+//#region src/core/drivers/databaseDriver.d.ts
+type PongoDriverOptions<ConnectionOptions = unknown> = {
+  connectionOptions?: ConnectionOptions | undefined;
+} & JSONSerializationOptions;
+type AnyPongoDriverOptions = PongoDriverOptions<any>;
+type PongoDatabaseFactoryOptions<CollectionsSchema extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>, DriverOptions extends AnyPongoDriverOptions = AnyPongoDriverOptions> = {
+  databaseName?: string | undefined;
+  schema?: {
+    autoMigration?: MigrationStyle;
+    definition?: PongoDbSchema<CollectionsSchema>;
+  } | undefined;
+  serializer: JSONSerializer;
+  errors?: {
+    throwOnOperationFailures?: boolean;
+  } | undefined;
+  cache?: CacheConfig | 'disabled' | PongoCache | undefined;
+} & DriverOptions;
+interface PongoDriver<Database extends AnyPongoDb = AnyPongoDb, DriverOptions extends AnyPongoDriverOptions = AnyPongoDriverOptions> {
+  driverType: Database['driverType'];
+  databaseFactory<CollectionsSchema extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>>(options: PongoDatabaseFactoryOptions<CollectionsSchema, DriverOptions>): Database & PongoDb<Database['driverType']>;
+}
+type AnyPongoDriver = PongoDriver<AnyPongoDb, AnyPongoDriverOptions>;
+type ExtractPongoDriverOptions<DatabaseDriver> = DatabaseDriver extends PongoDriver<any, infer O> ? O : never;
+type ExtractPongoDatabaseTypeFromDriver<DatabaseDriver> = DatabaseDriver extends PongoDriver<infer D, any> ? D : never;
+declare const PongoDriverRegistry: () => {
+  register: <Database extends AnyPongoDb = AnyPongoDb>(driverType: Database["driverType"], driver: PongoDriver<Database> | (() => Promise<PongoDriver<Database>>)) => void;
+  tryResolve: <Driver extends AnyPongoDriver = AnyPongoDriver>(driverType: Driver["driverType"]) => Promise<Driver | null>;
+  tryGet: <Driver extends AnyPongoDriver = AnyPongoDriver>(driverType: Driver["driverType"]) => Driver | null;
+  has: (driverType: DatabaseDriverType) => boolean;
+  readonly databaseDriverTypes: DatabaseDriverType[];
+};
+declare global {
+  var pongoDriverRegistry: ReturnType<typeof PongoDriverRegistry>;
+}
+declare const pongoDriverRegistry: {
+  register: <Database extends AnyPongoDb = AnyPongoDb>(driverType: Database["driverType"], driver: PongoDriver<Database> | (() => Promise<PongoDriver<Database>>)) => void;
+  tryResolve: <Driver extends AnyPongoDriver = AnyPongoDriver>(driverType: Driver["driverType"]) => Promise<Driver | null>;
+  tryGet: <Driver extends AnyPongoDriver = AnyPongoDriver>(driverType: Driver["driverType"]) => Driver | null;
+  has: (driverType: DatabaseDriverType) => boolean;
+  readonly databaseDriverTypes: DatabaseDriverType[];
+};
+//#endregion
+//#region src/core/typing/operations.d.ts
+interface PongoClient<DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>> {
+  driverType: DriverType;
+  connect(): Promise<this>;
+  close(): Promise<void>;
+  db(dbName?: string, options?: PongoDbOptions): Database;
+  startSession(): PongoSession<DriverType>;
+  withSession<T = unknown>(callback: (session: PongoSession<DriverType>) => Promise<T>): Promise<T>;
+}
+type PongoClientOptions<DatabaseDriver extends AnyPongoDriver = AnyPongoDriver, TypedClientSchema extends PongoClientSchema = PongoClientSchema> = ExtractPongoDriverOptions<DatabaseDriver> extends infer Options ? Options extends unknown ? {
+  driver: DatabaseDriver;
+  schema?: {
+    autoMigration?: MigrationStyle;
+    definition?: TypedClientSchema;
+  } | undefined;
+  errors?: {
+    throwOnOperationFailures?: boolean;
+  } | undefined;
+  cache?: CacheConfig | PongoCache | undefined;
+} & JSONSerializationOptions & Omit<Options, 'driver'> : never : never;
+declare interface PongoTransactionOptions {
+  get snapshotEnabled(): boolean;
+  maxCommitTimeMS?: number;
+}
+interface PongoDbTransaction<DriverType extends DatabaseDriverType = DatabaseDriverType, Database extends PongoDb<DriverType> = PongoDb<DriverType>> {
+  get databaseName(): string | null;
+  options: PongoTransactionOptions;
+  enlistDatabase: (database: Database) => Promise<DatabaseTransaction<AnyConnection>>;
+  commit: () => Promise<void>;
+  rollback: (error?: unknown) => Promise<void>;
+  get cache(): PongoTransactionCache | null;
+  get sqlExecutor(): SQLExecutor;
+  get isStarting(): boolean;
+  get isActive(): boolean;
+  get isCommitted(): boolean;
+}
+interface PongoSession<DriverType extends DatabaseDriverType = DatabaseDriverType> {
+  hasEnded: boolean;
+  explicit: boolean;
+  defaultTransactionOptions: PongoTransactionOptions;
+  transaction: PongoDbTransaction<DriverType> | null;
+  get snapshotEnabled(): boolean;
+  endSession(): Promise<void>;
+  incrementTransactionNumber(): void;
+  inTransaction(): boolean;
+  startTransaction(options?: PongoTransactionOptions): void;
+  commitTransaction(): Promise<void>;
+  abortTransaction(): Promise<void>;
+  withTransaction<T = unknown>(fn: (session: PongoSession<DriverType>) => Promise<T>, options?: PongoTransactionOptions): Promise<T>;
+}
+type PongoDBCollectionOptions<T extends PongoDocument, Payload extends PongoDocument = T> = {
+  schema?: {
+    versioning?: {
+      upcast?: (document: Payload) => T;
+      downcast?: (document: T) => Payload;
+    };
+  };
+  errors?: {
+    throwOnOperationFailures?: boolean;
+  };
+  cache?: CacheConfig | 'disabled' | PongoCache;
+};
+type PongoDbOptions = {
+  cache?: CacheConfig | PongoCache;
+};
+interface PongoDb<DriverType extends DatabaseDriverType = DatabaseDriverType> extends WithDatabaseTransactionFactory<AnyConnection> {
+  driverType: DriverType;
+  databaseName: string;
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  collection<T extends PongoDocument, Payload extends PongoDocument = T>(name: string, options?: PongoDBCollectionOptions<T, Payload>): PongoCollection<T>;
+  collections(): ReadonlyArray<PongoCollection<PongoDocument>>;
+  readonly schema: Readonly<{
+    component: PongoDatabaseSchemaComponent<DriverType>;
+    migrate(options?: PongoMigrationOptions): Promise<RunSQLMigrationsResult>;
+  }>;
+  sql: {
+    query<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions & SQLQueryOptions): Promise<Result[]>;
+    command<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions & SQLCommandOptions): Promise<QueryResult<Result>>;
+  };
+}
+type AnyPongoDb = PongoDb<DatabaseDriverType>;
+type PongoMigrationOptions = {
+  dryRun?: boolean | undefined;
+  ignoreMigrationHashMismatch?: boolean | undefined;
+  migrationTimeoutMs?: number | undefined;
+};
+type CollectionOperationOptions = {
+  session?: PongoSession;
+  skipCache?: boolean;
+};
+type InsertOneOptions = {
+  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK'>;
+  upsert?: boolean;
+} & CollectionOperationOptions;
+type InsertManyOptions = {
+  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK'>;
+  upsert?: boolean;
+} & CollectionOperationOptions;
+type UpdateOneOptions = {
+  expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
+} & CollectionOperationOptions;
+type UpdateManyOptions = {
+  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
+} & CollectionOperationOptions;
+type HandleOptions = CollectionOperationOptions;
+type BatchHandleOptions = {
+  parallel?: boolean;
+} & CollectionOperationOptions;
+type ReplaceOneOptions = {
+  expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
+  upsert?: boolean;
+} & CollectionOperationOptions;
+type DeleteOneOptions = {
+  expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
+} & CollectionOperationOptions;
+type ReplaceManyOptions = {
+  upsert?: boolean;
+} & CollectionOperationOptions;
+type DeleteManyOptions = {
+  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
+} & CollectionOperationOptions;
+type FindOptions = {
+  limit?: number;
+  skip?: number;
+  sort?: {
+    [field: string]: 1 | -1;
+  };
+} & CollectionOperationOptions;
+interface PongoCollection<T extends PongoDocument> {
+  readonly dbName: string;
+  readonly collectionName: string;
+  createCollection(options?: CollectionOperationOptions): Promise<void>;
+  insertOne(document: OptionalUnlessRequiredId<T>, options?: InsertOneOptions): Promise<PongoInsertOneResult>;
+  insertMany(documents: OptionalUnlessRequiredId<T>[], options?: InsertManyOptions): Promise<PongoInsertManyResult>;
+  updateOne(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateOneOptions): Promise<PongoUpdateResult>;
+  replaceOne(filter: PongoFilter<T> | SQL, document: WithoutId<T>, options?: ReplaceOneOptions): Promise<PongoUpdateResult>;
+  updateMany(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateManyOptions): Promise<PongoUpdateManyResult>;
+  deleteOne(filter?: PongoFilter<T> | SQL, options?: DeleteOneOptions): Promise<PongoDeleteResult>;
+  deleteMany(filter?: PongoFilter<T> | SQL, options?: DeleteManyOptions): Promise<PongoDeleteResult>;
+  findOne(filter?: PongoFilter<T> | SQL, options?: CollectionOperationOptions): Promise<WithIdAndVersion<T> | null>;
+  find(filter?: PongoFilter<T> | SQL, options?: FindOptions): Promise<WithIdAndVersion<T>[]>;
+  findOneAndDelete(filter: PongoFilter<T> | SQL, options?: DeleteOneOptions): Promise<WithIdAndVersion<T> | null>;
+  findOneAndReplace(filter: PongoFilter<T> | SQL, replacement: WithoutId<T>, options?: ReplaceOneOptions): Promise<WithIdAndVersion<T> | null>;
+  findOneAndUpdate(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateOneOptions): Promise<WithIdAndVersion<T> | null>;
+  countDocuments(filter?: PongoFilter<T> | SQL, options?: CollectionOperationOptions): Promise<number>;
+  drop(options?: CollectionOperationOptions): Promise<boolean>;
+  rename(newName: string, options?: CollectionOperationOptions): Promise<PongoCollection<T>>;
+  handle(id: string | DocumentCommandHandlerInput, handle: DocumentHandler<T>, options?: HandleOptions): Promise<PongoHandleResult<T>>;
+  handle(id: string[] | DocumentCommandHandlerInput[], handle: DocumentHandler<T>, options?: BatchHandleOptions): Promise<PongoHandleResult<T>[]>;
+  replaceMany(documents: Array<WithIdAndVersion<T>> | Array<WithId<T>>, options?: ReplaceManyOptions): Promise<PongoReplaceManyResult>;
+  readonly schema: Readonly<{
+    component: PongoCollectionSchemaComponent;
+    migrate(options?: PongoMigrationOptions): Promise<RunSQLMigrationsResult>;
+  }>;
+  close: () => MaybePromise<void>;
+  sql: {
+    query<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions): Promise<Result[]>;
+    command<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions): Promise<QueryResult<Result>>;
+  };
+}
+type ObjectId = string & {
+  __brandId: 'ObjectId';
+};
+declare const ObjectId: (value?: string) => string;
+type HasId = {
+  _id: string;
+};
+declare type InferIdType<TSchema> = TSchema extends {
+  _id: infer IdType;
+} ? Record<any, never> extends IdType ? never : IdType : TSchema extends {
+  _id?: infer IdType;
+} ? unknown extends IdType ? ObjectId : IdType : ObjectId;
+/** TypeScript Omit (Exclude to be specific) does not work for objects with an "any" indexed type, and breaks discriminated unions @public */
+declare type EnhancedOmit<TRecordOrUnion, KeyUnion> = string extends keyof TRecordOrUnion ? TRecordOrUnion : TRecordOrUnion extends any ? Pick<TRecordOrUnion, Exclude<keyof TRecordOrUnion, KeyUnion>> : never;
+declare type OptionalUnlessRequiredId<TSchema> = TSchema extends {
+  _id: string | ObjectId;
+} ? TSchema : OptionalId<TSchema>;
+declare type OptionalUnlessRequiredVersion<TSchema> = TSchema extends {
+  _version: bigint;
+} ? TSchema : OptionalVersion<TSchema>;
+declare type OptionalUnlessRequiredIdAndVersion<TSchema> = OptionalUnlessRequiredId<TSchema> & OptionalUnlessRequiredVersion<TSchema>;
+declare type WithId<TSchema> = TSchema & {
+  _id: string | ObjectId;
+};
+type WithoutId<T> = Omit<T, '_id'>;
+declare type WithVersion<TSchema> = TSchema & {
+  _version: bigint;
+};
+type WithoutVersion<T> = Omit<T, '_version'>;
+type WithIdAndVersion<T> = WithId<T> & WithVersion<T>;
+type WithoutIdAndVersion<T> = WithoutId<WithoutVersion<T>>;
+/** @public */
+declare type RegExpOrString<T> = T extends string ? RegExp | T : T;
+declare interface Document {
+  [key: string]: any;
+}
+declare type OptionalId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
+  _id?: string | ObjectId;
+};
+declare type OptionalVersion<TSchema> = EnhancedOmit<TSchema, '_version'> & {
+  _version?: bigint;
+};
+declare interface ObjectIdLike {
+  __id?: string | ObjectId;
+}
+declare type NonObjectIdLikeDocument = { [key in keyof ObjectIdLike]?: never } & Document;
+declare type AlternativeType<T> = T extends ReadonlyArray<infer U> ? T | RegExpOrString<U> : RegExpOrString<T>;
+declare type Condition<T> = AlternativeType<T> | PongoFilterOperator<AlternativeType<T>>;
+declare interface RootFilterOperators<TSchema> extends Document {
+  $and?: PongoFilter<TSchema>[];
+  $nor?: PongoFilter<TSchema>[];
+  $or?: PongoFilter<TSchema>[];
+  $text?: {
+    $search: string;
+    $language?: string;
+    $caseSensitive?: boolean;
+    $diacriticSensitive?: boolean;
+  };
+  $where?: string | ((this: TSchema) => boolean);
+  $comment?: string | Document;
+}
+declare type PongoFilter<TSchema> = ({ [P in keyof WithId<TSchema>]?: Condition<WithId<TSchema>[P]> } & Pick<RootFilterOperators<WithId<TSchema>>, '$and' | '$nor' | '$or'>) | (HasId & Pick<RootFilterOperators<WithId<TSchema>>, '$and' | '$nor' | '$or'>);
+declare interface PongoFilterOperator<TValue> extends NonObjectIdLikeDocument {
+  $eq?: TValue;
+  $gt?: TValue;
+  $gte?: TValue;
+  $lt?: TValue;
+  $lte?: TValue;
+  $ne?: TValue;
+  $in?: TValue[];
+  $nin?: TValue[];
+}
+type $set<T> = Partial<T>;
+type $unset<T> = { [P in keyof T]?: '' };
+type $inc<T> = { [P in keyof T]?: number | bigint };
+type $push<T> = { [P in keyof T]?: T[P] };
+type ExpectedDocumentVersionGeneral = 'DOCUMENT_EXISTS' | 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK';
+type ExpectedDocumentVersionValue = bigint & {
+  __brand: 'sql';
+};
+type ExpectedDocumentVersion = (bigint & {
+  __brand: 'sql';
+}) | bigint | ExpectedDocumentVersionGeneral;
+declare const DOCUMENT_EXISTS: ExpectedDocumentVersionGeneral;
+declare const DOCUMENT_DOES_NOT_EXIST: ExpectedDocumentVersionGeneral;
+declare const NO_CONCURRENCY_CHECK: ExpectedDocumentVersionGeneral;
+declare const isGeneralExpectedDocumentVersion: (version: ExpectedDocumentVersion) => version is ExpectedDocumentVersionGeneral;
+declare const expectedVersionValue: (version: ExpectedDocumentVersion | undefined) => ExpectedDocumentVersionValue | null;
+type ExpectedVersionPredicate = {
+  operator: 'none';
+} | {
+  operator: '=';
+  value: bigint;
+};
+declare const expectedVersionPredicate: (version: ExpectedDocumentVersion | undefined) => ExpectedVersionPredicate;
+declare const expectedVersion: (version: number | bigint | string | undefined | null) => ExpectedDocumentVersion;
+type PongoUpdate<T> = {
+  $set?: Partial<T>;
+  $unset?: $unset<T>;
+  $inc?: $inc<T>;
+  $push?: $push<T>;
+};
+type OperationResult = {
+  acknowledged: boolean;
+  successful: boolean;
+  assertSuccessful: (errorMessage?: string) => void;
+};
+declare const operationResult: <T extends OperationResult>(result: Omit<T, "assertSuccess" | "acknowledged" | "assertSuccessful">, options: {
+  operationName: string;
+  collectionName: string;
+  serializer: JSONSerializer;
+  errors?: {
+    throwOnOperationFailures?: boolean;
+  } | undefined;
+}) => T;
+interface PongoInsertOneResult extends OperationResult {
+  insertedId: string | null;
+  nextExpectedVersion: bigint;
+}
+interface PongoInsertManyResult extends OperationResult {
+  insertedIds: string[];
+  insertedCount: number;
+}
+interface PongoUpdateResult extends OperationResult {
+  matchedCount: number;
+  modifiedCount: number;
+  upsertedId: string | null;
+  upsertedCount: number;
+  nextExpectedVersion: bigint;
+}
+interface PongoUpdateManyResult extends OperationResult {
+  matchedCount: number;
+  modifiedCount: number;
+}
+interface PongoDeleteResult extends OperationResult {
+  matchedCount: number;
+  deletedCount: number;
+}
+interface PongoDeleteManyResult extends OperationResult {
+  deletedCount: number;
+}
+interface PongoReplaceManyResult extends OperationResult {
+  modifiedCount: number;
+  matchedCount: number;
+  modifiedIds: string[];
+  conflictIds: string[];
+  nextExpectedVersions: Map<string, bigint>;
+}
+type PongoHandleResult<T> = (PongoInsertOneResult & {
+  document: T;
+}) | (PongoUpdateResult & {
+  document: T;
+}) | (PongoDeleteResult & {
+  document: null;
+}) | (OperationResult & {
+  document: null;
+});
+type PongoDocument = Record<string, unknown>;
+type DocumentHandler<T extends PongoDocument> = ((document: T | null, id: string) => T | null) | ((document: T | null, id: string) => Promise<T | null>);
+//#endregion
+//#region src/core/typing/index.d.ts
+type MaybePromise<T> = T | PromiseLike<T>;
+//#endregion
+//#region src/core/cache/providers/identityMapCache.d.ts
+declare const identityMapCache: () => PongoCache;
+//#endregion
+//#region src/core/cache/providers/lruCache.d.ts
+type LRUCacheOptions = Omit<LRUCache.Options<string, {
+  doc: PongoDocument | null;
+}, unknown>, 'max'> & {
+  max?: number;
+};
+declare const lruCache: (options?: LRUCacheOptions) => PongoCache;
+//#endregion
+//#region src/core/cache/providers/noopCache.d.ts
+declare const noopCacheProvider: PongoCache;
+//#endregion
+//#region src/core/cache/pongoCache.d.ts
+type PongoDocumentCacheKey = `${string}:${string}:${string}`;
+type PongoCacheSetEntry<Doc extends PongoDocument = PongoDocument> = {
+  key: PongoDocumentCacheKey;
+  value: Doc | null;
+};
+type PongoCacheType<T extends string = string> = `pongo:cache:${T}`;
+interface PongoCache<T extends string = string> {
+  cacheType: PongoCacheType<T>;
+  get<Doc extends PongoDocument = PongoDocument>(key: PongoDocumentCacheKey): MaybePromise<Doc | null | undefined>;
+  getMany<Doc extends PongoDocument = PongoDocument>(keys: PongoDocumentCacheKey[]): MaybePromise<(Doc | null | undefined)[]>;
+  set<Doc extends PongoDocument = PongoDocument>(key: PongoDocumentCacheKey, value: Doc | null): MaybePromise<void>;
+  setMany(entries: PongoCacheSetEntry[]): MaybePromise<void>;
+  update<Doc extends PongoDocument = PongoDocument>(key: PongoDocumentCacheKey, updater: PongoUpdate<Doc>): MaybePromise<void>;
+  updateMany<Doc extends PongoDocument = PongoDocument>(keys: PongoDocumentCacheKey[], updater: PongoUpdate<Doc>): MaybePromise<void>;
+  delete(key: PongoDocumentCacheKey): MaybePromise<void>;
+  deleteMany(keys: PongoDocumentCacheKey[]): MaybePromise<void>;
+  clear(): MaybePromise<void>;
+  close(): MaybePromise<void>;
+}
+type CacheHooks = {
+  onHit?(key: PongoDocumentCacheKey): void;
+  onMiss?(key: PongoDocumentCacheKey): void;
+  onEvict?(key: PongoDocumentCacheKey): void;
+  onError?(error: unknown, operation: string): void;
+};
+type CacheType = 'in-memory' | 'identity-map';
+type CacheSettings = ({
+  type: 'in-memory';
+} & LRUCacheOptions) | {
+  type: 'identity-map';
+};
+type CacheConfig = CacheSettings | 'disabled';
+type CacheOptions = {
+  skipCache?: boolean;
+};
+declare const pongoCache: (options?: CacheConfig | "disabled" | PongoCache | undefined) => PongoCache;
+//#endregion
+//#region src/core/cache/pongoCacheWrapper.d.ts
+declare const pongoCacheWrapper: (options: {
+  provider: PongoCache;
+  hooks?: CacheHooks;
+}) => PongoCache;
+//#endregion
+//#region src/core/cache/transactions/pongoTransactionCache.d.ts
+type PongoTransactionCacheOperationOptions = {
+  mainCache: PongoCache;
+};
+interface PongoTransactionCache<T extends string = string> {
+  type: PongoCacheType<T>;
+  get<Doc extends PongoDocument = PongoDocument>(key: PongoDocumentCacheKey): MaybePromise<Doc | null | undefined>;
+  set(key: PongoDocumentCacheKey, value: PongoDocument | null, options: PongoTransactionCacheOperationOptions): MaybePromise<void>;
+  update<Doc extends PongoDocument = PongoDocument>(key: PongoDocumentCacheKey, updater: PongoUpdate<Doc>, options: PongoTransactionCacheOperationOptions): MaybePromise<void>;
+  delete(key: PongoDocumentCacheKey, options: PongoTransactionCacheOperationOptions): MaybePromise<void>;
+  getMany<Doc extends PongoDocument = PongoDocument>(keys: PongoDocumentCacheKey[]): MaybePromise<(Doc | null | undefined)[]>;
+  setMany(entries: PongoCacheSetEntry[], options: PongoTransactionCacheOperationOptions): MaybePromise<void>;
+  updateMany<Doc extends PongoDocument = PongoDocument>(keys: PongoDocumentCacheKey[], updater: PongoUpdate<Doc>, options: PongoTransactionCacheOperationOptions): MaybePromise<void>;
+  deleteMany(keys: PongoDocumentCacheKey[], options: PongoTransactionCacheOperationOptions): MaybePromise<void>;
+  clear(): MaybePromise<void>;
+  commit(): Promise<void>;
+}
+declare const pongoTransactionCache: (options?: {
+  cache?: PongoCache;
+}) => PongoTransactionCache;
+//#endregion
+//#region src/core/database/pongoDatabaseCache.d.ts
+declare const PongoDatabaseCache: <Database extends PongoDb<DatabaseDriverType> = PongoDb<DatabaseDriverType>, TypedClientSchema extends PongoClientSchema = PongoClientSchema>({
+  driver,
+  typedSchema
+}: {
+  driver: PongoDriver<Database>;
+  typedSchema?: TypedClientSchema | undefined;
+}) => {
+  getOrCreate: <CollectionsSchema extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema<PongoDocument>>>(createOptions: Omit<PongoDatabaseFactoryOptions<CollectionsSchema>, "schema"> & JSONSerializationOptions & {
+    schema?: {
+      autoMigration?: MigrationStyle;
+    };
+  }) => Database;
+  all: () => Database[];
+  forAll: (func: (db: Database) => Promise<void>) => Promise<void[]>;
+};
+//#endregion
+//#region src/core/database/pongoDb.d.ts
+type PongoDatabaseOptions<DumboType extends Dumbo<DatabaseDriverType, any> = Dumbo<DatabaseDriverType, any>, CollectionsSchema extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>> = {
+  databaseName: string;
+  pool: DumboType;
+  serializer: JSONSerializer;
+  schemaComponent: PongoDatabaseSchemaComponent<DumboType['driverType']>;
+  schema?: {
+    autoMigration?: MigrationStyle;
+    definition?: PongoDbSchema<CollectionsSchema>;
+  } | undefined;
+  errors?: {
+    throwOnOperationFailures?: boolean;
+  } | undefined;
+  cache?: CacheConfig | 'disabled' | PongoCache | undefined;
+};
+declare const PongoDatabase: <Database extends AnyPongoDb = AnyPongoDb, DumboType extends Dumbo<Database["driverType"], any> = Dumbo<Database["driverType"], any>>(options: PongoDatabaseOptions<DumboType>) => Database;
+//#endregion
+//#region src/core/errors/index.d.ts
+declare const isNumber: (val: unknown) => val is number;
+declare const isString: (val: unknown) => val is string;
+declare class PongoError extends Error {
+  errorCode: number;
+  constructor(options?: {
+    errorCode: number;
+    message?: string;
+  } | string | number);
+}
+declare class ConcurrencyError extends PongoError {
+  constructor(message?: string);
+}
+//#endregion
+//#region src/core/pongoClient.d.ts
+declare const pongoClient: <DatabaseDriver extends AnyPongoDriver, TypedClientSchema extends PongoClientSchema = PongoClientSchema>(options: PongoClientOptions<DatabaseDriver, TypedClientSchema>) => PongoClient<DatabaseDriver["driverType"], ExtractPongoDatabaseTypeFromDriver<DatabaseDriver>> & PongoClientWithSchema<TypedClientSchema>;
+//#endregion
+//#region src/core/pongoSession.d.ts
+type PongoSessionOptions = {
+  explicit?: boolean;
+  defaultTransactionOptions: PongoTransactionOptions;
+  cache?: CacheConfig | 'disabled' | PongoCache;
+};
+declare const pongoSession: (options?: PongoSessionOptions) => PongoSession;
+//#endregion
+//#region src/core/pongoTransaction.d.ts
+declare const pongoTransaction: (options: PongoTransactionOptions) => PongoDbTransaction;
+//#endregion
 //#region src/core/utils/deepEquals.d.ts
 declare const deepEquals: <T>(left: T, right: T) => boolean;
 type Equatable<T> = {