@event-driven-io/pongo 0.17.0-beta.44 → 0.17.0-beta.46

package/dist/pg.d.cts

@@ -1,437 +1,9 @@
+import { In as PongoCollectionSQLBuilder, _t as PongoDb, in as PongoDriverOptions, rn as PongoDriver } from "./index-C3pnS1S_.cjs";
 import * as _$_event_driven_io_dumbo0 from "@event-driven-io/dumbo";
-import { AnyConnection, DatabaseDriverType, DatabaseTransaction, JSONSerializationOptions, JSONSerializer, MigrationStyle, QueryResult, QueryResultRow, RunSQLMigrationsResult, SQL, SQLCommandOptions, SQLExecutor, SQLQueryOptions, SchemaComponent, SchemaComponentOptions, WithDatabaseTransactionFactory } from "@event-driven-io/dumbo";
-import { LRUCache } from "lru-cache";
+import { JSONSerializer } from "@event-driven-io/dumbo";
 import { PgConnection, PgDriverType } from "@event-driven-io/dumbo/pg";
 import pg from "pg";
 
-//#region src/core/collection/handle.d.ts
-type DocumentCommandHandlerInput = {
-  _id: string;
-  expectedVersion?: ExpectedDocumentVersion;
-};
-//#endregion
-//#region src/core/collection/pongoCollectionSchema.d.ts
-type PongoCollectionSQLBuilder = {
-  createCollection: () => SQL;
-  insertOne: <T>(document: OptionalUnlessRequiredIdAndVersion<T>) => SQL;
-  insertMany: <T>(documents: OptionalUnlessRequiredIdAndVersion<T>[]) => SQL;
-  insertOrReplace: <T>(documents: Array<WithId<T>>) => SQL;
-  updateOne: <T>(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateOneOptions) => SQL;
-  replaceOne: <T>(filter: PongoFilter<T> | SQL, document: WithoutId<T>, options?: ReplaceOneOptions) => SQL;
-  updateMany: <T>(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL) => SQL;
-  deleteOne: <T>(filter: PongoFilter<T> | SQL, options?: DeleteOneOptions) => SQL;
-  deleteMany: <T>(filter: PongoFilter<T> | SQL) => SQL;
-  replaceMany: <T>(documents: Array<WithIdAndVersion<T>> | Array<WithId<T>>) => SQL;
-  deleteManyByIds: (ids: Array<{
-    _id: string;
-    _version?: bigint;
-  }>) => SQL;
-  findOne: <T>(filter: PongoFilter<T> | SQL) => SQL;
-  find: <T>(filter: PongoFilter<T> | SQL, options?: FindOptions) => SQL;
-  countDocuments: <T>(filter: PongoFilter<T> | SQL) => SQL;
-  rename: (newName: string) => SQL;
-  drop: () => SQL;
-};
-//#endregion
-//#region src/core/collection/pongoCollectionSchemaComponent.d.ts
-type PongoCollectionURNType = 'sc:pongo:collection';
-type PongoCollectionURN = `${PongoCollectionURNType}:${string}`;
-type PongoCollectionSchemaComponent = SchemaComponent<PongoCollectionURN> & {
-  collectionName: string;
-  definition: PongoCollectionSchema;
-  sqlBuilder: PongoCollectionSQLBuilder;
-};
-type PongoCollectionSchemaComponentOptions<DriverType extends DatabaseDriverType = DatabaseDriverType> = Readonly<{
-  driverType: DriverType;
-  definition: PongoCollectionSchema;
-  migrationsOrSchemaComponents: SchemaComponentOptions;
-  sqlBuilder: PongoCollectionSQLBuilder;
-}>;
-declare const PongoCollectionSchemaComponent: <DriverType extends DatabaseDriverType = DatabaseDriverType>({
-  definition,
-  migrationsOrSchemaComponents,
-  sqlBuilder
-}: PongoCollectionSchemaComponentOptions<DriverType>) => PongoCollectionSchemaComponent;
-//#endregion
-//#region src/core/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;
-}
-//#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;
-//#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>;
-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>;
-}
-//#endregion
-//#region src/core/typing/operations.d.ts
-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;
-};
-interface PongoDb<DriverType extends DatabaseDriverType = DatabaseDriverType> extends WithDatabaseTransactionFactory<AnyConnection> {
-  driverType: DriverType;
-  databaseName: string;
-  connect(): Promise<void>;
-  close(): Promise<void>;
-  collection<T extends PongoDocument, Payload extends PongoDocument = T>(name: string, options?: PongoDBCollectionOptions<T, Payload>): PongoCollection<T>;
-  collections(): ReadonlyArray<PongoCollection<PongoDocument>>;
-  readonly schema: Readonly<{
-    component: PongoDatabaseSchemaComponent<DriverType>;
-    migrate(options?: PongoMigrationOptions): Promise<RunSQLMigrationsResult>;
-  }>;
-  sql: {
-    query<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions & SQLQueryOptions): Promise<Result[]>;
-    command<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions & SQLCommandOptions): Promise<QueryResult<Result>>;
-  };
-}
-type AnyPongoDb = PongoDb<DatabaseDriverType>;
-type PongoMigrationOptions = {
-  dryRun?: boolean | undefined;
-  ignoreMigrationHashMismatch?: boolean | undefined;
-  migrationTimeoutMs?: number | undefined;
-};
-type CollectionOperationOptions = {
-  session?: PongoSession;
-  skipCache?: boolean;
-};
-type InsertOneOptions = {
-  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK'>;
-  upsert?: boolean;
-} & CollectionOperationOptions;
-type InsertManyOptions = {
-  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK'>;
-  upsert?: boolean;
-} & CollectionOperationOptions;
-type UpdateOneOptions = {
-  expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
-} & CollectionOperationOptions;
-type UpdateManyOptions = {
-  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
-} & CollectionOperationOptions;
-type HandleOptions = CollectionOperationOptions;
-type BatchHandleOptions = {
-  parallel?: boolean;
-} & CollectionOperationOptions;
-type ReplaceOneOptions = {
-  expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
-  upsert?: boolean;
-} & CollectionOperationOptions;
-type DeleteOneOptions = {
-  expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
-} & CollectionOperationOptions;
-type ReplaceManyOptions = {
-  upsert?: boolean;
-} & CollectionOperationOptions;
-type DeleteManyOptions = {
-  expectedVersion?: Extract<ExpectedDocumentVersion, 'DOCUMENT_EXISTS' | 'NO_CONCURRENCY_CHECK'>;
-} & CollectionOperationOptions;
-type FindOptions = {
-  limit?: number;
-  skip?: number;
-  sort?: {
-    [field: string]: 1 | -1;
-  };
-} & CollectionOperationOptions;
-interface PongoCollection<T extends PongoDocument> {
-  readonly dbName: string;
-  readonly collectionName: string;
-  createCollection(options?: CollectionOperationOptions): Promise<void>;
-  insertOne(document: OptionalUnlessRequiredId<T>, options?: InsertOneOptions): Promise<PongoInsertOneResult>;
-  insertMany(documents: OptionalUnlessRequiredId<T>[], options?: InsertManyOptions): Promise<PongoInsertManyResult>;
-  updateOne(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateOneOptions): Promise<PongoUpdateResult>;
-  replaceOne(filter: PongoFilter<T> | SQL, document: WithoutId<T>, options?: ReplaceOneOptions): Promise<PongoUpdateResult>;
-  updateMany(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateManyOptions): Promise<PongoUpdateManyResult>;
-  deleteOne(filter?: PongoFilter<T> | SQL, options?: DeleteOneOptions): Promise<PongoDeleteResult>;
-  deleteMany(filter?: PongoFilter<T> | SQL, options?: DeleteManyOptions): Promise<PongoDeleteResult>;
-  findOne(filter?: PongoFilter<T> | SQL, options?: CollectionOperationOptions): Promise<WithIdAndVersion<T> | null>;
-  find(filter?: PongoFilter<T> | SQL, options?: FindOptions): Promise<WithIdAndVersion<T>[]>;
-  findOneAndDelete(filter: PongoFilter<T> | SQL, options?: DeleteOneOptions): Promise<WithIdAndVersion<T> | null>;
-  findOneAndReplace(filter: PongoFilter<T> | SQL, replacement: WithoutId<T>, options?: ReplaceOneOptions): Promise<WithIdAndVersion<T> | null>;
-  findOneAndUpdate(filter: PongoFilter<T> | SQL, update: PongoUpdate<T> | SQL, options?: UpdateOneOptions): Promise<WithIdAndVersion<T> | null>;
-  countDocuments(filter?: PongoFilter<T> | SQL, options?: CollectionOperationOptions): Promise<number>;
-  drop(options?: CollectionOperationOptions): Promise<boolean>;
-  rename(newName: string, options?: CollectionOperationOptions): Promise<PongoCollection<T>>;
-  handle(id: string | DocumentCommandHandlerInput, handle: DocumentHandler<T>, options?: HandleOptions): Promise<PongoHandleResult<T>>;
-  handle(id: string[] | DocumentCommandHandlerInput[], handle: DocumentHandler<T>, options?: BatchHandleOptions): Promise<PongoHandleResult<T>[]>;
-  replaceMany(documents: Array<WithIdAndVersion<T>> | Array<WithId<T>>, options?: ReplaceManyOptions): Promise<PongoReplaceManyResult>;
-  readonly schema: Readonly<{
-    component: PongoCollectionSchemaComponent;
-    migrate(options?: PongoMigrationOptions): Promise<RunSQLMigrationsResult>;
-  }>;
-  close: () => MaybePromise<void>;
-  sql: {
-    query<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions): Promise<Result[]>;
-    command<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: CollectionOperationOptions): Promise<QueryResult<Result>>;
-  };
-}
-type ObjectId = string & {
-  __brandId: 'ObjectId';
-};
-declare const ObjectId: (value?: string) => string;
-type HasId = {
-  _id: string;
-};
-/** TypeScript Omit (Exclude to be specific) does not work for objects with an "any" indexed type, and breaks discriminated unions @public */
-declare type EnhancedOmit<TRecordOrUnion, KeyUnion> = string extends keyof TRecordOrUnion ? TRecordOrUnion : TRecordOrUnion extends any ? Pick<TRecordOrUnion, Exclude<keyof TRecordOrUnion, KeyUnion>> : never;
-declare type OptionalUnlessRequiredId<TSchema> = TSchema extends {
-  _id: string | ObjectId;
-} ? TSchema : OptionalId<TSchema>;
-declare type OptionalUnlessRequiredVersion<TSchema> = TSchema extends {
-  _version: bigint;
-} ? TSchema : OptionalVersion<TSchema>;
-declare type OptionalUnlessRequiredIdAndVersion<TSchema> = OptionalUnlessRequiredId<TSchema> & OptionalUnlessRequiredVersion<TSchema>;
-declare type WithId<TSchema> = TSchema & {
-  _id: string | ObjectId;
-};
-type WithoutId<T> = Omit<T, '_id'>;
-declare type WithVersion<TSchema> = TSchema & {
-  _version: bigint;
-};
-type WithIdAndVersion<T> = WithId<T> & WithVersion<T>;
-/** @public */
-declare type RegExpOrString<T> = T extends string ? RegExp | T : T;
-declare interface Document {
-  [key: string]: any;
-}
-declare type OptionalId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
-  _id?: string | ObjectId;
-};
-declare type OptionalVersion<TSchema> = EnhancedOmit<TSchema, '_version'> & {
-  _version?: bigint;
-};
-declare interface ObjectIdLike {
-  __id?: string | ObjectId;
-}
-declare type NonObjectIdLikeDocument = { [key in keyof ObjectIdLike]?: never } & Document;
-declare type AlternativeType<T> = T extends ReadonlyArray<infer U> ? T | RegExpOrString<U> : RegExpOrString<T>;
-declare type Condition<T> = AlternativeType<T> | PongoFilterOperator<AlternativeType<T>>;
-declare interface RootFilterOperators<TSchema> extends Document {
-  $and?: PongoFilter<TSchema>[];
-  $nor?: PongoFilter<TSchema>[];
-  $or?: PongoFilter<TSchema>[];
-  $text?: {
-    $search: string;
-    $language?: string;
-    $caseSensitive?: boolean;
-    $diacriticSensitive?: boolean;
-  };
-  $where?: string | ((this: TSchema) => boolean);
-  $comment?: string | Document;
-}
-declare type PongoFilter<TSchema> = ({ [P in keyof WithId<TSchema>]?: Condition<WithId<TSchema>[P]> } & Pick<RootFilterOperators<WithId<TSchema>>, '$and' | '$nor' | '$or'>) | (HasId & Pick<RootFilterOperators<WithId<TSchema>>, '$and' | '$nor' | '$or'>);
-declare interface PongoFilterOperator<TValue> extends NonObjectIdLikeDocument {
-  $eq?: TValue;
-  $gt?: TValue;
-  $gte?: TValue;
-  $lt?: TValue;
-  $lte?: TValue;
-  $ne?: TValue;
-  $in?: TValue[];
-  $nin?: TValue[];
-}
-type $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 ExpectedDocumentVersion = (bigint & {
-  __brand: 'sql';
-}) | bigint | ExpectedDocumentVersionGeneral;
-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;
-};
-interface PongoInsertOneResult extends OperationResult {
-  insertedId: string | null;
-  nextExpectedVersion: bigint;
-}
-interface PongoInsertManyResult extends OperationResult {
-  insertedIds: string[];
-  insertedCount: number;
-}
-interface PongoUpdateResult extends OperationResult {
-  matchedCount: number;
-  modifiedCount: number;
-  upsertedId: string | null;
-  upsertedCount: number;
-  nextExpectedVersion: bigint;
-}
-interface PongoUpdateManyResult extends OperationResult {
-  matchedCount: number;
-  modifiedCount: number;
-}
-interface PongoDeleteResult extends OperationResult {
-  matchedCount: number;
-  deletedCount: number;
-}
-interface 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/lruCache.d.ts
-type LRUCacheOptions = Omit<LRUCache.Options<string, {
-  doc: PongoDocument | null;
-}, unknown>, 'max'> & {
-  max?: number;
-};
-//#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 CacheSettings = ({
-  type: 'in-memory';
-} & LRUCacheOptions) | {
-  type: 'identity-map';
-};
-type CacheConfig = CacheSettings | 'disabled';
-//#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>;
-}
-//#endregion
 //#region src/storage/postgresql/core/sqlBuilder/index.d.ts
 declare const pongoCollectionPostgreSQLMigrations: (collectionName: string) => _$_event_driven_io_dumbo0.SQLMigration[];
 declare const postgresSQLBuilder: (collectionName: string, serializer: JSONSerializer) => PongoCollectionSQLBuilder;
@@ -464,5 +36,4 @@ type PgDatabaseDriverOptions = PongoDriverOptions<PgPongoClientOptions> & {
 declare const pgPongoDriver: PongoDriver<PongoDb<PgDriverType>, PgDatabaseDriverOptions>;
 declare const usePgPongoDriver: () => void;
 //#endregion
-export { NotPooledPongoOptions, PgPongoClientOptions, PooledPongoClientOptions, pgPongoDriver as pgDriver, pgPongoDriver as pongoDriver, pongoCollectionPostgreSQLMigrations, postgresSQLBuilder, usePgPongoDriver };
-//# sourceMappingURL=pg.d.cts.map
+export { NotPooledPongoOptions, PgPongoClientOptions, PooledPongoClientOptions, pgPongoDriver as pgDriver, pgPongoDriver as pongoDriver, pongoCollectionPostgreSQLMigrations, postgresSQLBuilder, usePgPongoDriver };