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

package/dist/pongoTransactionCache-BsigBOq1.d.ts

@@ -1,556 +0,0 @@
-import { JSONSerializer, SQL, SchemaComponent, DatabaseDriverType, SchemaComponentOptions, JSONSerializationOptions, MigrationStyle, WithDatabaseTransactionFactory, AnyConnection, DatabaseTransaction, SQLExecutor, RunSQLMigrationsResult, QueryResultRow, QueryResult, SQLQueryOptions, SQLCommandOptions } from '@event-driven-io/dumbo';
-import { LRUCache } from 'lru-cache';
-
-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>[]>;
-};
-
-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;
-};
-
-type PongoCollectionURNType = 'sc:pongo:collection';
-type PongoCollectionURN = `${PongoCollectionURNType}:${string}`;
-type PongoCollectionSchemaComponentOptions<DriverType extends DatabaseDriverType = DatabaseDriverType> = Readonly<{
-    driverType: DriverType;
-    definition: PongoCollectionSchema;
-    migrationsOrSchemaComponents: SchemaComponentOptions;
-    sqlBuilder: PongoCollectionSQLBuilder;
-}>;
-type PongoCollectionSchemaComponent = SchemaComponent<PongoCollectionURN> & {
-    collectionName: string;
-    definition: PongoCollectionSchema;
-    sqlBuilder: PongoCollectionSQLBuilder;
-};
-declare const PongoCollectionSchemaComponent: <DriverType extends DatabaseDriverType = DatabaseDriverType>({ definition, migrationsOrSchemaComponents, sqlBuilder, }: PongoCollectionSchemaComponentOptions<DriverType>) => PongoCollectionSchemaComponent;
-
-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;
-}
-
-type PongoDatabaseURNType = 'sc:dumbo:database';
-type PongoDatabaseURN = `${PongoDatabaseURNType}:${string}`;
-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;
-}>;
-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;
-};
-declare const PongoDatabaseSchemaComponent: <DriverType extends DatabaseDriverType = DatabaseDriverType>({ definition, collectionFactory, }: PongoDatabaseSchemaComponentOptions<DriverType>) => PongoDatabaseSchemaComponent;
-type PongoDatabaseSQLBuilder<DriverType extends DatabaseDriverType = DatabaseDriverType> = {
-    driverType: DriverType;
-    collection: PongoCollectionSQLBuilder;
-};
-
-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[];
-};
-
-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;
-} & 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) => T | null) | ((document: T | null) => Promise<T | null>);
-
-type MaybePromise<T> = T | PromiseLike<T>;
-
-type LRUCacheOptions = Omit<LRUCache.Options<string, {
-    doc: PongoDocument | null;
-}, unknown>, 'max'> & {
-    max?: number;
-};
-declare const lruCache: (options?: LRUCacheOptions) => PongoCache;
-
-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;
-
-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;
-
-export { type $inc as $, type AnyPongoDb as A, type BatchHandleOptions as B, type CacheConfig as C, type CacheOptions as D, type ExtractPongoDatabaseTypeFromDriver as E, type CacheSettings as F, type CacheType as G, type CollectionsMap as H, type Condition as I, type DBsMap as J, DOCUMENT_DOES_NOT_EXIST as K, DOCUMENT_EXISTS as L, type DeleteManyOptions as M, type DeleteOneOptions as N, type Document as O, type PongoDriver as P, DocumentCommandHandler as Q, type DocumentCommandHandlerInput as R, type DocumentCommandHandlerOptions as S, type DocumentHandler as T, type EnhancedOmit as U, type ExpectedDocumentVersion as V, type ExpectedDocumentVersionGeneral as W, type ExpectedDocumentVersionValue as X, type ExtractPongoDriverOptions as Y, type FindOptions as Z, type HandleOptions as _, type PongoDb as a, lruCache as a$, type HasId as a0, type InferIdType as a1, type InsertManyOptions as a2, type InsertOneOptions as a3, type LRUCacheOptions as a4, type MaybePromise as a5, NO_CONCURRENCY_CHECK as a6, type NonObjectIdLikeDocument as a7, ObjectId as a8, type ObjectIdLike as a9, type PongoFilterOperator as aA, type PongoHandleResult as aB, type PongoInsertManyResult as aC, type PongoInsertOneResult as aD, type PongoMigrationOptions as aE, type PongoReplaceManyResult as aF, type PongoSchemaConfig as aG, type PongoTransactionCache as aH, type PongoTransactionCacheOperationOptions as aI, type PongoUpdate as aJ, type PongoUpdateManyResult as aK, type PongoUpdateResult as aL, type RegExpOrString as aM, type ReplaceManyOptions as aN, type ReplaceOneOptions as aO, type RootFilterOperators as aP, type UpdateManyOptions as aQ, type UpdateOneOptions as aR, type WithId as aS, type WithIdAndVersion as aT, type WithVersion as aU, type WithoutId as aV, type WithoutIdAndVersion as aW, type WithoutVersion as aX, expectedVersion as aY, expectedVersionValue as aZ, isGeneralExpectedDocumentVersion as a_, type OperationResult as aa, type OptionalId as ab, type OptionalUnlessRequiredId as ac, type OptionalUnlessRequiredIdAndVersion as ad, type OptionalUnlessRequiredVersion as ae, type OptionalVersion as af, type PongoCacheSetEntry as ag, type PongoCacheType as ah, type PongoClientSchemaMetadata as ai, type PongoCollectionSQLBuilder as aj, type PongoCollectionSchemaComponentOptions as ak, type PongoCollectionSchemaMetadata as al, type PongoCollectionURN as am, type PongoCollectionURNType as an, type PongoDBCollectionOptions as ao, type PongoDatabaseSQLBuilder as ap, type PongoDatabaseSchemaComponentOptions as aq, type PongoDatabaseURN as ar, type PongoDatabaseURNType as as, type PongoDbOptions as at, type PongoDbSchemaMetadata as au, type PongoDbWithSchema as av, type PongoDeleteManyResult as aw, type PongoDeleteResult as ax, type PongoDocumentCacheKey as ay, PongoDriverRegistry as az, type PongoDriverOptions as b, operationResult as b0, pongoCache as b1, pongoDriverRegistry as b2, pongoSchema as b3, pongoTransactionCache as b4, proxyClientWithSchema as b5, proxyPongoDbWithSchema as b6, toClientSchemaMetadata as b7, toDbSchemaMetadata as b8, type PongoFilter as c, type PongoDocument as d, PongoCollectionSchemaComponent as e, type PongoCache as f, type PongoCollection as g, type CollectionOperationOptions as h, type CacheHooks as i, type PongoClientSchema as j, type PongoCollectionSchema as k, type PongoDatabaseFactoryOptions as l, PongoDatabaseSchemaComponent as m, type PongoDbSchema as n, type AnyPongoDriver as o, type PongoClientOptions as p, type PongoClient as q, type PongoClientWithSchema as r, type PongoTransactionOptions as s, type PongoSession as t, type PongoDbTransaction as u, type $push as v, type $set as w, type $unset as x, type AlternativeType as y, type AnyPongoDriverOptions as z };