@event-driven-io/pongo 0.17.0-beta.4 → 0.17.0-beta.40

package/dist/index-r7V4paf_.d.ts

@@ -0,0 +1,720 @@
+import { LRUCache } from "lru-cache";
+import { AnyConnection, DatabaseDriverType, DatabaseTransaction, Dumbo, JSONSerializationOptions, JSONSerializer, MigrationStyle, QueryResult, QueryResultRow, RunSQLMigrationsResult, SQL, SQLCommandOptions, SQLExecutor, SQLQueryOptions, SchemaComponent, SchemaComponentOptions, WithDatabaseTransactionFactory } from "@event-driven-io/dumbo";
+
+//#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
+export { HasId as $, AnyPongoDriverOptions as $t, MaybePromise as A, hasOperators as An, PongoSession as At, DOCUMENT_DOES_NOT_EXIST as B, DocumentCommandHandler as Bn, UpdateOneOptions as Bt, PongoCacheType as C, pongoSchema as Cn, PongoFilter as Ct, LRUCacheOptions as D, toDbSchemaMetadata as Dn, PongoInsertOneResult as Dt, noopCacheProvider as E, toClientSchemaMetadata as En, PongoInsertManyResult as Et, AlternativeType as F, PongoCollectionURNType as Fn, RegExpOrString as Ft, DocumentHandler as G, NonPartial as Gn, WithoutIdAndVersion as Gt, DeleteManyOptions as H, DocumentCommandHandlerOptions as Hn, WithIdAndVersion as Ht, AnyPongoDb as I, PongoCollectionSQLBuilder as In, ReplaceManyOptions as It, ExpectedDocumentVersionGeneral as J, expectedVersionPredicate as Jt, EnhancedOmit as K, objectEntries as Kn, WithoutVersion as Kt, BatchHandleOptions as L, PongoCollectionOptions as Ln, ReplaceOneOptions as Lt, $push as M, PongoCollectionSchemaComponent as Mn, PongoUpdate as Mt, $set as N, PongoCollectionSchemaComponentOptions as Nn, PongoUpdateManyResult as Nt, lruCache as O, OperatorMap as On, PongoMigrationOptions as Ot, $unset as P, PongoCollectionURN as Pn, PongoUpdateResult as Pt, HandleOptions as Q, AnyPongoDriver as Qt, CollectionOperationOptions as R, pongoCollection as Rn, RootFilterOperators as Rt, PongoCacheSetEntry as S, PongoSchemaConfig as Sn, PongoDocument as St, pongoCache as T, proxyPongoDbWithSchema as Tn, PongoHandleResult as Tt, DeleteOneOptions as U, getIdsFromIdOnlyFilter as Un, WithVersion as Ut, DOCUMENT_EXISTS as V, DocumentCommandHandlerInput as Vn, WithId as Vt, Document as W, idFromFilter as Wn, WithoutId as Wt, ExpectedVersionPredicate as X, isGeneralExpectedDocumentVersion as Xt, ExpectedDocumentVersionValue as Y, expectedVersionValue as Yt, FindOptions as Z, operationResult as Zt, CacheHooks as _, PongoCollectionSchema as _n, PongoDb as _t, ConcurrencyError as a, PongoDriverRegistry as an, ObjectId as at, CacheType as b, PongoDbSchemaMetadata as bn, PongoDeleteManyResult as bt, isString as c, PongoDatabaseSchemaComponent as cn, OptionalId as ct, PongoDatabaseCache as d, PongoDatabaseURNType as dn, OptionalUnlessRequiredVersion as dt, ExtractPongoDatabaseTypeFromDriver as en, InferIdType as et, PongoTransactionCache as f, CollectionsMap as fn, OptionalVersion as ft, CacheConfig as g, PongoClientWithSchema as gn, PongoDBCollectionOptions as gt, pongoCacheWrapper as h, PongoClientSchemaMetadata as hn, PongoCollection as ht, pongoClient as i, PongoDriverOptions as in, NonObjectIdLikeDocument as it, $inc as j, isOperator as jn, PongoTransactionOptions as jt, identityMapCache as k, QueryOperators as kn, PongoReplaceManyResult as kt, PongoDatabase as l, PongoDatabaseSchemaComponentOptions as ln, OptionalUnlessRequiredId as lt, pongoTransactionCache as m, PongoClientSchema as mn, PongoClientOptions as mt, PongoSessionOptions as n, PongoDatabaseFactoryOptions as nn, InsertOneOptions as nt, PongoError as o, pongoDriverRegistry as on, ObjectIdLike as ot, PongoTransactionCacheOperationOptions as p, DBsMap as pn, PongoClient as pt, ExpectedDocumentVersion as q, expectedVersion as qt, pongoSession as r, PongoDriver as rn, NO_CONCURRENCY_CHECK as rt, isNumber as s, PongoDatabaseSQLBuilder as sn, OperationResult as st, pongoTransaction as t, ExtractPongoDriverOptions as tn, InsertManyOptions as tt, PongoDatabaseOptions as u, PongoDatabaseURN as un, OptionalUnlessRequiredIdAndVersion as ut, CacheOptions as v, PongoCollectionSchemaMetadata as vn, PongoDbOptions as vt, PongoDocumentCacheKey as w, proxyClientWithSchema as wn, PongoFilterOperator as wt, PongoCache as x, PongoDbWithSchema as xn, PongoDeleteResult as xt, CacheSettings as y, PongoDbSchema as yn, PongoDbTransaction as yt, Condition as z, transactionExecutorOrDefault as zn, UpdateManyOptions as zt };
+//# sourceMappingURL=index-r7V4paf_.d.ts.map