@event-driven-io/pongo 0.17.0-beta.35 → 0.17.0-beta.36

package/dist/index-DMq6F3x9.d.ts

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