@event-driven-io/pongo 0.17.0-alpha.6 → 0.17.0-beta.1

package/dist/pongoCollectionSchemaComponent-BsHlVyN-.d.cts

@@ -0,0 +1,422 @@
+import { DatabaseDriverType, SchemaComponent, MigrationStyle, DatabaseTransactionFactory, DatabaseTransaction, SQLExecutor, SQL, QueryResultRow, QueryResult, DatabaseConnectionString, InferDriverDatabaseType, SchemaComponentOptions } from '@event-driven-io/dumbo';
+
+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;
+};
+
+interface PongoDatabaseDriverOptions<ConnectionOptions = unknown> {
+    connectionOptions?: ConnectionOptions | undefined;
+}
+type AnyPongoDatabaseDriverOptions = PongoDatabaseDriverOptions<any>;
+type PongoDatabaseFactoryOptions<CollectionsSchema extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>, DriverOptions extends AnyPongoDatabaseDriverOptions = AnyPongoDatabaseDriverOptions> = {
+    databaseName?: string | undefined;
+    connectionString: string;
+    schema?: {
+        autoMigration?: MigrationStyle;
+        definition?: PongoDbSchema<CollectionsSchema>;
+    } | undefined;
+    errors?: {
+        throwOnOperationFailures?: boolean;
+    } | undefined;
+} & DriverOptions;
+interface PongoDatabaseDriver<Database extends AnyPongoDb = AnyPongoDb, DriverOptions extends AnyPongoDatabaseDriverOptions = AnyPongoDatabaseDriverOptions> {
+    driverType: Database['driverType'];
+    databaseFactory<CollectionsSchema extends Record<string, PongoCollectionSchema> = Record<string, PongoCollectionSchema>>(options: PongoDatabaseFactoryOptions<CollectionsSchema, DriverOptions>): Database & PongoDb<Database['driverType']>;
+    getDatabaseNameOrDefault(connectionString: string): string;
+    defaultConnectionString: string;
+}
+type AnyPongoDatabaseDriver = PongoDatabaseDriver<AnyPongoDb, AnyPongoDatabaseDriverOptions>;
+type ExtractPongoDatabaseDriverOptions<DatabaseDriver> = DatabaseDriver extends PongoDatabaseDriver<any, infer O> ? O : never;
+type ExtractPongoDatabaseTypeFromDriver<DatabaseDriver> = DatabaseDriver extends PongoDatabaseDriver<infer D, any> ? D : never;
+declare const PongoDatabaseDriverRegistry: () => {
+    register: <Database extends AnyPongoDb = AnyPongoDb>(driverType: Database["driverType"], driver: PongoDatabaseDriver<Database> | (() => Promise<PongoDatabaseDriver<Database>>)) => void;
+    tryResolve: <Driver extends AnyPongoDatabaseDriver = AnyPongoDatabaseDriver>(driverType: Driver["driverType"]) => Promise<Driver | null>;
+    tryGet: <Driver extends AnyPongoDatabaseDriver = AnyPongoDatabaseDriver>(driverType: Driver["driverType"]) => Driver | null;
+    has: (driverType: DatabaseDriverType) => boolean;
+    readonly databaseDriverTypes: DatabaseDriverType[];
+};
+declare global {
+    var pongoDatabaseDriverRegistry: ReturnType<typeof PongoDatabaseDriverRegistry>;
+}
+declare const pongoDatabaseDriverRegistry: {
+    register: <Database extends AnyPongoDb = AnyPongoDb>(driverType: Database["driverType"], driver: PongoDatabaseDriver<Database> | (() => Promise<PongoDatabaseDriver<Database>>)) => void;
+    tryResolve: <Driver extends AnyPongoDatabaseDriver = AnyPongoDatabaseDriver>(driverType: Driver["driverType"]) => Promise<Driver | null>;
+    tryGet: <Driver extends AnyPongoDatabaseDriver = AnyPongoDatabaseDriver>(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): Database;
+    startSession(): PongoSession<DriverType>;
+    withSession<T = unknown>(callback: (session: PongoSession<DriverType>) => Promise<T>): Promise<T>;
+}
+type PongoClientOptions<DatabaseDriver extends AnyPongoDatabaseDriver = AnyPongoDatabaseDriver, ConnectionString extends DatabaseConnectionString<InferDriverDatabaseType<DatabaseDriver['driverType']>> = DatabaseConnectionString<InferDriverDatabaseType<DatabaseDriver['driverType']>>, TypedClientSchema extends PongoClientSchema = PongoClientSchema> = ExtractPongoDatabaseDriverOptions<DatabaseDriver> extends infer Options ? Options extends unknown ? {
+    driver: DatabaseDriver;
+    connectionString: ConnectionString | string;
+    schema?: {
+        autoMigration?: MigrationStyle;
+        definition?: TypedClientSchema;
+    } | undefined;
+    errors?: {
+        throwOnOperationFailures?: boolean;
+    } | undefined;
+} & 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<DriverType>>;
+    commit: () => Promise<void>;
+    rollback: (error?: unknown) => Promise<void>;
+    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>;
+}
+interface PongoDb<DriverType extends DatabaseDriverType = DatabaseDriverType> extends DatabaseTransactionFactory<DriverType> {
+    driverType: DriverType;
+    databaseName: string;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    collection<T extends PongoDocument>(name: string): PongoCollection<T>;
+    collections(): ReadonlyArray<PongoCollection<PongoDocument>>;
+    readonly schema: Readonly<{
+        component: PongoDatabaseSchemaComponent<DriverType>;
+        migrate(): Promise<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 AnyPongoDb = PongoDb<DatabaseDriverType>;
+type CollectionOperationOptions = {
+    session?: PongoSession;
+};
+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 = {
+    expectedVersion?: ExpectedDocumentVersion;
+} & CollectionOperationOptions;
+type ReplaceOneOptions = {
+    expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
+} & CollectionOperationOptions;
+type DeleteOneOptions = {
+    expectedVersion?: Exclude<ExpectedDocumentVersion, 'DOCUMENT_DOES_NOT_EXIST'>;
+} & 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, handle: DocumentHandler<T>, options?: HandleOptions): Promise<PongoHandleResult<T>>;
+    readonly schema: Readonly<{
+        component: PongoCollectionSchemaComponent;
+        migrate(): Promise<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<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;
+    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;
+}
+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 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;
+    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;
+
+export { type FindOptions as $, type AnyPongoDb as A, type ExtractPongoDatabaseDriverOptions as B, type CollectionOperationOptions as C, PongoDatabaseDriverRegistry as D, type ExtractPongoDatabaseTypeFromDriver as E, pongoDatabaseDriverRegistry as F, type CollectionsMap as G, type PongoDbWithSchema as H, type DBsMap as I, pongoSchema as J, proxyPongoDbWithSchema as K, proxyClientWithSchema as L, type PongoCollectionSchemaMetadata as M, type PongoDbSchemaMetadata as N, type PongoClientSchemaMetadata as O, type PongoDb as P, toDbSchemaMetadata as Q, toClientSchemaMetadata as R, type PongoSchemaConfig as S, type InsertOneOptions as T, type InsertManyOptions as U, type UpdateOneOptions as V, type UpdateManyOptions as W, type HandleOptions as X, type ReplaceOneOptions as Y, type DeleteOneOptions as Z, type DeleteManyOptions as _, PongoCollectionSchemaComponent as a, ObjectId as a0, type HasId as a1, type InferIdType as a2, type EnhancedOmit as a3, type OptionalUnlessRequiredId as a4, type OptionalUnlessRequiredVersion as a5, type OptionalUnlessRequiredIdAndVersion as a6, type WithId as a7, type WithoutId as a8, type WithVersion as a9, expectedVersion as aA, type PongoUpdate as aB, type OperationResult as aC, operationResult as aD, type PongoInsertOneResult as aE, type PongoInsertManyResult as aF, type PongoUpdateResult as aG, type PongoUpdateManyResult as aH, type PongoDeleteResult as aI, type PongoDeleteManyResult as aJ, type PongoHandleResult as aK, type DocumentHandler as aL, type WithoutVersion as aa, type WithIdAndVersion as ab, type WithoutIdAndVersion as ac, type RegExpOrString as ad, type Document as ae, type OptionalId as af, type OptionalVersion as ag, type ObjectIdLike as ah, type NonObjectIdLikeDocument as ai, type AlternativeType as aj, type Condition as ak, type PongoFilter as al, type RootFilterOperators as am, type PongoFilterOperator as an, type $set as ao, type $unset as ap, type $inc as aq, type $push as ar, type ExpectedDocumentVersionGeneral as as, type ExpectedDocumentVersionValue as at, type ExpectedDocumentVersion as au, DOCUMENT_EXISTS as av, DOCUMENT_DOES_NOT_EXIST as aw, NO_CONCURRENCY_CHECK as ax, isGeneralExpectedDocumentVersion as ay, expectedVersionValue as az, type PongoDocument as b, type PongoCollection as c, type PongoClientSchema as d, type PongoDatabaseDriver as e, type PongoCollectionSchema as f, type PongoDatabaseFactoryOptions as g, PongoDatabaseSchemaComponent as h, type PongoDbSchema as i, type AnyPongoDatabaseDriver as j, type PongoClientOptions as k, type PongoClient as l, type PongoClientWithSchema as m, type PongoTransactionOptions as n, type PongoSession as o, type PongoDbTransaction as p, type PongoCollectionSQLBuilder as q, type PongoCollectionURNType as r, type PongoCollectionURN as s, type PongoCollectionSchemaComponentOptions as t, type PongoDatabaseURNType as u, type PongoDatabaseURN as v, type PongoDatabaseSchemaComponentOptions as w, type PongoDatabaseSQLBuilder as x, type PongoDatabaseDriverOptions as y, type AnyPongoDatabaseDriverOptions as z };