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

package/dist/index.cjs

@@ -1,124 +1,67 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_core = require('./core-CwxxuUAn.cjs');
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkEQ3T4XHTcjs = require('./chunk-EQ3T4XHT.cjs');
-
-// src/index.ts
+//#region src/index.ts
 pongoDriverRegistry.register(`PostgreSQL:pg`, () => loadPongoClient("pg"));
-pongoDriverRegistry.register(
-  `SQLite:sqlite3`,
-  () => loadPongoClient("sqlite3")
-);
+pongoDriverRegistry.register(`SQLite:sqlite3`, () => loadPongoClient("sqlite3"));
 pongoDriverRegistry.register(`SQLite:d1`, () => loadPongoClient("d1"));
-var loadPongoClient = async (path) => {
-  let module;
-  if (path === "pg") {
-    module = await Promise.resolve().then(() => _interopRequireWildcard(require("./pg.cjs")));
-  } else if (path === "sqlite3") {
-    module = await Promise.resolve().then(() => _interopRequireWildcard(require("./sqlite3.cjs")));
-  } else if (path === "d1") {
-    module = await Promise.resolve().then(() => _interopRequireWildcard(require("./cloudflare.cjs")));
-  } else {
-    throw new Error(`Unknown path: ${path}`);
-  }
-  if (!module.pongoDriver) {
-    throw new Error(`Failed to load Pongo client for ${path}`);
-  }
-  return module.pongoDriver;
+const loadPongoClient = async (path) => {
+	let module;
+	if (path === "pg") module = await Promise.resolve().then(() => require("./pg.cjs"));
+	else if (path === "sqlite3") module = await Promise.resolve().then(() => require("./sqlite3.cjs"));
+	else if (path === "d1") module = await Promise.resolve().then(() => require("./cloudflare.cjs"));
+	else throw new Error(`Unknown path: ${path}`);
+	if (!module.pongoDriver) throw new Error(`Failed to load Pongo client for ${path}`);
+	return module.pongoDriver;
 };
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.ConcurrencyError = _chunkEQ3T4XHTcjs.ConcurrencyError; exports.DOCUMENT_DOES_NOT_EXIST = _chunkEQ3T4XHTcjs.DOCUMENT_DOES_NOT_EXIST; exports.DOCUMENT_EXISTS = _chunkEQ3T4XHTcjs.DOCUMENT_EXISTS; exports.DocumentCommandHandler = _chunkEQ3T4XHTcjs.DocumentCommandHandler; exports.NO_CONCURRENCY_CHECK = _chunkEQ3T4XHTcjs.NO_CONCURRENCY_CHECK; exports.ObjectId = _chunkEQ3T4XHTcjs.ObjectId; exports.OperatorMap = _chunkEQ3T4XHTcjs.OperatorMap; exports.PongoCollectionSchemaComponent = _chunkEQ3T4XHTcjs.PongoCollectionSchemaComponent; exports.PongoDatabase = _chunkEQ3T4XHTcjs.PongoDatabase; exports.PongoDatabaseCache = _chunkEQ3T4XHTcjs.PongoDatabaseCache; exports.PongoDatabaseSchemaComponent = _chunkEQ3T4XHTcjs.PongoDatabaseSchemaComponent; exports.PongoDriverRegistry = _chunkEQ3T4XHTcjs.PongoDriverRegistry; exports.PongoError = _chunkEQ3T4XHTcjs.PongoError; exports.QueryOperators = _chunkEQ3T4XHTcjs.QueryOperators; exports.deepEquals = _chunkEQ3T4XHTcjs.deepEquals; exports.expectedVersion = _chunkEQ3T4XHTcjs.expectedVersion; exports.expectedVersionValue = _chunkEQ3T4XHTcjs.expectedVersionValue; exports.getIdsFromIdOnlyFilter = _chunkEQ3T4XHTcjs.getIdsFromIdOnlyFilter; exports.hasOperators = _chunkEQ3T4XHTcjs.hasOperators; exports.idFromFilter = _chunkEQ3T4XHTcjs.idFromFilter; exports.identityMapCache = _chunkEQ3T4XHTcjs.identityMapCache; exports.isEquatable = _chunkEQ3T4XHTcjs.isEquatable; exports.isGeneralExpectedDocumentVersion = _chunkEQ3T4XHTcjs.isGeneralExpectedDocumentVersion; exports.isNumber = _chunkEQ3T4XHTcjs.isNumber; exports.isOperator = _chunkEQ3T4XHTcjs.isOperator; exports.isString = _chunkEQ3T4XHTcjs.isString; exports.loadPongoClient = loadPongoClient; exports.lruCache = _chunkEQ3T4XHTcjs.lruCache; exports.mapAsync = _chunkEQ3T4XHTcjs.mapAsync; exports.mapParallel = _chunkEQ3T4XHTcjs.mapParallel; exports.mapSequential = _chunkEQ3T4XHTcjs.mapSequential; exports.noopCacheProvider = _chunkEQ3T4XHTcjs.noopCacheProvider; exports.objectEntries = _chunkEQ3T4XHTcjs.objectEntries; exports.operationResult = _chunkEQ3T4XHTcjs.operationResult; exports.pongoCache = _chunkEQ3T4XHTcjs.pongoCache; exports.pongoCacheWrapper = _chunkEQ3T4XHTcjs.pongoCacheWrapper; exports.pongoClient = _chunkEQ3T4XHTcjs.pongoClient; exports.pongoCollection = _chunkEQ3T4XHTcjs.pongoCollection; exports.pongoDriverRegistry = _chunkEQ3T4XHTcjs.pongoDriverRegistry; exports.pongoSchema = _chunkEQ3T4XHTcjs.pongoSchema; exports.pongoSession = _chunkEQ3T4XHTcjs.pongoSession; exports.pongoTransaction = _chunkEQ3T4XHTcjs.pongoTransaction; exports.pongoTransactionCache = _chunkEQ3T4XHTcjs.pongoTransactionCache; exports.proxyClientWithSchema = _chunkEQ3T4XHTcjs.proxyClientWithSchema; exports.proxyPongoDbWithSchema = _chunkEQ3T4XHTcjs.proxyPongoDbWithSchema; exports.toClientSchemaMetadata = _chunkEQ3T4XHTcjs.toClientSchemaMetadata; exports.toDbSchemaMetadata = _chunkEQ3T4XHTcjs.toDbSchemaMetadata; exports.transactionExecutorOrDefault = _chunkEQ3T4XHTcjs.transactionExecutorOrDefault;
+//#endregion
+exports.ConcurrencyError = require_core.ConcurrencyError;
+exports.DOCUMENT_DOES_NOT_EXIST = require_core.DOCUMENT_DOES_NOT_EXIST;
+exports.DOCUMENT_EXISTS = require_core.DOCUMENT_EXISTS;
+exports.DocumentCommandHandler = require_core.DocumentCommandHandler;
+exports.NO_CONCURRENCY_CHECK = require_core.NO_CONCURRENCY_CHECK;
+exports.ObjectId = require_core.ObjectId;
+exports.OperatorMap = require_core.OperatorMap;
+exports.PongoCollectionSchemaComponent = require_core.PongoCollectionSchemaComponent;
+exports.PongoDatabase = require_core.PongoDatabase;
+exports.PongoDatabaseCache = require_core.PongoDatabaseCache;
+exports.PongoDatabaseSchemaComponent = require_core.PongoDatabaseSchemaComponent;
+exports.PongoDriverRegistry = require_core.PongoDriverRegistry;
+exports.PongoError = require_core.PongoError;
+exports.QueryOperators = require_core.QueryOperators;
+exports.deepEquals = require_core.deepEquals;
+exports.expectedVersion = require_core.expectedVersion;
+exports.expectedVersionValue = require_core.expectedVersionValue;
+exports.getIdsFromIdOnlyFilter = require_core.getIdsFromIdOnlyFilter;
+exports.hasOperators = require_core.hasOperators;
+exports.idFromFilter = require_core.idFromFilter;
+exports.identityMapCache = require_core.identityMapCache;
+exports.isEquatable = require_core.isEquatable;
+exports.isGeneralExpectedDocumentVersion = require_core.isGeneralExpectedDocumentVersion;
+exports.isNumber = require_core.isNumber;
+exports.isOperator = require_core.isOperator;
+exports.isString = require_core.isString;
+exports.loadPongoClient = loadPongoClient;
+exports.lruCache = require_core.lruCache;
+exports.mapAsync = require_core.mapAsync;
+exports.mapParallel = require_core.mapParallel;
+exports.mapSequential = require_core.mapSequential;
+exports.noopCacheProvider = require_core.noopCacheProvider;
+exports.objectEntries = require_core.objectEntries;
+exports.operationResult = require_core.operationResult;
+exports.pongoCache = require_core.pongoCache;
+exports.pongoCacheWrapper = require_core.pongoCacheWrapper;
+exports.pongoClient = require_core.pongoClient;
+exports.pongoCollection = require_core.pongoCollection;
+exports.pongoDriverRegistry = require_core.pongoDriverRegistry;
+exports.pongoSchema = require_core.pongoSchema;
+exports.pongoSession = require_core.pongoSession;
+exports.pongoTransaction = require_core.pongoTransaction;
+exports.pongoTransactionCache = require_core.pongoTransactionCache;
+exports.proxyClientWithSchema = require_core.proxyClientWithSchema;
+exports.proxyPongoDbWithSchema = require_core.proxyPongoDbWithSchema;
+exports.toClientSchemaMetadata = require_core.toClientSchemaMetadata;
+exports.toDbSchemaMetadata = require_core.toDbSchemaMetadata;
+exports.transactionExecutorOrDefault = require_core.transactionExecutorOrDefault;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/Pongo/Pongo/src/packages/pongo/dist/index.cjs","../src/index.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACA;AC9CA,mBAAA,CAAoB,QAAA,CAAS,CAAA,aAAA,CAAA,EAAiB,CAAA,EAAA,GAAM,eAAA,CAAgB,IAAI,CAAC,CAAA;AACzE,mBAAA,CAAoB,QAAA;AAAA,EAAS,CAAA,cAAA,CAAA;AAAA,EAAkB,CAAA,EAAA,GAC7C,eAAA,CAAgB,SAAS;AAC3B,CAAA;AACA,mBAAA,CAAoB,QAAA,CAAS,CAAA,SAAA,CAAA,EAAa,CAAA,EAAA,GAAM,eAAA,CAAgB,IAAI,CAAC,CAAA;AAE9D,IAAM,gBAAA,EAAkB,MAAA,CAC7B,IAAA,EAAA,GAC4B;AAC5B,EAAA,IAAI,MAAA;AAEJ,EAAA,GAAA,CAAI,KAAA,IAAS,IAAA,EAAM;AACjB,IAAA,OAAA,EAAS,MAAM,4DAAA,CAAO,UAAM,GAAA;AAAA,EAC9B,EAAA,KAAA,GAAA,CAAW,KAAA,IAAS,SAAA,EAAW;AAC7B,IAAA,OAAA,EAAS,MAAM,4DAAA,CAAO,eAAW,GAAA;AAAA,EACnC,EAAA,KAAA,GAAA,CAAW,KAAA,IAAS,IAAA,EAAM;AACxB,IAAA,OAAA,EAAS,MAAM,4DAAA,CAAO,kBAAc,GAAA;AAAA,EACtC,EAAA,KAAO;AAEL,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,cAAA,EAAiB,IAAI,CAAA,CAAA;AACvC,EAAA;AAEyB,EAAA;AACP,IAAA;AAClB,EAAA;AAEc,EAAA;AAChB;AD0C0C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"/home/runner/work/Pongo/Pongo/src/packages/pongo/dist/index.cjs","sourcesContent":[null,"import type { AnyPongoDriver } from './core';\n\nexport * from './core';\n\npongoDriverRegistry.register(`PostgreSQL:pg`, () => loadPongoClient('pg'));\npongoDriverRegistry.register(`SQLite:sqlite3`, () =>\n  loadPongoClient('sqlite3'),\n);\npongoDriverRegistry.register(`SQLite:d1`, () => loadPongoClient('d1'));\n\nexport const loadPongoClient = async (\n  path: 'pg' | 'sqlite3' | 'd1',\n): Promise<AnyPongoDriver> => {\n  let module;\n\n  if (path === 'pg') {\n    module = await import('./pg');\n  } else if (path === 'sqlite3') {\n    module = await import('./sqlite3');\n  } else if (path === 'd1') {\n    module = await import('./cloudflare');\n  } else {\n    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n    throw new Error(`Unknown path: ${path}`);\n  }\n\n  if (!module.pongoDriver) {\n    throw new Error(`Failed to load Pongo client for ${path}`);\n  }\n\n  return module.pongoDriver;\n};\n"]}
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { AnyPongoDriver } from './core';\n\nexport * from './core';\n\npongoDriverRegistry.register(`PostgreSQL:pg`, () => loadPongoClient('pg'));\npongoDriverRegistry.register(`SQLite:sqlite3`, () =>\n  loadPongoClient('sqlite3'),\n);\npongoDriverRegistry.register(`SQLite:d1`, () => loadPongoClient('d1'));\n\nexport const loadPongoClient = async (\n  path: 'pg' | 'sqlite3' | 'd1',\n): Promise<AnyPongoDriver> => {\n  let module;\n\n  if (path === 'pg') {\n    module = await import('./pg');\n  } else if (path === 'sqlite3') {\n    module = await import('./sqlite3');\n  } else if (path === 'd1') {\n    module = await import('./cloudflare');\n  } else {\n    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n    throw new Error(`Unknown path: ${path}`);\n  }\n\n  if (!module.pongoDriver) {\n    throw new Error(`Failed to load Pongo client for ${path}`);\n  }\n\n  return module.pongoDriver;\n};\n"],"mappings":";;;;AAIA,oBAAoB,SAAS,uBAAuB,gBAAgB,KAAK,CAAC;AAC1E,oBAAoB,SAAS,wBAC3B,gBAAgB,UAAU,CAC3B;AACD,oBAAoB,SAAS,mBAAmB,gBAAgB,KAAK,CAAC;AAEtE,MAAa,kBAAkB,OAC7B,SAC4B;CAC5B,IAAI;AAEJ,KAAI,SAAS,KACX,UAAS,2CAAM;UACN,SAAS,UAClB,UAAS,2CAAM;UACN,SAAS,KAClB,UAAS,2CAAM;KAGf,OAAM,IAAI,MAAM,iBAAiB,OAAO;AAG1C,KAAI,CAAC,OAAO,YACV,OAAM,IAAI,MAAM,mCAAmC,OAAO;AAG5D,QAAO,OAAO"}

package/dist/index.d.cts

@@ -1,140 +1,21 @@
-import { c as PongoFilter, d as PongoDocument, a as PongoDb, e as PongoCollectionSchemaComponent, C as CacheConfig, f as PongoCache, g as PongoCollection, h as CollectionOperationOptions, i as CacheHooks, j as PongoClientSchema, P as PongoDriver, k as PongoCollectionSchema, l as PongoDatabaseFactoryOptions, A as AnyPongoDb, m as PongoDatabaseSchemaComponent, n as PongoDbSchema, o as AnyPongoDriver, p as PongoClientOptions, q as PongoClient, E as ExtractPongoDatabaseTypeFromDriver, r as PongoClientWithSchema, s as PongoTransactionOptions, t as PongoSession, u as PongoDbTransaction } from './pongoTransactionCache-CRuPGag3.cjs';
-export { $ as $inc, v as $push, w as $set, x as $unset, y as AlternativeType, z as AnyPongoDriverOptions, B as BatchHandleOptions, D as CacheOptions, F as CacheSettings, G as CacheType, H as CollectionsMap, I as Condition, J as DBsMap, K as DOCUMENT_DOES_NOT_EXIST, L as DOCUMENT_EXISTS, M as DeleteManyOptions, N as DeleteOneOptions, O as Document, Q as DocumentCommandHandler, R as DocumentCommandHandlerInput, S as DocumentCommandHandlerOptions, T as DocumentHandler, U as EnhancedOmit, V as ExpectedDocumentVersion, W as ExpectedDocumentVersionGeneral, X as ExpectedDocumentVersionValue, Y as ExtractPongoDriverOptions, Z as FindOptions, _ as HandleOptions, a0 as HasId, a1 as InferIdType, a2 as InsertManyOptions, a3 as InsertOneOptions, a4 as LRUCacheOptions, a5 as MaybePromise, a6 as NO_CONCURRENCY_CHECK, a7 as NonObjectIdLikeDocument, a8 as ObjectId, a9 as ObjectIdLike, aa as OperationResult, ab as OptionalId, ac as OptionalUnlessRequiredId, ad as OptionalUnlessRequiredIdAndVersion, ae as OptionalUnlessRequiredVersion, af as OptionalVersion, ag as PongoCacheSetEntry, ah as PongoCacheType, ai as PongoClientSchemaMetadata, aj as PongoCollectionSQLBuilder, ak as PongoCollectionSchemaComponentOptions, al as PongoCollectionSchemaMetadata, am as PongoCollectionURN, an as PongoCollectionURNType, ao as PongoDBCollectionOptions, ap as PongoDatabaseSQLBuilder, aq as PongoDatabaseSchemaComponentOptions, ar as PongoDatabaseURN, as as PongoDatabaseURNType, at as PongoDbOptions, au as PongoDbSchemaMetadata, av as PongoDbWithSchema, aw as PongoDeleteManyResult, ax as PongoDeleteResult, ay as PongoDocumentCacheKey, b as PongoDriverOptions, az as PongoDriverRegistry, aA as PongoFilterOperator, aB as PongoHandleResult, aC as PongoInsertManyResult, aD as PongoInsertOneResult, aE as PongoMigrationOptions, aF as PongoReplaceManyResult, aG as PongoSchemaConfig, aH as PongoTransactionCache, aI as PongoTransactionCacheOperationOptions, aJ as PongoUpdate, aK as PongoUpdateManyResult, aL as PongoUpdateResult, aM as RegExpOrString, aN as ReplaceManyOptions, aO as ReplaceOneOptions, aP as RootFilterOperators, aQ as UpdateManyOptions, aR as UpdateOneOptions, aS as WithId, aT as WithIdAndVersion, aU as WithVersion, aV as WithoutId, aW as WithoutIdAndVersion, aX as WithoutVersion, aY as expectedVersion, aZ as expectedVersionValue, a_ as isGeneralExpectedDocumentVersion, a$ as lruCache, b0 as operationResult, b1 as pongoCache, b2 as pongoDriverRegistry, b3 as pongoSchema, b4 as pongoTransactionCache, b5 as proxyClientWithSchema, b6 as proxyPongoDbWithSchema, b7 as toClientSchemaMetadata, b8 as toDbSchemaMetadata } from './pongoTransactionCache-CRuPGag3.cjs';
-import { SQL, DatabaseDriverType, Dumbo, MigrationStyle, JSONSerializer, SQLExecutor, JSONSerializationOptions } from '@event-driven-io/dumbo';
-import 'lru-cache';
-
-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];
-};
-
-declare const idFromFilter: <T>(filter: PongoFilter<T> | SQL | undefined) => string | undefined;
-declare const getIdsFromIdOnlyFilter: <T>(filter: PongoFilter<T> | SQL | undefined) => string[] | undefined;
-
-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>;
-
-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;
-
-declare const identityMapCache: () => PongoCache;
-
-declare const noopCacheProvider: PongoCache;
-
-declare const pongoCacheWrapper: (options: {
-    provider: PongoCache;
-    hooks?: CacheHooks;
-}) => PongoCache;
-
-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[]>;
-};
-
-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;
-
-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);
-}
-
-declare const pongoClient: <DatabaseDriver extends AnyPongoDriver, TypedClientSchema extends PongoClientSchema = PongoClientSchema>(options: PongoClientOptions<DatabaseDriver, TypedClientSchema>) => PongoClient<DatabaseDriver["driverType"], ExtractPongoDatabaseTypeFromDriver<DatabaseDriver>> & PongoClientWithSchema<TypedClientSchema>;
-
-type PongoSessionOptions = {
-    explicit?: boolean;
-    defaultTransactionOptions: PongoTransactionOptions;
-    cache?: CacheConfig | 'disabled' | PongoCache;
-};
-declare const pongoSession: (options?: PongoSessionOptions) => PongoSession;
-
-declare const pongoTransaction: (options: PongoTransactionOptions) => PongoDbTransaction;
+import { $ as InferIdType, $t as ExtractPongoDriverOptions, A as MaybePromise, An as PongoCollectionSchemaComponent, At as PongoTransactionOptions, B as DOCUMENT_DOES_NOT_EXIST, Bn as DocumentCommandHandlerOptions, Bt as WithId, C as PongoCacheType, Cn as proxyPongoDbWithSchema, Ct as PongoFilterOperator, D as LRUCacheOptions, Dn as QueryOperators, Dt as PongoMigrationOptions, E as noopCacheProvider, En as OperatorMap, Et as PongoInsertOneResult, F as AlternativeType, Fn as PongoCollectionOptions, Ft as ReplaceManyOptions, G as DocumentHandler, Gt as WithoutVersion, H as DeleteManyOptions, Hn as idFromFilter, Ht as WithVersion, I as AnyPongoDb, In as pongoCollection, It as ReplaceOneOptions, J as ExpectedDocumentVersionGeneral, Jt as isGeneralExpectedDocumentVersion, K as EnhancedOmit, Kt as expectedVersion, L as BatchHandleOptions, Ln as transactionExecutorOrDefault, Lt as RootFilterOperators, M as $push, Mn as PongoCollectionURN, Mt as PongoUpdateManyResult, N as $set, Nn as PongoCollectionURNType, Nt as PongoUpdateResult, O as lruCache, On as hasOperators, Ot as PongoReplaceManyResult, P as $unset, Pn as PongoCollectionSQLBuilder, Pt as RegExpOrString, Q as HasId, Qt as ExtractPongoDatabaseTypeFromDriver, R as CollectionOperationOptions, Rn as DocumentCommandHandler, Rt as UpdateManyOptions, S as PongoCacheSetEntry, Sn as proxyClientWithSchema, St as PongoFilter, T as pongoCache, Tn as toDbSchemaMetadata, Tt as PongoInsertManyResult, U as DeleteOneOptions, Un as NonPartial, Ut as WithoutId, V as DOCUMENT_EXISTS, Vn as getIdsFromIdOnlyFilter, Vt as WithIdAndVersion, W as Document, Wn as objectEntries, Wt as WithoutIdAndVersion, X as FindOptions, Xt as AnyPongoDriver, Y as ExpectedDocumentVersionValue, Yt as operationResult, Z as HandleOptions, Zt as AnyPongoDriverOptions, _ as CacheHooks, _n as PongoDbSchema, _t as PongoDbOptions, a as ConcurrencyError, an as PongoDatabaseSQLBuilder, at as ObjectIdLike, b as CacheType, bn as PongoSchemaConfig, bt as PongoDeleteResult, c as isString, cn as PongoDatabaseURN, ct as OptionalUnlessRequiredId, d as PongoDatabaseCache, dn as DBsMap, dt as OptionalVersion, en as PongoDatabaseFactoryOptions, et as InsertManyOptions, f as PongoTransactionCache, fn as PongoClientSchema, ft as PongoClient, g as CacheConfig, gn as PongoCollectionSchemaMetadata, gt as PongoDb, h as pongoCacheWrapper, hn as PongoCollectionSchema, ht as PongoDBCollectionOptions, i as pongoClient, in as pongoDriverRegistry, it as ObjectId, j as $inc, jn as PongoCollectionSchemaComponentOptions, jt as PongoUpdate, k as identityMapCache, kn as isOperator, kt as PongoSession, l as PongoDatabase, ln as PongoDatabaseURNType, lt as OptionalUnlessRequiredIdAndVersion, m as pongoTransactionCache, mn as PongoClientWithSchema, mt as PongoCollection, n as PongoSessionOptions, nn as PongoDriverOptions, nt as NO_CONCURRENCY_CHECK, o as PongoError, on as PongoDatabaseSchemaComponent, ot as OperationResult, p as PongoTransactionCacheOperationOptions, pn as PongoClientSchemaMetadata, pt as PongoClientOptions, q as ExpectedDocumentVersion, qt as expectedVersionValue, r as pongoSession, rn as PongoDriverRegistry, rt as NonObjectIdLikeDocument, s as isNumber, sn as PongoDatabaseSchemaComponentOptions, st as OptionalId, t as pongoTransaction, tn as PongoDriver, tt as InsertOneOptions, u as PongoDatabaseOptions, un as CollectionsMap, ut as OptionalUnlessRequiredVersion, v as CacheOptions, vn as PongoDbSchemaMetadata, vt as PongoDbTransaction, w as PongoDocumentCacheKey, wn as toClientSchemaMetadata, wt as PongoHandleResult, x as PongoCache, xn as pongoSchema, xt as PongoDocument, y as CacheSettings, yn as PongoDbWithSchema, yt as PongoDeleteManyResult, z as Condition, zn as DocumentCommandHandlerInput, zt as UpdateOneOptions } from "./index-qeC-p0Tq.cjs";
 
+//#region src/core/utils/deepEquals.d.ts
 declare const deepEquals: <T>(left: T, right: T) => boolean;
 type Equatable<T> = {
-    equals: (right: T) => boolean;
+  equals: (right: T) => boolean;
 } & T;
 declare const isEquatable: <T>(left: T) => left is Equatable<T>;
-
+//#endregion
+//#region src/core/utils/mapAsync.d.ts
 declare function mapSequential<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
 declare const mapParallel: <T, R>(items: T[], fn: (item: T, index: number) => Promise<R>) => Promise<R[]>;
 declare const mapAsync: <T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, options?: {
-    parallel: boolean | undefined;
+  parallel: boolean | undefined;
 }) => Promise<R[]>;
-
+//#endregion
+//#region src/index.d.ts
 declare const loadPongoClient: (path: "pg" | "sqlite3" | "d1") => Promise<AnyPongoDriver>;
-
-export { AnyPongoDb, AnyPongoDriver, CacheConfig, CacheHooks, CollectionOperationOptions, ConcurrencyError, type Equatable, ExtractPongoDatabaseTypeFromDriver, type NonPartial, OperatorMap, PongoCache, PongoClient, PongoClientOptions, PongoClientSchema, PongoClientWithSchema, PongoCollection, type PongoCollectionOptions, PongoCollectionSchema, PongoCollectionSchemaComponent, PongoDatabase, PongoDatabaseCache, PongoDatabaseFactoryOptions, type PongoDatabaseOptions, PongoDatabaseSchemaComponent, PongoDb, PongoDbSchema, PongoDbTransaction, PongoDocument, PongoDriver, PongoError, PongoFilter, PongoSession, type PongoSessionOptions, PongoTransactionOptions, QueryOperators, deepEquals, getIdsFromIdOnlyFilter, hasOperators, idFromFilter, identityMapCache, isEquatable, isNumber, isOperator, isString, loadPongoClient, mapAsync, mapParallel, mapSequential, noopCacheProvider, objectEntries, pongoCacheWrapper, pongoClient, pongoCollection, pongoSession, pongoTransaction, transactionExecutorOrDefault };
+//#endregion
+export { $inc, $push, $set, $unset, AlternativeType, AnyPongoDb, AnyPongoDriver, AnyPongoDriverOptions, BatchHandleOptions, CacheConfig, CacheHooks, CacheOptions, CacheSettings, CacheType, CollectionOperationOptions, CollectionsMap, ConcurrencyError, Condition, DBsMap, DOCUMENT_DOES_NOT_EXIST, DOCUMENT_EXISTS, DeleteManyOptions, DeleteOneOptions, Document, DocumentCommandHandler, DocumentCommandHandlerInput, DocumentCommandHandlerOptions, DocumentHandler, EnhancedOmit, Equatable, ExpectedDocumentVersion, ExpectedDocumentVersionGeneral, ExpectedDocumentVersionValue, ExtractPongoDatabaseTypeFromDriver, ExtractPongoDriverOptions, FindOptions, HandleOptions, HasId, InferIdType, InsertManyOptions, InsertOneOptions, LRUCacheOptions, MaybePromise, NO_CONCURRENCY_CHECK, NonObjectIdLikeDocument, NonPartial, ObjectId, ObjectIdLike, OperationResult, OperatorMap, OptionalId, OptionalUnlessRequiredId, OptionalUnlessRequiredIdAndVersion, OptionalUnlessRequiredVersion, OptionalVersion, PongoCache, PongoCacheSetEntry, PongoCacheType, PongoClient, PongoClientOptions, PongoClientSchema, PongoClientSchemaMetadata, PongoClientWithSchema, PongoCollection, PongoCollectionOptions, PongoCollectionSQLBuilder, PongoCollectionSchema, PongoCollectionSchemaComponent, PongoCollectionSchemaComponentOptions, PongoCollectionSchemaMetadata, PongoCollectionURN, PongoCollectionURNType, PongoDBCollectionOptions, PongoDatabase, PongoDatabaseCache, PongoDatabaseFactoryOptions, PongoDatabaseOptions, PongoDatabaseSQLBuilder, PongoDatabaseSchemaComponent, PongoDatabaseSchemaComponentOptions, PongoDatabaseURN, PongoDatabaseURNType, PongoDb, PongoDbOptions, PongoDbSchema, PongoDbSchemaMetadata, PongoDbTransaction, PongoDbWithSchema, PongoDeleteManyResult, PongoDeleteResult, PongoDocument, PongoDocumentCacheKey, PongoDriver, PongoDriverOptions, PongoDriverRegistry, PongoError, PongoFilter, PongoFilterOperator, PongoHandleResult, PongoInsertManyResult, PongoInsertOneResult, PongoMigrationOptions, PongoReplaceManyResult, PongoSchemaConfig, PongoSession, PongoSessionOptions, PongoTransactionCache, PongoTransactionCacheOperationOptions, PongoTransactionOptions, PongoUpdate, PongoUpdateManyResult, PongoUpdateResult, QueryOperators, RegExpOrString, ReplaceManyOptions, ReplaceOneOptions, RootFilterOperators, UpdateManyOptions, UpdateOneOptions, WithId, WithIdAndVersion, WithVersion, WithoutId, WithoutIdAndVersion, WithoutVersion, deepEquals, expectedVersion, expectedVersionValue, getIdsFromIdOnlyFilter, hasOperators, idFromFilter, identityMapCache, isEquatable, isGeneralExpectedDocumentVersion, isNumber, isOperator, isString, loadPongoClient, lruCache, mapAsync, mapParallel, mapSequential, noopCacheProvider, objectEntries, operationResult, pongoCache, pongoCacheWrapper, pongoClient, pongoCollection, pongoDriverRegistry, pongoSchema, pongoSession, pongoTransaction, pongoTransactionCache, proxyClientWithSchema, proxyPongoDbWithSchema, toClientSchemaMetadata, toDbSchemaMetadata, transactionExecutorOrDefault };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,140 +1,21 @@
-import { c as PongoFilter, d as PongoDocument, a as PongoDb, e as PongoCollectionSchemaComponent, C as CacheConfig, f as PongoCache, g as PongoCollection, h as CollectionOperationOptions, i as CacheHooks, j as PongoClientSchema, P as PongoDriver, k as PongoCollectionSchema, l as PongoDatabaseFactoryOptions, A as AnyPongoDb, m as PongoDatabaseSchemaComponent, n as PongoDbSchema, o as AnyPongoDriver, p as PongoClientOptions, q as PongoClient, E as ExtractPongoDatabaseTypeFromDriver, r as PongoClientWithSchema, s as PongoTransactionOptions, t as PongoSession, u as PongoDbTransaction } from './pongoTransactionCache-CRuPGag3.js';
-export { $ as $inc, v as $push, w as $set, x as $unset, y as AlternativeType, z as AnyPongoDriverOptions, B as BatchHandleOptions, D as CacheOptions, F as CacheSettings, G as CacheType, H as CollectionsMap, I as Condition, J as DBsMap, K as DOCUMENT_DOES_NOT_EXIST, L as DOCUMENT_EXISTS, M as DeleteManyOptions, N as DeleteOneOptions, O as Document, Q as DocumentCommandHandler, R as DocumentCommandHandlerInput, S as DocumentCommandHandlerOptions, T as DocumentHandler, U as EnhancedOmit, V as ExpectedDocumentVersion, W as ExpectedDocumentVersionGeneral, X as ExpectedDocumentVersionValue, Y as ExtractPongoDriverOptions, Z as FindOptions, _ as HandleOptions, a0 as HasId, a1 as InferIdType, a2 as InsertManyOptions, a3 as InsertOneOptions, a4 as LRUCacheOptions, a5 as MaybePromise, a6 as NO_CONCURRENCY_CHECK, a7 as NonObjectIdLikeDocument, a8 as ObjectId, a9 as ObjectIdLike, aa as OperationResult, ab as OptionalId, ac as OptionalUnlessRequiredId, ad as OptionalUnlessRequiredIdAndVersion, ae as OptionalUnlessRequiredVersion, af as OptionalVersion, ag as PongoCacheSetEntry, ah as PongoCacheType, ai as PongoClientSchemaMetadata, aj as PongoCollectionSQLBuilder, ak as PongoCollectionSchemaComponentOptions, al as PongoCollectionSchemaMetadata, am as PongoCollectionURN, an as PongoCollectionURNType, ao as PongoDBCollectionOptions, ap as PongoDatabaseSQLBuilder, aq as PongoDatabaseSchemaComponentOptions, ar as PongoDatabaseURN, as as PongoDatabaseURNType, at as PongoDbOptions, au as PongoDbSchemaMetadata, av as PongoDbWithSchema, aw as PongoDeleteManyResult, ax as PongoDeleteResult, ay as PongoDocumentCacheKey, b as PongoDriverOptions, az as PongoDriverRegistry, aA as PongoFilterOperator, aB as PongoHandleResult, aC as PongoInsertManyResult, aD as PongoInsertOneResult, aE as PongoMigrationOptions, aF as PongoReplaceManyResult, aG as PongoSchemaConfig, aH as PongoTransactionCache, aI as PongoTransactionCacheOperationOptions, aJ as PongoUpdate, aK as PongoUpdateManyResult, aL as PongoUpdateResult, aM as RegExpOrString, aN as ReplaceManyOptions, aO as ReplaceOneOptions, aP as RootFilterOperators, aQ as UpdateManyOptions, aR as UpdateOneOptions, aS as WithId, aT as WithIdAndVersion, aU as WithVersion, aV as WithoutId, aW as WithoutIdAndVersion, aX as WithoutVersion, aY as expectedVersion, aZ as expectedVersionValue, a_ as isGeneralExpectedDocumentVersion, a$ as lruCache, b0 as operationResult, b1 as pongoCache, b2 as pongoDriverRegistry, b3 as pongoSchema, b4 as pongoTransactionCache, b5 as proxyClientWithSchema, b6 as proxyPongoDbWithSchema, b7 as toClientSchemaMetadata, b8 as toDbSchemaMetadata } from './pongoTransactionCache-CRuPGag3.js';
-import { SQL, DatabaseDriverType, Dumbo, MigrationStyle, JSONSerializer, SQLExecutor, JSONSerializationOptions } from '@event-driven-io/dumbo';
-import 'lru-cache';
-
-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];
-};
-
-declare const idFromFilter: <T>(filter: PongoFilter<T> | SQL | undefined) => string | undefined;
-declare const getIdsFromIdOnlyFilter: <T>(filter: PongoFilter<T> | SQL | undefined) => string[] | undefined;
-
-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>;
-
-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;
-
-declare const identityMapCache: () => PongoCache;
-
-declare const noopCacheProvider: PongoCache;
-
-declare const pongoCacheWrapper: (options: {
-    provider: PongoCache;
-    hooks?: CacheHooks;
-}) => PongoCache;
-
-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[]>;
-};
-
-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;
-
-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);
-}
-
-declare const pongoClient: <DatabaseDriver extends AnyPongoDriver, TypedClientSchema extends PongoClientSchema = PongoClientSchema>(options: PongoClientOptions<DatabaseDriver, TypedClientSchema>) => PongoClient<DatabaseDriver["driverType"], ExtractPongoDatabaseTypeFromDriver<DatabaseDriver>> & PongoClientWithSchema<TypedClientSchema>;
-
-type PongoSessionOptions = {
-    explicit?: boolean;
-    defaultTransactionOptions: PongoTransactionOptions;
-    cache?: CacheConfig | 'disabled' | PongoCache;
-};
-declare const pongoSession: (options?: PongoSessionOptions) => PongoSession;
-
-declare const pongoTransaction: (options: PongoTransactionOptions) => PongoDbTransaction;
+import { $ as InferIdType, $t as ExtractPongoDriverOptions, A as MaybePromise, An as PongoCollectionSchemaComponent, At as PongoTransactionOptions, B as DOCUMENT_DOES_NOT_EXIST, Bn as DocumentCommandHandlerOptions, Bt as WithId, C as PongoCacheType, Cn as proxyPongoDbWithSchema, Ct as PongoFilterOperator, D as LRUCacheOptions, Dn as QueryOperators, Dt as PongoMigrationOptions, E as noopCacheProvider, En as OperatorMap, Et as PongoInsertOneResult, F as AlternativeType, Fn as PongoCollectionOptions, Ft as ReplaceManyOptions, G as DocumentHandler, Gt as WithoutVersion, H as DeleteManyOptions, Hn as idFromFilter, Ht as WithVersion, I as AnyPongoDb, In as pongoCollection, It as ReplaceOneOptions, J as ExpectedDocumentVersionGeneral, Jt as isGeneralExpectedDocumentVersion, K as EnhancedOmit, Kt as expectedVersion, L as BatchHandleOptions, Ln as transactionExecutorOrDefault, Lt as RootFilterOperators, M as $push, Mn as PongoCollectionURN, Mt as PongoUpdateManyResult, N as $set, Nn as PongoCollectionURNType, Nt as PongoUpdateResult, O as lruCache, On as hasOperators, Ot as PongoReplaceManyResult, P as $unset, Pn as PongoCollectionSQLBuilder, Pt as RegExpOrString, Q as HasId, Qt as ExtractPongoDatabaseTypeFromDriver, R as CollectionOperationOptions, Rn as DocumentCommandHandler, Rt as UpdateManyOptions, S as PongoCacheSetEntry, Sn as proxyClientWithSchema, St as PongoFilter, T as pongoCache, Tn as toDbSchemaMetadata, Tt as PongoInsertManyResult, U as DeleteOneOptions, Un as NonPartial, Ut as WithoutId, V as DOCUMENT_EXISTS, Vn as getIdsFromIdOnlyFilter, Vt as WithIdAndVersion, W as Document, Wn as objectEntries, Wt as WithoutIdAndVersion, X as FindOptions, Xt as AnyPongoDriver, Y as ExpectedDocumentVersionValue, Yt as operationResult, Z as HandleOptions, Zt as AnyPongoDriverOptions, _ as CacheHooks, _n as PongoDbSchema, _t as PongoDbOptions, a as ConcurrencyError, an as PongoDatabaseSQLBuilder, at as ObjectIdLike, b as CacheType, bn as PongoSchemaConfig, bt as PongoDeleteResult, c as isString, cn as PongoDatabaseURN, ct as OptionalUnlessRequiredId, d as PongoDatabaseCache, dn as DBsMap, dt as OptionalVersion, en as PongoDatabaseFactoryOptions, et as InsertManyOptions, f as PongoTransactionCache, fn as PongoClientSchema, ft as PongoClient, g as CacheConfig, gn as PongoCollectionSchemaMetadata, gt as PongoDb, h as pongoCacheWrapper, hn as PongoCollectionSchema, ht as PongoDBCollectionOptions, i as pongoClient, in as pongoDriverRegistry, it as ObjectId, j as $inc, jn as PongoCollectionSchemaComponentOptions, jt as PongoUpdate, k as identityMapCache, kn as isOperator, kt as PongoSession, l as PongoDatabase, ln as PongoDatabaseURNType, lt as OptionalUnlessRequiredIdAndVersion, m as pongoTransactionCache, mn as PongoClientWithSchema, mt as PongoCollection, n as PongoSessionOptions, nn as PongoDriverOptions, nt as NO_CONCURRENCY_CHECK, o as PongoError, on as PongoDatabaseSchemaComponent, ot as OperationResult, p as PongoTransactionCacheOperationOptions, pn as PongoClientSchemaMetadata, pt as PongoClientOptions, q as ExpectedDocumentVersion, qt as expectedVersionValue, r as pongoSession, rn as PongoDriverRegistry, rt as NonObjectIdLikeDocument, s as isNumber, sn as PongoDatabaseSchemaComponentOptions, st as OptionalId, t as pongoTransaction, tn as PongoDriver, tt as InsertOneOptions, u as PongoDatabaseOptions, un as CollectionsMap, ut as OptionalUnlessRequiredVersion, v as CacheOptions, vn as PongoDbSchemaMetadata, vt as PongoDbTransaction, w as PongoDocumentCacheKey, wn as toClientSchemaMetadata, wt as PongoHandleResult, x as PongoCache, xn as pongoSchema, xt as PongoDocument, y as CacheSettings, yn as PongoDbWithSchema, yt as PongoDeleteManyResult, z as Condition, zn as DocumentCommandHandlerInput, zt as UpdateOneOptions } from "./index-DMq6F3x9.js";
 
+//#region src/core/utils/deepEquals.d.ts
 declare const deepEquals: <T>(left: T, right: T) => boolean;
 type Equatable<T> = {
-    equals: (right: T) => boolean;
+  equals: (right: T) => boolean;
 } & T;
 declare const isEquatable: <T>(left: T) => left is Equatable<T>;
-
+//#endregion
+//#region src/core/utils/mapAsync.d.ts
 declare function mapSequential<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
 declare const mapParallel: <T, R>(items: T[], fn: (item: T, index: number) => Promise<R>) => Promise<R[]>;
 declare const mapAsync: <T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, options?: {
-    parallel: boolean | undefined;
+  parallel: boolean | undefined;
 }) => Promise<R[]>;
-
+//#endregion
+//#region src/index.d.ts
 declare const loadPongoClient: (path: "pg" | "sqlite3" | "d1") => Promise<AnyPongoDriver>;
-
-export { AnyPongoDb, AnyPongoDriver, CacheConfig, CacheHooks, CollectionOperationOptions, ConcurrencyError, type Equatable, ExtractPongoDatabaseTypeFromDriver, type NonPartial, OperatorMap, PongoCache, PongoClient, PongoClientOptions, PongoClientSchema, PongoClientWithSchema, PongoCollection, type PongoCollectionOptions, PongoCollectionSchema, PongoCollectionSchemaComponent, PongoDatabase, PongoDatabaseCache, PongoDatabaseFactoryOptions, type PongoDatabaseOptions, PongoDatabaseSchemaComponent, PongoDb, PongoDbSchema, PongoDbTransaction, PongoDocument, PongoDriver, PongoError, PongoFilter, PongoSession, type PongoSessionOptions, PongoTransactionOptions, QueryOperators, deepEquals, getIdsFromIdOnlyFilter, hasOperators, idFromFilter, identityMapCache, isEquatable, isNumber, isOperator, isString, loadPongoClient, mapAsync, mapParallel, mapSequential, noopCacheProvider, objectEntries, pongoCacheWrapper, pongoClient, pongoCollection, pongoSession, pongoTransaction, transactionExecutorOrDefault };
+//#endregion
+export { $inc, $push, $set, $unset, AlternativeType, AnyPongoDb, AnyPongoDriver, AnyPongoDriverOptions, BatchHandleOptions, CacheConfig, CacheHooks, CacheOptions, CacheSettings, CacheType, CollectionOperationOptions, CollectionsMap, ConcurrencyError, Condition, DBsMap, DOCUMENT_DOES_NOT_EXIST, DOCUMENT_EXISTS, DeleteManyOptions, DeleteOneOptions, Document, DocumentCommandHandler, DocumentCommandHandlerInput, DocumentCommandHandlerOptions, DocumentHandler, EnhancedOmit, Equatable, ExpectedDocumentVersion, ExpectedDocumentVersionGeneral, ExpectedDocumentVersionValue, ExtractPongoDatabaseTypeFromDriver, ExtractPongoDriverOptions, FindOptions, HandleOptions, HasId, InferIdType, InsertManyOptions, InsertOneOptions, LRUCacheOptions, MaybePromise, NO_CONCURRENCY_CHECK, NonObjectIdLikeDocument, NonPartial, ObjectId, ObjectIdLike, OperationResult, OperatorMap, OptionalId, OptionalUnlessRequiredId, OptionalUnlessRequiredIdAndVersion, OptionalUnlessRequiredVersion, OptionalVersion, PongoCache, PongoCacheSetEntry, PongoCacheType, PongoClient, PongoClientOptions, PongoClientSchema, PongoClientSchemaMetadata, PongoClientWithSchema, PongoCollection, PongoCollectionOptions, PongoCollectionSQLBuilder, PongoCollectionSchema, PongoCollectionSchemaComponent, PongoCollectionSchemaComponentOptions, PongoCollectionSchemaMetadata, PongoCollectionURN, PongoCollectionURNType, PongoDBCollectionOptions, PongoDatabase, PongoDatabaseCache, PongoDatabaseFactoryOptions, PongoDatabaseOptions, PongoDatabaseSQLBuilder, PongoDatabaseSchemaComponent, PongoDatabaseSchemaComponentOptions, PongoDatabaseURN, PongoDatabaseURNType, PongoDb, PongoDbOptions, PongoDbSchema, PongoDbSchemaMetadata, PongoDbTransaction, PongoDbWithSchema, PongoDeleteManyResult, PongoDeleteResult, PongoDocument, PongoDocumentCacheKey, PongoDriver, PongoDriverOptions, PongoDriverRegistry, PongoError, PongoFilter, PongoFilterOperator, PongoHandleResult, PongoInsertManyResult, PongoInsertOneResult, PongoMigrationOptions, PongoReplaceManyResult, PongoSchemaConfig, PongoSession, PongoSessionOptions, PongoTransactionCache, PongoTransactionCacheOperationOptions, PongoTransactionOptions, PongoUpdate, PongoUpdateManyResult, PongoUpdateResult, QueryOperators, RegExpOrString, ReplaceManyOptions, ReplaceOneOptions, RootFilterOperators, UpdateManyOptions, UpdateOneOptions, WithId, WithIdAndVersion, WithVersion, WithoutId, WithoutIdAndVersion, WithoutVersion, deepEquals, expectedVersion, expectedVersionValue, getIdsFromIdOnlyFilter, hasOperators, idFromFilter, identityMapCache, isEquatable, isGeneralExpectedDocumentVersion, isNumber, isOperator, isString, loadPongoClient, lruCache, mapAsync, mapParallel, mapSequential, noopCacheProvider, objectEntries, operationResult, pongoCache, pongoCacheWrapper, pongoClient, pongoCollection, pongoDriverRegistry, pongoSchema, pongoSession, pongoTransaction, pongoTransactionCache, proxyClientWithSchema, proxyPongoDbWithSchema, toClientSchemaMetadata, toDbSchemaMetadata, transactionExecutorOrDefault };
+//# sourceMappingURL=index.d.ts.map