@event-driven-io/dumbo 0.13.0-beta.3 → 0.13.0-beta.31

package/dist/{connectionString-B1wm0TFc.d.cts → connectionString-Dch_MIRU.d.cts}

@@ -1,3 +1,72 @@
+type JSONSerializerOptions = {
+    parseDates?: boolean;
+    parseBigInts?: boolean;
+    failOnBigIntSerialization?: boolean;
+    useDefaultDateSerialization?: boolean;
+};
+type JSONSerializeOptions = {
+    replacer?: JSONReplacer;
+} & JSONSerializerOptions;
+type JSONDeserializeOptions = {
+    reviver?: JSONReviver;
+} & JSONSerializerOptions;
+type JSONCodecSerializationOptions<SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> = {
+    serializer?: JSONSerializer<SerializeOptions, DeserializeOptions>;
+    serializerOptions?: never;
+} | {
+    serializer?: never;
+    serializerOptions?: JSONSerializerOptions;
+};
+type JSONSerializationOptions<SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> = {
+    serialization?: {
+        serializer?: JSONSerializer<SerializeOptions, DeserializeOptions>;
+        options?: JSONSerializeOptions | JSONDeserializeOptions;
+    } | undefined;
+};
+type JSONCodecOptions<T, Payload = T, SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> = JSONCodecSerializationOptions<SerializeOptions, DeserializeOptions> & {
+    upcast?: (document: Payload) => T;
+    downcast?: (document: T) => Payload;
+};
+type JSONReviverContext = {
+    source: string;
+};
+declare const composeJSONReplacers: (...replacers: (JSONReplacer | undefined)[]) => JSONReplacer | undefined;
+declare const composeJSONRevivers: (...revivers: (JSONReviver | undefined)[]) => JSONReviver | undefined;
+type JSONReplacer = (this: any, key: string, value: any) => any;
+declare const JSONReplacer: (opts?: JSONSerializeOptions) => JSONReplacer | undefined;
+type JSONReviver = (this: any, key: string, value: any, context: JSONReviverContext) => any;
+declare const JSONReviver: (opts?: JSONDeserializeOptions) => JSONReviver | undefined;
+declare const JSONReplacers: {
+    bigInt: JSONReplacer;
+    date: JSONReplacer;
+};
+declare const JSONRevivers: {
+    bigInt: JSONReviver;
+    date: JSONReviver;
+};
+declare const jsonSerializer: (options?: JSONSerializerOptions & JSONDeserializeOptions & JSONSerializeOptions) => JSONSerializer;
+interface JSONSerializer<SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> extends Serializer<string, SerializeOptions, DeserializeOptions> {
+    serialize<T>(object: T, options?: SerializeOptions): string;
+    deserialize<T>(payload: string, options?: DeserializeOptions): T;
+}
+declare const JSONSerializer: JSONSerializer & {
+    from: <SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions>(options?: JSONSerializationOptions<SerializeOptions, DeserializeOptions>) => JSONSerializer<SerializeOptions, DeserializeOptions>;
+};
+interface JSONCodec<T, SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> extends SerializationCodec<T, string, SerializeOptions, DeserializeOptions> {
+    encode(object: T, options?: SerializeOptions): string;
+    decode(payload: string, options?: DeserializeOptions): T;
+}
+declare const JSONCodec: <T, Payload = T, SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions>(options: JSONCodecOptions<T, Payload, SerializeOptions, DeserializeOptions>) => JSONCodec<T, SerializeOptions, DeserializeOptions>;
+
+interface Serializer<Payload, SerializeOptions extends Record<string, unknown> = Record<string, unknown>, DeserializeOptions extends Record<string, unknown> = SerializeOptions> {
+    serialize<T>(object: T, options?: SerializeOptions): Payload;
+    deserialize<T>(payload: Payload, options?: DeserializeOptions): T;
+}
+interface SerializationCodec<T, Payload, SerializeOptions extends Record<string, unknown> = Record<string, unknown>, DeserializeOptions extends Record<string, unknown> = SerializeOptions> {
+    encode(object: T, options?: SerializeOptions): Payload;
+    decode(payload: Payload, options?: DeserializeOptions): T;
+}
+
 interface ParametrizedSQL {
     query: string;
     params: unknown[];
@@ -49,22 +118,29 @@ declare const SQLLiteral: {
     check: (token: unknown) => token is SQLLiteral;
     type: "SQL_LITERAL";
 };
+type SQLArrayMode = 'params' | 'native';
 type SQLArray = SQLToken<'SQL_ARRAY', {
     value: unknown[];
+    mode?: SQLArrayMode;
 }>;
 declare const SQLArray: {
-    from: (input: unknown[]) => SQLArray;
+    from: (input: unknown[] | {
+        value: unknown[];
+        mode?: SQLArrayMode;
+    }) => SQLArray;
     check: (token: unknown) => token is SQLArray;
     type: "SQL_ARRAY";
 };
 type SQLIn = SQLToken<'SQL_IN', {
     column: SQLIdentifier;
     values: SQLArray;
+    mode?: SQLArrayMode;
 }>;
 declare const SQLIn: {
     from: (input: {
         column: string;
         values: unknown[];
+        mode?: SQLArrayMode;
     }) => SQLIn;
     check: (token: unknown) => token is SQLIn;
     type: "SQL_IN";
@@ -248,7 +324,7 @@ declare const SQLColumnToken: {
     type: "SQL_COLUMN";
 };
 
-type MapSQLParamValue = (value: unknown, options?: MapSQLParamValueOptions) => unknown;
+type MapSQLParamValue = (value: unknown, serializer: JSONSerializer, options?: MapSQLParamValueOptions) => unknown;
 interface MapSQLParamValueOptions {
     mapBoolean?: (value: boolean) => unknown;
     mapArray?: (array: unknown[], mapValue: MapSQLParamValue) => unknown[];
@@ -283,12 +359,13 @@ interface SQLValueMapper {
     mapIdentifier: (value: string) => string;
 }
 declare const SQLValueMapper: (options?: MapSQLParamValueOptions) => SQLValueMapper;
-declare function mapSQLParamValue(value: unknown, options?: MapSQLParamValueOptions): unknown;
+declare function mapSQLParamValue(value: unknown, serializer: JSONSerializer, options?: MapSQLParamValueOptions): unknown;
 
 type SQLProcessorContext = {
     mapper: SQLValueMapper;
     builder: ParametrizedSQLBuilder;
     processorsRegistry: SQLProcessorsReadonlyRegistry;
+    serializer: JSONSerializer;
 };
 type AnySQLProcessor = SQLProcessor<any>;
 type SQLProcessorOptions<Token extends AnySQLToken = AnySQLToken> = {
@@ -328,7 +405,12 @@ declare namespace SQL {
     export var merge: (sqls: SQL[], separator?: string) => SQL;
     export var format: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => ParametrizedSQL;
     export var describe: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => string;
-    var _a: (column: string, values: unknown[]) => SQLIn;
+    var _a: (column: string, values: unknown[], options?: {
+        mode?: SQLArrayMode;
+    }) => SQLIn;
+    export var array: (values: unknown[], options?: {
+        mode?: SQLArrayMode;
+    }) => SQLArray;
     export var identifier: (input: string) => SQLIdentifier;
     export var plain: (input: string) => SQLPlain;
     export var check: {
@@ -348,19 +430,22 @@ declare namespace SQL {
     };
     export { _a as in };
 }
+declare function RawSQL(strings: TemplateStringsArray, ...values: unknown[]): SQL;
 declare const isSQL: (value: unknown) => value is SQL;
 
+type FormatContext = Partial<SQLProcessorContext> & Pick<SQLProcessorContext, 'serializer'>;
 type FormatSQLOptions = {
     mapper?: MapSQLParamValueOptions;
     processorsRegistry?: SQLProcessorsReadonlyRegistry;
+    serializer?: JSONSerializer;
 };
 type SQLFormatterOptions = Partial<Omit<SQLFormatter, 'valueMapper'>> & {
     valueMapper?: MapSQLParamValueOptions;
     processorsRegistry?: SQLProcessorsReadonlyRegistry;
 };
 interface SQLFormatter {
-    format: (sql: SQL | SQL[], context?: SQLProcessorContext) => ParametrizedSQL;
-    describe: (sql: SQL | SQL[], context?: SQLProcessorContext) => string;
+    format: (sql: SQL | SQL[], context: FormatContext) => ParametrizedSQL;
+    describe: (sql: SQL | SQL[], context: FormatContext) => string;
     valueMapper: SQLValueMapper;
 }
 declare const SQLFormatter: ({ format, describe, valueMapper: valueMapperOptions, processorsRegistry, }: SQLFormatterOptions) => SQLFormatter;
@@ -369,8 +454,8 @@ declare global {
 }
 declare const registerFormatter: (dialect: string, formatter: SQLFormatter) => void;
 declare const getFormatter: (dialect: string) => SQLFormatter;
-declare function formatSQL(sql: SQL | SQL[], formatter: SQLFormatter, context?: FormatSQLOptions): ParametrizedSQL;
-declare const describeSQL: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => string;
+declare function formatSQL(sql: SQL | SQL[], formatter: SQLFormatter, serializer: JSONSerializer, context?: FormatSQLOptions): ParametrizedSQL;
+declare const describeSQL: (sql: SQL | SQL[], formatter: SQLFormatter, serializer: JSONSerializer, options?: FormatSQLOptions) => string;
 
 type MigrationStyle = 'None' | 'CreateOrUpdate';
 type SQLMigration = {
@@ -833,6 +918,235 @@ type ValidateDatabaseSchemas<Schemas extends DatabaseSchemas> = MapRecordCollect
 }> extends infer Results ? AnyTypeValidationFailed<Results> extends true ? TypeValidationError<UnwrapTypeValidationErrors<Results extends readonly AnyTypeValidationError[] ? Results : never>> : TypeValidationSuccess : TypeValidationSuccess;
 type ValidateDatabaseSchemasWithMessages<Schemas extends DatabaseSchemas> = FormatValidationErrors<ValidateDatabaseSchemas<Schemas>>;
 
+declare class DumboError extends Error {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    errorCode: number;
+    errorType: string;
+    innerError: Error | undefined;
+    constructor(options?: {
+        errorCode: number;
+        errorType?: string;
+        message?: string | undefined;
+        innerError?: Error | undefined;
+    } | string | number);
+    static isInstanceOf<ErrorType extends DumboError = DumboError>(error: unknown, options?: {
+        errorCode?: number;
+        errorType?: string;
+    }): error is ErrorType;
+}
+declare class ConcurrencyError extends DumboError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class TransientDatabaseError extends DumboError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class ConnectionError extends TransientDatabaseError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class SerializationError extends TransientDatabaseError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class DeadlockError extends TransientDatabaseError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class LockNotAvailableError extends TransientDatabaseError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class InsufficientResourcesError extends TransientDatabaseError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class SystemError extends TransientDatabaseError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class AdminShutdownError extends TransientDatabaseError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class QueryCanceledError extends TransientDatabaseError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class IntegrityConstraintViolationError extends DumboError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class UniqueConstraintError extends IntegrityConstraintViolationError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class ForeignKeyViolationError extends IntegrityConstraintViolationError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class NotNullViolationError extends IntegrityConstraintViolationError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class CheckViolationError extends IntegrityConstraintViolationError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class ExclusionViolationError extends IntegrityConstraintViolationError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class DataError extends DumboError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+declare class InvalidOperationError extends DumboError {
+    static readonly ErrorCode: number;
+    static readonly ErrorType: string;
+    constructor(message?: string, innerError?: Error);
+}
+
+interface QueryResultRow {
+    [column: string]: any;
+}
+type QueryResult<Result extends QueryResultRow = QueryResultRow> = {
+    rowCount: number | null;
+    rows: Result[];
+};
+
+declare const mapColumnToJSON: (column: string, serializer: JSONSerializer, options?: JSONDeserializeOptions) => {
+    [x: string]: (value: unknown) => unknown;
+};
+declare const mapColumnToBigint: (column: string) => {
+    [x: string]: (value: unknown) => unknown;
+};
+declare const mapColumnToDate: (column: string) => {
+    [x: string]: (value: unknown) => unknown;
+};
+declare const mapSQLQueryResult: <T>(result: T, mapping: SQLQueryResultColumnMapping) => T;
+type SQLQueryResultColumnMapping = {
+    [column: string]: (value: unknown) => unknown;
+};
+type SQLQueryOptions = {
+    timeoutMs?: number | undefined;
+    mapping?: SQLQueryResultColumnMapping;
+};
+type SQLCommandOptions = {
+    timeoutMs?: number | undefined;
+    mapping?: SQLQueryResultColumnMapping;
+};
+type BatchSQLCommandOptions = SQLCommandOptions & {
+    assertChanges?: boolean;
+};
+declare class BatchCommandNoChangesError extends DumboError {
+    readonly statementIndex: number;
+    constructor(statementIndex: number);
+}
+type DbSQLExecutorOptions = {
+    serializer: JSONSerializer;
+};
+interface DbSQLExecutor<DriverType extends DatabaseDriverType = DatabaseDriverType, DbClient = unknown> {
+    driverType: DriverType;
+    query<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sql: SQL, options?: SQLQueryOptions): Promise<QueryResult<Result>>;
+    batchQuery<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sqls: SQL[], options?: SQLQueryOptions): Promise<QueryResult<Result>[]>;
+    command<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sql: SQL, options?: SQLCommandOptions): Promise<QueryResult<Result>>;
+    batchCommand<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sqls: SQL[], options?: BatchSQLCommandOptions): Promise<QueryResult<Result>[]>;
+    formatter: SQLFormatter;
+}
+interface SQLExecutor {
+    query<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: SQLQueryOptions): Promise<QueryResult<Result>>;
+    batchQuery<Result extends QueryResultRow = QueryResultRow>(sqls: SQL[], options?: SQLQueryOptions): Promise<QueryResult<Result>[]>;
+    command<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: SQLCommandOptions): Promise<QueryResult<Result>>;
+    batchCommand<Result extends QueryResultRow = QueryResultRow>(sqls: SQL[], options?: BatchSQLCommandOptions): Promise<QueryResult<Result>[]>;
+}
+interface WithSQLExecutor {
+    execute: SQLExecutor;
+}
+declare const sqlExecutor: <DbClient = unknown, DbExecutor extends DbSQLExecutor = DbSQLExecutor>(sqlExecutor: DbExecutor, options: {
+    connect: () => Promise<DbClient>;
+    close?: (client: DbClient, error?: unknown) => Promise<void>;
+}) => SQLExecutor;
+declare const sqlExecutorInNewConnection: <ConnectionType extends Connection>(options: {
+    driverType: ConnectionType["driverType"];
+    connection: () => Promise<ConnectionType>;
+}) => SQLExecutor;
+declare const sqlExecutorInAmbientConnection: <ConnectionType extends Connection>(options: {
+    driverType: ConnectionType["driverType"];
+    connection: () => Promise<ConnectionType>;
+}) => SQLExecutor;
+declare const executeInNewDbClient: <DbClient = unknown, Result = unknown>(handle: (client: DbClient) => Promise<Result>, options: {
+    connect: () => Promise<DbClient>;
+    close?: (client: DbClient, error?: unknown) => Promise<void>;
+}) => Promise<Result>;
+declare const executeInNewConnection: <ConnectionType extends Connection, Result>(handle: (connection: ConnectionType) => Promise<Result>, options: {
+    connection: () => Promise<ConnectionType>;
+}) => Promise<Result>;
+declare const executeInAmbientConnection: <ConnectionType extends Connection, Result>(handle: (connection: ConnectionType) => Promise<Result>, options: {
+    connection: () => Promise<ConnectionType>;
+}) => Promise<Result>;
+
+interface DatabaseCapabilities<SupportsMultipleDatabases extends boolean, SupportsSchemas extends boolean, SupportsFunctions extends boolean> {
+    readonly supportsMultipleDatabases: SupportsMultipleDatabases;
+    readonly supportsSchemas: SupportsSchemas;
+    readonly supportsFunctions: SupportsFunctions;
+}
+type DatabaseMetadata<SupportsMultipleDatabases extends boolean = boolean, SupportsSchemas extends boolean = boolean, SupportsFunctions extends boolean = boolean> = {
+    readonly databaseType: DatabaseType;
+    readonly capabilities: DatabaseCapabilities<SupportsMultipleDatabases, SupportsSchemas, SupportsFunctions>;
+    readonly tableExists: (pool: SQLExecutor, tableName: string) => Promise<boolean>;
+} & (SupportsMultipleDatabases extends true ? {
+    readonly defaultDatabaseName: string;
+    readonly parseDatabaseName: (connectionString?: string) => string | undefined;
+} : {
+    readonly defaultDatabaseName?: never;
+    readonly parseDatabaseName?: never;
+}) & (SupportsFunctions extends true ? {
+    readonly functionExists: (pool: SQLExecutor, functionName: string) => Promise<boolean>;
+} : {
+    readonly functionExists?: (pool: SQLExecutor, functionName: string) => Promise<boolean>;
+});
+declare const DumboDatabaseMetadataRegistry: () => {
+    register: (databaseType: DatabaseType, info: DatabaseMetadata | (() => Promise<DatabaseMetadata>)) => void;
+    tryResolve: (databaseType: DatabaseType) => Promise<DatabaseMetadata | null>;
+    tryGet: (databaseType: DatabaseType) => DatabaseMetadata | null;
+    has: (databaseType: DatabaseType) => boolean;
+    readonly databaseTypes: DatabaseType[];
+};
+declare global {
+    var dumboDatabaseMetadataRegistry: ReturnType<typeof DumboDatabaseMetadataRegistry>;
+}
+declare const dumboDatabaseMetadataRegistry: {
+    register: (databaseType: DatabaseType, info: DatabaseMetadata | (() => Promise<DatabaseMetadata>)) => void;
+    tryResolve: (databaseType: DatabaseType) => Promise<DatabaseMetadata | null>;
+    tryGet: (databaseType: DatabaseType) => DatabaseMetadata | null;
+    has: (databaseType: DatabaseType) => boolean;
+    readonly databaseTypes: DatabaseType[];
+};
+declare const getDatabaseMetadata: (driverType: DatabaseDriverType) => DatabaseMetadata | null;
+declare const resolveDatabaseMetadata: (driverType: DatabaseDriverType, driverOverride?: DatabaseMetadata) => Promise<DatabaseMetadata | null>;
+declare const getDefaultDatabase: (driverType: DatabaseDriverType) => string | undefined;
+declare const getDefaultDatabaseAsync: (driverType: DatabaseDriverType) => Promise<string | undefined>;
+
 declare const DEFAULT_DATABASE_SCHEMA_NAME = "__default_database_schema__";
 declare function dumboDatabaseSchema<const Tables extends DatabaseSchemaTables = DatabaseSchemaTables>(tables: Tables): DatabaseSchemaSchemaComponent<Tables, typeof DEFAULT_DATABASE_SCHEMA_NAME>;
 declare function dumboDatabaseSchema<const Tables extends DatabaseSchemaTables = DatabaseSchemaTables, const SchemaName extends string = string>(schemaName: SchemaName, tables: Tables, options?: SchemaComponentOptions): DatabaseSchemaSchemaComponent<Tables, SchemaName>;
@@ -956,15 +1270,21 @@ type MigratorOptions = {
         options?: Omit<DatabaseLockOptions, 'lockId'> & Partial<Pick<DatabaseLockOptions, 'lockId'>>;
     };
     dryRun?: boolean | undefined;
+    ignoreMigrationHashMismatch?: boolean | undefined;
+    migrationTimeoutMs?: number | undefined;
+};
+type RunSQLMigrationsResult = {
+    applied: SQLMigration[];
+    skipped: SQLMigration[];
 };
-declare const runSQLMigrations: (pool: Dumbo, migrations: ReadonlyArray<SQLMigration>, partialOptions?: Partial<MigratorOptions>) => Promise<void>;
+declare const runSQLMigrations: (pool: Dumbo, migrations: ReadonlyArray<SQLMigration>, partialOptions?: Partial<MigratorOptions>) => Promise<RunSQLMigrationsResult>;
 declare const combineMigrations: (...migration: Pick<SQLMigration, "sqls">[]) => SQL[];
 
 interface DumboDatabaseDriver<ConnectionType extends AnyConnection = AnyConnection, DriverOptions extends unknown = unknown, DumboType extends Dumbo<ConnectionType['driverType'], ConnectionType> = Dumbo<ConnectionType['driverType'], ConnectionType>> {
     readonly driverType: ConnectionType['driverType'];
     readonly sqlFormatter: SQLFormatter;
     readonly defaultMigratorOptions: MigratorOptions;
-    getDatabaseNameOrDefault(connectionString: string): string;
+    readonly databaseMetadata: DatabaseMetadata;
     createPool(options: DumboConnectionOptions<this>): DumboType;
     canHandle(options: DumboConnectionOptions<this>): boolean;
 }
@@ -1018,223 +1338,129 @@ declare function getDatabaseDriverName<T extends DatabaseType>(databaseDriverTyp
  */
 declare function getDatabaseType<T extends DatabaseType>(databaseDriverType: DatabaseDriverType<T>): DatabaseType;
 
-interface QueryResultRow {
-    [column: string]: any;
-}
-type QueryResult<Result extends QueryResultRow = QueryResultRow> = {
-    rowCount: number | null;
-    rows: Result[];
-};
-
-type JSONSerializerOptions = {
-    disableBigIntSerialization?: boolean;
-};
-type JSONSerializeOptions = {
-    replacer?: JSONReplacer;
-} & JSONSerializerOptions;
-type JSONDeserializeOptions = {
-    reviver?: JSONReviver;
-} & JSONSerializerOptions;
-type JSONObjectCodecOptions<SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions> = {
-    serializer?: JSONSerializer<SerializeOptions, DeserializeOptions>;
-} | {
-    serializerOptions?: JSONSerializerOptions;
-};
-declare const composeJSONReplacers: (...replacers: JSONReplacer[]) => JSONReplacer;
-declare const composeJSONRevivers: (...revivers: JSONReviver[]) => JSONReviver;
-type JSONReplacer = (this: any, key: string, value: any) => any;
-declare const JSONReplacer: (opts?: JSONSerializeOptions) => JSONReplacer | undefined;
-type JSONReviver = (this: any, key: string, value: any) => any;
-declare const JSONReviver: (opts?: JSONDeserializeOptions) => JSONReviver | undefined;
-declare const JSONReplacers: {
-    bigInt: JSONReplacer;
-};
-declare const JSONRevivers: {
-    bigInt: JSONReviver;
-};
-declare const jsonSerializer: (options?: JSONSerializerOptions) => JSONSerializer;
-interface JSONSerializer<SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions> extends Serializer<string, SerializeOptions, DeserializeOptions> {
-    serialize<T>(object: T, options?: SerializeOptions): string;
-    deserialize<T>(payload: string, options?: DeserializeOptions): T;
-}
-declare const JSONSerializer: JSONSerializer<JSONSerializeOptions, JSONDeserializeOptions>;
-declare const RawJSONSerializer: JSONSerializer<JSONSerializeOptions, JSONDeserializeOptions>;
-interface JSONObjectCodec<T, SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions> extends ObjectCodec<T, string> {
-    encode(object: T, options?: SerializeOptions): string;
-    decode(payload: string, options?: DeserializeOptions): T;
-}
-declare const JSONObjectCodec: <T, SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions>(options: JSONObjectCodecOptions<SerializeOptions, DeserializeOptions>) => JSONObjectCodec<T, SerializeOptions, DeserializeOptions>;
-
-interface Serializer<Payload, SerializeOptions = never, DeserializeOptions = SerializeOptions> {
-    serialize<T>(object: T, options?: SerializeOptions): Payload;
-    deserialize<T>(payload: Payload, options?: DeserializeOptions): T;
-}
-interface ObjectCodec<T, Payload> {
-    encode(object: T): Payload;
-    decode(payload: Payload): T;
-}
-
-declare const mapColumnToJSON: (column: string, options?: JSONDeserializeOptions) => {
-    [x: string]: (value: unknown) => unknown;
-};
-declare const mapColumnToBigint: (column: string) => {
-    [x: string]: (value: unknown) => unknown;
-};
-declare const mapSQLQueryResult: <T>(result: T, mapping: SQLQueryResultColumnMapping) => T;
-type SQLQueryResultColumnMapping = {
-    [column: string]: (value: unknown) => unknown;
-};
-type SQLQueryOptions = {
-    timeoutMs?: number;
-    mapping?: SQLQueryResultColumnMapping;
-};
-type SQLCommandOptions = {
-    timeoutMs?: number;
-    mapping?: SQLQueryResultColumnMapping;
-};
-interface DbSQLExecutor<DriverType extends DatabaseDriverType = DatabaseDriverType, DbClient = unknown> {
-    driverType: DriverType;
-    query<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sql: SQL, options?: SQLQueryOptions): Promise<QueryResult<Result>>;
-    batchQuery<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sqls: SQL[], options?: SQLQueryOptions): Promise<QueryResult<Result>[]>;
-    command<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sql: SQL, options?: SQLCommandOptions): Promise<QueryResult<Result>>;
-    batchCommand<Result extends QueryResultRow = QueryResultRow>(client: DbClient, sqls: SQL[], options?: SQLCommandOptions): Promise<QueryResult<Result>[]>;
-    formatter: SQLFormatter;
-}
-interface SQLExecutor {
-    query<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: SQLQueryOptions): Promise<QueryResult<Result>>;
-    batchQuery<Result extends QueryResultRow = QueryResultRow>(sqls: SQL[], options?: SQLQueryOptions): Promise<QueryResult<Result>[]>;
-    command<Result extends QueryResultRow = QueryResultRow>(sql: SQL, options?: SQLCommandOptions): Promise<QueryResult<Result>>;
-    batchCommand<Result extends QueryResultRow = QueryResultRow>(sqls: SQL[], options?: SQLCommandOptions): Promise<QueryResult<Result>[]>;
-}
-interface WithSQLExecutor {
-    execute: SQLExecutor;
-}
-declare const sqlExecutor: <DbClient = unknown, DbExecutor extends DbSQLExecutor = DbSQLExecutor>(sqlExecutor: DbExecutor, options: {
-    connect: () => Promise<DbClient>;
-    close?: (client: DbClient, error?: unknown) => Promise<void>;
-}) => SQLExecutor;
-declare const sqlExecutorInNewConnection: <ConnectionType extends Connection>(options: {
-    driverType: ConnectionType["driverType"];
-    connection: () => Promise<ConnectionType>;
-}) => SQLExecutor;
-declare const sqlExecutorInAmbientConnection: <ConnectionType extends Connection>(options: {
-    driverType: ConnectionType["driverType"];
-    connection: () => Promise<ConnectionType>;
-}) => SQLExecutor;
-declare const executeInNewDbClient: <DbClient = unknown, Result = unknown>(handle: (client: DbClient) => Promise<Result>, options: {
-    connect: () => Promise<DbClient>;
-    close?: (client: DbClient, error?: unknown) => Promise<void>;
-}) => Promise<Result>;
-declare const executeInNewConnection: <ConnectionType extends Connection, Result>(handle: (connection: ConnectionType) => Promise<Result>, options: {
-    connection: () => Promise<ConnectionType>;
-}) => Promise<Result>;
-declare const executeInAmbientConnection: <ConnectionType extends Connection, Result>(handle: (connection: ConnectionType) => Promise<Result>, options: {
-    connection: () => Promise<ConnectionType>;
-}) => Promise<Result>;
-
-interface DatabaseTransaction<ConnectionType extends AnyConnection = AnyConnection> extends WithSQLExecutor {
+interface DatabaseTransaction<ConnectionType extends AnyConnection = AnyConnection, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> extends WithSQLExecutor {
     driverType: ConnectionType['driverType'];
     connection: ConnectionType;
     begin: () => Promise<void>;
     commit: () => Promise<void>;
     rollback: (error?: unknown) => Promise<void>;
+    _transactionOptions: TransactionOptionsType;
 }
-type AnyDatabaseTransaction = DatabaseTransaction<any>;
+type AnyDatabaseTransaction = DatabaseTransaction<any, any>;
 type DatabaseTransactionOptions = {
     allowNestedTransactions?: boolean;
+    readonly?: boolean;
 };
-interface WithDatabaseTransactionFactory<ConnectionType extends AnyConnection = AnyConnection, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> {
-    transaction: (options?: TransactionOptionsType) => TransactionType;
-    withTransaction: <Result = never>(handle: (transaction: TransactionType) => Promise<TransactionResult<Result> | Result>, options?: TransactionOptionsType) => Promise<Result>;
+type InferTransactionOptionsFromTransaction<C extends AnyDatabaseTransaction> = C extends DatabaseTransaction<any, infer TO> ? TO : never;
+interface WithDatabaseTransactionFactory<ConnectionType extends AnyConnection = AnyConnection> {
+    transaction: (options?: InferTransactionOptionsFromConnection<ConnectionType>) => InferTransactionFromConnection<ConnectionType>;
+    withTransaction: <Result = never>(handle: (transaction: InferTransactionFromConnection<ConnectionType>) => Promise<TransactionResult<Result> | Result>, options?: InferTransactionOptionsFromConnection<ConnectionType>) => Promise<Result>;
 }
 type TransactionResult<Result> = {
     success: boolean;
     result: Result;
 };
 declare const executeInTransaction: <DatabaseTransactionType extends AnyDatabaseTransaction = AnyDatabaseTransaction, Result = void>(transaction: DatabaseTransactionType, handle: (transaction: DatabaseTransactionType) => Promise<TransactionResult<Result> | Result>) => Promise<Result>;
-declare const transactionFactoryWithDbClient: <ConnectionType extends AnyConnection = AnyConnection, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions>(connect: () => Promise<InferDbClientFromConnection<ConnectionType>>, initTransaction: (client: Promise<InferDbClientFromConnection<ConnectionType>>, options?: TransactionOptionsType & {
+declare const transactionFactoryWithDbClient: <ConnectionType extends AnyConnection = AnyConnection>(connect: () => Promise<InferDbClientFromConnection<ConnectionType>>, initTransaction: (client: Promise<InferDbClientFromConnection<ConnectionType>>, options?: InferTransactionOptionsFromConnection<ConnectionType> & {
     close: (client: InferDbClientFromConnection<ConnectionType>, error?: unknown) => Promise<void>;
-}) => TransactionType) => WithDatabaseTransactionFactory<ConnectionType, TransactionType, TransactionOptionsType>;
-declare const transactionFactoryWithNewConnection: <ConnectionType extends AnyConnection = AnyConnection, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions>(connect: () => ConnectionType) => WithDatabaseTransactionFactory<ConnectionType, TransactionType, TransactionOptionsType>;
+}) => InferTransactionFromConnection<ConnectionType>) => WithDatabaseTransactionFactory<ConnectionType>;
+declare const transactionFactoryWithNewConnection: <ConnectionType extends AnyConnection = AnyConnection>(connect: () => ConnectionType) => WithDatabaseTransactionFactory<ConnectionType>;
 declare const transactionFactoryWithAmbientConnection: <ConnectionType extends AnyConnection = AnyConnection>(connect: () => ConnectionType) => WithDatabaseTransactionFactory<ConnectionType>;
+declare const transactionFactoryWithAsyncAmbientConnection: <ConnectionType extends AnyConnection = AnyConnection>(driverType: ConnectionType["driverType"], connect: () => Promise<ConnectionType>, close?: (connection: ConnectionType) => void | Promise<void>) => WithDatabaseTransactionFactory<ConnectionType>;
 
-interface Connection<Self extends AnyConnection = AnyConnection, DriverType extends DatabaseDriverType = DatabaseDriverType, DbClient = unknown, TransactionType extends DatabaseTransaction<Self> = DatabaseTransaction<Self>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> extends WithSQLExecutor, WithDatabaseTransactionFactory<Self, TransactionType, TransactionOptionsType> {
+interface Connection<Self extends AnyConnection = AnyConnection, DriverType extends DatabaseDriverType = DatabaseDriverType, DbClient = unknown, TransactionType extends DatabaseTransaction<Self, any> = DatabaseTransaction<Self, any>> extends WithSQLExecutor, WithDatabaseTransactionFactory<Self> {
     driverType: DriverType;
     open: () => Promise<DbClient>;
     close: () => Promise<void>;
+    _transactionType: TransactionType;
 }
-type AnyConnection = Connection<AnyConnection, DatabaseDriverType, unknown, AnyDatabaseTransaction, DatabaseTransactionOptions>;
-type InferDriverTypeFromConnection<C extends AnyConnection> = C extends Connection<any, infer DT, any, any, any> ? DT : never;
-type InferDbClientFromConnection<C extends AnyConnection> = C extends Connection<any, any, infer DC, any, any> ? DC : never;
-type InferTransactionFromConnection<C extends AnyConnection> = C extends Connection<any, any, any, infer DT, any> ? DT : never;
-type InferTransactionOptionsFromConnection<C extends AnyConnection> = C extends Connection<any, any, any, any, infer TO> ? TO : never;
+type AnyConnection = Connection<AnyConnection, DatabaseDriverType, unknown, AnyDatabaseTransaction>;
+type InferDriverTypeFromConnection<C extends AnyConnection> = C extends Connection<any, infer DT, any, any> ? DT : never;
+type InferDbClientFromConnection<C extends AnyConnection> = C extends Connection<any, any, infer DC, any> ? DC : never;
+type InferTransactionFromConnection<C extends AnyConnection> = C extends Connection<any, any, any, infer DT> ? DT : never;
+type InferTransactionOptionsFromConnection<C extends AnyConnection> = InferTransactionOptionsFromTransaction<InferTransactionFromConnection<C>>;
 type ConnectionOptions<ConnectionType extends AnyConnection = AnyConnection> = {
     driverType?: ConnectionType['driverType'];
     transactionOptions?: InferTransactionOptionsFromConnection<ConnectionType>;
 };
 type ConnectionFactory<ConnectionType extends AnyConnection = AnyConnection> = (options: ConnectionOptions<ConnectionType>) => ConnectionType;
+type WithConnectionOptions = {
+    readonly?: boolean;
+};
 interface WithConnectionFactory<ConnectionType extends AnyConnection = AnyConnection> {
-    connection: () => Promise<ConnectionType>;
-    withConnection: <Result = unknown>(handle: (connection: ConnectionType) => Promise<Result>) => Promise<Result>;
+    connection: (options?: WithConnectionOptions) => Promise<ConnectionType>;
+    withConnection: <Result = unknown>(handle: (connection: ConnectionType) => Promise<Result>, options?: WithConnectionOptions) => Promise<Result>;
 }
-type InitTransaction<ConnectionType extends AnyConnection = AnyConnection, TreansactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> = (connection: () => ConnectionType) => (client: Promise<InferDbClientFromConnection<ConnectionType>>, options?: TransactionOptionsType & {
+type InitTransaction<ConnectionType extends AnyConnection = AnyConnection> = (connection: () => ConnectionType) => (client: Promise<InferDbClientFromConnection<ConnectionType>>, options?: InferTransactionOptionsFromConnection<ConnectionType> & {
     close: (client: InferDbClientFromConnection<ConnectionType>, error?: unknown) => Promise<void>;
-}) => TreansactionType;
-type CreateConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> = {
+}) => InferTransactionFromConnection<ConnectionType>;
+type CreateConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor> = {
     driverType: InferDriverTypeFromConnection<ConnectionType>;
     connect: () => Promise<InferDbClientFromConnection<ConnectionType>>;
     close: (client: InferDbClientFromConnection<ConnectionType>) => Promise<void>;
-    initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
+    initTransaction: InitTransaction<ConnectionType>;
+    serializer: JSONSerializer;
+    executor: (options: DbSQLExecutorOptions) => Executor;
 };
-type CreateAmbientConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> = {
+type CreateAmbientConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor> = {
     driverType: InferDriverTypeFromConnection<ConnectionType>;
     client: InferDbClientFromConnection<ConnectionType>;
-    initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
+    serializer: JSONSerializer;
+    initTransaction: InitTransaction<ConnectionType>;
+    executor: (options: DbSQLExecutorOptions) => Executor;
 };
-declare const createAmbientConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>>(options: CreateAmbientConnectionOptions<ConnectionType, Executor, TransactionType>) => ConnectionType;
-type CreateSingletonConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> = {
+declare const createAmbientConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor>(options: CreateAmbientConnectionOptions<ConnectionType, Executor>) => ConnectionType;
+type CreateSingletonConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor> = {
     driverType: InferDriverTypeFromConnection<ConnectionType>;
     connect: () => Promise<InferDbClientFromConnection<ConnectionType>>;
     close: (client: InferDbClientFromConnection<ConnectionType>) => Promise<void>;
-    initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
+    initTransaction: InitTransaction<ConnectionType>;
+    serializer: JSONSerializer;
+    executor: (options: DbSQLExecutorOptions) => Executor;
 };
-declare const createSingletonConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>>(options: CreateSingletonConnectionOptions<ConnectionType, Executor, TransactionType>) => ConnectionType;
-type CreateTransientConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> = {
+declare const createSingletonConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor>(options: CreateSingletonConnectionOptions<ConnectionType, Executor>) => ConnectionType;
+type CreateTransientConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor> = {
     driverType: InferDriverTypeFromConnection<ConnectionType>;
     open: () => Promise<InferDbClientFromConnection<ConnectionType>>;
     close: () => Promise<void>;
-    initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
+    initTransaction: InitTransaction<ConnectionType>;
+    serializer: JSONSerializer;
+    executor: (options: DbSQLExecutorOptions) => Executor;
 };
-declare const createTransientConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>>(options: CreateTransientConnectionOptions<ConnectionType, Executor, TransactionType>) => ConnectionType;
-declare const createConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>>(options: CreateConnectionOptions<ConnectionType, Executor, TransactionType>) => ConnectionType;
+declare const createTransientConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor>(options: CreateTransientConnectionOptions<ConnectionType, Executor>) => ConnectionType;
+declare const createConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor>(options: CreateConnectionOptions<ConnectionType, Executor>) => ConnectionType;
 
-interface ConnectionPool<ConnectionType extends AnyConnection = AnyConnection, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> extends WithSQLExecutor, WithConnectionFactory<ConnectionType>, WithDatabaseTransactionFactory<ConnectionType, TransactionType, TransactionOptionsType> {
+interface ConnectionPool<ConnectionType extends AnyConnection = AnyConnection> extends WithSQLExecutor, WithConnectionFactory<ConnectionType>, WithDatabaseTransactionFactory<ConnectionType> {
     driverType: ConnectionType['driverType'];
     close: () => Promise<void>;
 }
 type ConnectionPoolFactory<ConnectionPoolType extends ConnectionPool = ConnectionPool, ConnectionPoolOptions = unknown> = (options: ConnectionPoolOptions) => ConnectionPoolType;
-declare const createAmbientConnectionPool: <ConnectionType extends AnyConnection>(options: {
-    driverType: ConnectionType["driverType"];
+type AmbientConnectionPoolOptions<ConnectionType extends AnyConnection> = {
+    driverType: ConnectionType['driverType'];
     connection: ConnectionType;
-}) => ConnectionPool<ConnectionType>;
-type CreateSingletonConnectionPoolOptions<ConnectionType extends AnyConnection> = {
+};
+declare const createAmbientConnectionPool: <ConnectionType extends AnyConnection>(options: AmbientConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
+type SingletonConnectionPoolOptions<ConnectionType extends AnyConnection> = {
     driverType: ConnectionType['driverType'];
-    getConnection: () => ConnectionType;
+    getConnection: () => ConnectionType | Promise<ConnectionType>;
+    closeConnection?: (connection: ConnectionType) => void | Promise<void>;
     connectionOptions?: never;
 };
-declare const createSingletonConnectionPool: <ConnectionType extends AnyConnection>(options: CreateSingletonConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
-type CreateSingletonClientPoolOptions<ConnectionType extends AnyConnection> = {
+declare const createSingletonConnectionPool: <ConnectionType extends AnyConnection>(options: SingletonConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
+type CreateBoundedConnectionPoolOptions<ConnectionType extends AnyConnection> = {
+    driverType: ConnectionType['driverType'];
+    getConnection: () => ConnectionType | Promise<ConnectionType>;
+    maxConnections: number;
+};
+declare const createBoundedConnectionPool: <ConnectionType extends AnyConnection>(options: CreateBoundedConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
+type SingletonClientConnectionPoolOptions<ConnectionType extends AnyConnection> = {
     driverType: ConnectionType['driverType'];
     dbClient: InferDbClientFromConnection<ConnectionType>;
     connectionFactory: (options: {
         dbClient: InferDbClientFromConnection<ConnectionType>;
     }) => ConnectionType;
 };
-declare const createSingletonClientPool: <ConnectionType extends AnyConnection>(options: CreateSingletonClientPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
+declare const createSingletonClientConnectionPool: <ConnectionType extends AnyConnection>(options: SingletonClientConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
 type CreateAlwaysNewConnectionPoolOptions<ConnectionType extends AnyConnection, ConnectionOptions extends Record<string, unknown> | undefined = undefined> = ConnectionOptions extends undefined ? {
     driverType: ConnectionType['driverType'];
     getConnection: () => ConnectionType;
@@ -1268,4 +1494,4 @@ type DatabaseConnectionString<DatabaseTypeName extends DatabaseType = DatabaseTy
 };
 declare const parseConnectionString: (connectionString: DatabaseConnectionString | string) => DatabaseDriverTypeParts;
 
-export { type CreateAlwaysNewConnectionPoolOptions as $, type AnySQLToken as A, type ConnectionOptions as B, type Connection as C, type DatabaseTransaction as D, type ExtractDumboTypeFromDriver as E, type ConnectionFactory as F, type InitTransaction as G, type CreateConnectionOptions as H, IndexURN as I, type CreateAmbientConnectionOptions as J, createAmbientConnection as K, type CreateSingletonConnectionOptions as L, type MigratorOptions as M, createSingletonConnection as N, type CreateTransientConnectionOptions as O, createTransientConnection as P, type QueryResultRow as Q, createConnection as R, SQLFormatter as S, TableURN as T, type ConnectionPoolFactory as U, createAmbientConnectionPool as V, type WithConnectionFactory as W, type CreateSingletonConnectionPoolOptions as X, createSingletonConnectionPool as Y, type CreateSingletonClientPoolOptions as Z, createSingletonClientPool as _, type DatabaseTransactionOptions as a, type ExtractColumnNames as a$, createAlwaysNewConnectionPool as a0, type CreateConnectionPoolOptions as a1, createConnectionPool as a2, type AnyDatabaseTransaction as a3, type WithDatabaseTransactionFactory as a4, type TransactionResult as a5, executeInTransaction as a6, transactionFactoryWithDbClient as a7, transactionFactoryWithNewConnection as a8, transactionFactoryWithAmbientConnection as a9, type DatabaseLockOptions as aA, type AcquireDatabaseLockMode as aB, type AcquireDatabaseLockOptions as aC, type ReleaseDatabaseLockOptions as aD, defaultDatabaseLockOptions as aE, type DatabaseLock as aF, NoDatabaseLock as aG, ColumnURNType as aH, type ColumnSchemaComponent as aI, type AnyColumnSchemaComponent as aJ, type ColumnSchemaComponentOptions as aK, columnSchemaComponent as aL, DatabaseURNType as aM, type DatabaseSchemas as aN, type DatabaseSchemaComponent as aO, type AnyDatabaseSchemaComponent as aP, databaseSchemaComponent as aQ, DatabaseSchemaURNType as aR, type DatabaseSchemaTables as aS, type DatabaseSchemaSchemaComponent as aT, type AnyDatabaseSchemaSchemaComponent as aU, databaseSchemaSchemaComponent as aV, IndexURNType as aW, type IndexSchemaComponent as aX, indexSchemaComponent as aY, type ExtractSchemaNames as aZ, type ExtractTableNames as a_, type DatabaseType as aa, type DatabaseDriverName as ab, type InferDriverDatabaseType as ac, type DatabaseDriverTypeParts as ad, toDatabaseDriverType as ae, fromDatabaseDriverType as af, getDatabaseDriverName as ag, getDatabaseType as ah, type ExtractDumboDatabaseDriverOptions as ai, canHandleDriverWithConnectionString as aj, DumboDatabaseDriverRegistry as ak, dumboDatabaseDriverRegistry as al, mapColumnToJSON as am, mapColumnToBigint as an, mapSQLQueryResult as ao, type SQLQueryResultColumnMapping as ap, type SQLQueryOptions as aq, type SQLCommandOptions as ar, type SQLExecutor as as, type WithSQLExecutor as at, sqlExecutor as au, sqlExecutorInNewConnection as av, sqlExecutorInAmbientConnection as aw, executeInNewDbClient as ax, executeInNewConnection as ay, executeInAmbientConnection as az, type ConnectionPool as b, type InferColumnType as b$, type ExtractColumnTypeName as b0, type AllColumnTypes as b1, type AllColumnReferences as b2, type AllColumnTypesInSchema as b3, type AllColumnReferencesInSchema as b4, type NormalizeReference as b5, type NormalizeColumnPath as b6, type ColumnName as b7, type TableColumnName as b8, type SchemaColumnName as b9, type CollectReferencesErrors as bA, type SchemaTablesWithSingle as bB, type DatabaseSchemasWithSingle as bC, type ValidateRelationship as bD, type CollectRelationshipErrors as bE, type ValidateTableRelationships as bF, type ValidateTable as bG, type ValidateSchemaTables as bH, type ValidateDatabaseSchema as bI, type ValidateDatabaseSchemas as bJ, type ValidateDatabaseSchemasWithMessages as bK, type Join as bL, type IndentErrors as bM, type FormatSingleError as bN, type FormatRelationshipBlock as bO, type FormatTableLevel as bP, type FormatSchemaLevel as bQ, type FormatDatabaseValidationErrors as bR, type FormatValidationErrors as bS, TableURNType as bT, type TableColumns as bU, type TableSchemaComponent as bV, type InferTableSchemaComponentTypes as bW, type InferTableSchemaComponentColumns as bX, type AnyTableSchemaComponent as bY, tableSchemaComponent as bZ, type Writable as b_, type ColumnPath as ba, type ColumnReference as bb, type ColumnPathToReference as bc, type ParseReferencePath as bd, type LookupColumnType as be, type RelationshipType as bf, type RelationshipDefinition as bg, type AnyTableRelationshipDefinition as bh, type AnyTableRelationshipDefinitionWithColumns as bi, type TableRelationships as bj, relationship as bk, type AnyRelationshipDefinition as bl, type RelationshipColumnsMismatchError as bm, type RelationshipReferencesLengthMismatchError as bn, type ColumnReferenceExistanceError as bo, type ColumnReferenceTypeMismatchError as bp, type NoError as bq, type ColumnReferenceError as br, type RelationshipValidationError as bs, type ValidateRelationshipLength as bt, type ValidateRelationshipColumns as bu, type ValidateColumnReference as bv, type ValidateColumnTypeMatch as bw, type ValidateColumnsMatch as bx, type ValidateReference as by, type ValidateReferences as bz, type DbSQLExecutor as c, ColumnTypeToken as c$, type TableColumnType as c0, type TableColumnNames as c1, type InferTableRow as c2, type TableRowType as c3, type InferSchemaTables as c4, type InferDatabaseSchemas as c5, dumboSchema as c6, MIGRATIONS_LOCK_ID as c7, registerDefaultMigratorOptions as c8, getDefaultMigratorOptionsFromRegistry as c9, RawJSONSerializer as cA, JSONObjectCodec as cB, type JSONObjectCodecOptions as cC, type JSONSerializerOptions as cD, type JSONSerializeOptions as cE, type JSONDeserializeOptions as cF, type FormatSQLOptions as cG, type SQLFormatterOptions as cH, registerFormatter as cI, getFormatter as cJ, formatSQL as cK, describeSQL as cL, type ParametrizedSQL as cM, ParametrizedSQLBuilder as cN, defaultProcessorsRegistry as cO, type SQLProcessorContext as cP, type AnySQLProcessor as cQ, type SQLProcessorOptions as cR, type SQLProcessorsReadonlyRegistry as cS, SQLProcessorsRegistry as cT, SQL as cU, isSQL as cV, type JSONValueType as cW, type JSONValueTypeName as cX, type JavaScriptValueType as cY, type JavaScriptValueTypeName as cZ, type JavaScriptValueTypeToNameMap as c_, runSQLMigrations as ca, combineMigrations as cb, type ExtractAdditionalData as cc, type AnySchemaComponent as cd, type AnySchemaComponentOfType as ce, type SchemaComponentOptions as cf, type SchemaComponentType as cg, type DumboSchemaComponentType as ch, schemaComponent as ci, isSchemaComponentOfType as cj, filterSchemaComponentsOfType as ck, mapSchemaComponentsOfType as cl, findSchemaComponentsOfType as cm, type MigrationStyle as cn, sqlMigration as co, type MigrationRecord as cp, type Serializer as cq, type ObjectCodec as cr, composeJSONReplacers as cs, composeJSONRevivers as ct, JSONReplacer as cu, JSONReplacers as cv, JSONReviver as cw, JSONRevivers as cx, JSONSerializer as cy, jsonSerializer as cz, type DumboDatabaseDriver as d, type AnyColumnTypeToken as d0, SerialToken as d1, BigSerialToken as d2, IntegerToken as d3, BigIntegerToken as d4, JSONBToken as d5, TimestampToken as d6, TimestamptzToken as d7, VarcharToken as d8, type NotNullableSQLColumnTokenProps as d9, type NullableSQLColumnTokenProps as da, SQLColumnToken as db, AutoIncrementSQLColumnToken as dc, SQLColumnTypeTokens as dd, SQLColumnTypeTokensFactory as de, type DefaultSQLColumnToken as df, SQLToken as dg, type ExtractSQLTokenType as dh, SQLPlain as di, type SQLDefaultTokens as dj, type SQLDefaultTokensTypes as dk, SQLValueMapper as dl, type MapSQLParamValue as dm, type MapSQLParamValueOptions as dn, ANSISQLParamPlaceholder as dp, ANSISQLIdentifierQuote as dq, mapANSISQLParamPlaceholder as dr, mapSQLIdentifier as ds, DefaultMapSQLParamValueOptions as dt, mapSQLParamValue as du, type DatabaseConnectionString as dv, parseConnectionString as dw, type Dumbo as e, type DumboConnectionOptions as f, SQLProcessor as g, SQLArray as h, SQLIn as i, SQLIdentifier as j, SQLLiteral as k, DatabaseURN as l, DatabaseSchemaURN as m, ColumnURN as n, type SchemaComponent as o, type SQLMigration as p, type DatabaseDriverType as q, type QueryResult as r, type AnyTypeValidationError as s, type TypeValidationSuccess as t, type AnyDumboDatabaseDriver as u, type AnyConnection as v, type InferDriverTypeFromConnection as w, type InferDbClientFromConnection as x, type InferTransactionFromConnection as y, type InferTransactionOptionsFromConnection as z };
+export { type AnyDatabaseSchemaSchemaComponent as $, type AnyConnection as A, type AnyTypeValidationError as B, type Connection as C, type DefaultSQLColumnToken as D, type TypeValidationSuccess as E, type AnyDumboDatabaseDriver as F, type ExtractDumboDatabaseDriverOptions as G, type ExtractDumboTypeFromDriver as H, IndexURN as I, JSONSerializer as J, ANSISQLIdentifierQuote as K, ANSISQLParamPlaceholder as L, type MigratorOptions as M, type AcquireDatabaseLockMode as N, type AcquireDatabaseLockOptions as O, AdminShutdownError as P, type QueryResultRow as Q, type AllColumnReferences as R, SQLColumnTypeTokens as S, TableURN as T, type AllColumnReferencesInSchema as U, type AllColumnTypes as V, type AllColumnTypesInSchema as W, type AmbientConnectionPoolOptions as X, type AnyColumnSchemaComponent as Y, type AnyColumnTypeToken as Z, type AnyDatabaseSchemaComponent as _, SQLProcessor as a, type ExtractSQLTokenType as a$, type AnyDatabaseTransaction as a0, type AnyRelationshipDefinition as a1, type AnySQLProcessor as a2, type AnySchemaComponent as a3, type AnySchemaComponentOfType as a4, type AnyTableRelationshipDefinition as a5, type AnyTableRelationshipDefinitionWithColumns as a6, type AnyTableSchemaComponent as a7, AutoIncrementSQLColumnToken as a8, BatchCommandNoChangesError as a9, type CreateSingletonConnectionOptions as aA, type CreateTransientConnectionOptions as aB, DataError as aC, type DatabaseCapabilities as aD, type DatabaseConnectionString as aE, type DatabaseDriverName as aF, type DatabaseDriverTypeParts as aG, type DatabaseLock as aH, type DatabaseLockOptions as aI, type DatabaseSchemaComponent as aJ, type DatabaseSchemaSchemaComponent as aK, type DatabaseSchemaTables as aL, DatabaseSchemaURNType as aM, type DatabaseSchemas as aN, type DatabaseSchemasWithSingle as aO, type DatabaseType as aP, DatabaseURNType as aQ, type DbSQLExecutorOptions as aR, DeadlockError as aS, DefaultMapSQLParamValueOptions as aT, DumboDatabaseDriverRegistry as aU, DumboDatabaseMetadataRegistry as aV, type DumboSchemaComponentType as aW, ExclusionViolationError as aX, type ExtractAdditionalData as aY, type ExtractColumnNames as aZ, type ExtractColumnTypeName as a_, type BatchSQLCommandOptions as aa, BigIntegerToken as ab, BigSerialToken as ac, CheckViolationError as ad, type CollectReferencesErrors as ae, type CollectRelationshipErrors as af, type ColumnName as ag, type ColumnPath as ah, type ColumnPathToReference as ai, type ColumnReference as aj, type ColumnReferenceError as ak, type ColumnReferenceExistanceError as al, type ColumnReferenceTypeMismatchError as am, type ColumnSchemaComponent as an, type ColumnSchemaComponentOptions as ao, ColumnTypeToken as ap, ColumnURNType as aq, ConcurrencyError as ar, ConnectionError as as, type ConnectionFactory as at, type ConnectionPoolFactory as au, type CreateAlwaysNewConnectionPoolOptions as av, type CreateAmbientConnectionOptions as aw, type CreateBoundedConnectionPoolOptions as ax, type CreateConnectionOptions as ay, type CreateConnectionPoolOptions as az, type SQLProcessorContext as b, ParametrizedSQLBuilder as b$, type ExtractSchemaNames as b0, type ExtractTableNames as b1, ForeignKeyViolationError as b2, type FormatContext as b3, type FormatDatabaseValidationErrors as b4, type FormatRelationshipBlock as b5, type FormatSQLOptions as b6, type FormatSchemaLevel as b7, type FormatSingleError as b8, type FormatTableLevel as b9, JSONReplacers as bA, JSONReviver as bB, type JSONReviverContext as bC, JSONRevivers as bD, type JSONSerializeOptions as bE, type JSONSerializerOptions as bF, type JSONValueType as bG, type JSONValueTypeName as bH, type JavaScriptValueType as bI, type JavaScriptValueTypeName as bJ, type JavaScriptValueTypeToNameMap as bK, type Join as bL, LockNotAvailableError as bM, type LookupColumnType as bN, MIGRATIONS_LOCK_ID as bO, type MapSQLParamValue as bP, type MapSQLParamValueOptions as bQ, type MigrationRecord as bR, type MigrationStyle as bS, NoDatabaseLock as bT, type NoError as bU, type NormalizeColumnPath as bV, type NormalizeReference as bW, NotNullViolationError as bX, type NotNullableSQLColumnTokenProps as bY, type NullableSQLColumnTokenProps as bZ, type ParametrizedSQL as b_, type FormatValidationErrors as ba, type IndentErrors as bb, type IndexSchemaComponent as bc, IndexURNType as bd, type InferColumnType as be, type InferDatabaseSchemas as bf, type InferDbClientFromConnection as bg, type InferDriverDatabaseType as bh, type InferDriverTypeFromConnection as bi, type InferSchemaTables as bj, type InferTableRow as bk, type InferTableSchemaComponentColumns as bl, type InferTableSchemaComponentTypes as bm, type InferTransactionFromConnection as bn, type InferTransactionOptionsFromConnection as bo, type InferTransactionOptionsFromTransaction as bp, type InitTransaction as bq, InsufficientResourcesError as br, IntegerToken as bs, IntegrityConstraintViolationError as bt, InvalidOperationError as bu, JSONBToken as bv, JSONCodec as bw, type JSONCodecOptions as bx, type JSONDeserializeOptions as by, JSONReplacer as bz, type DumboConnectionOptions as c, type ValidateTable as c$, type ParseReferencePath as c0, QueryCanceledError as c1, RawSQL as c2, type RelationshipColumnsMismatchError as c3, type RelationshipDefinition as c4, type RelationshipReferencesLengthMismatchError as c5, type RelationshipType as c6, type RelationshipValidationError as c7, type ReleaseDatabaseLockOptions as c8, type RunSQLMigrationsResult as c9, type SingletonConnectionPoolOptions as cA, SystemError as cB, type TableColumnName as cC, type TableColumnNames as cD, type TableColumnType as cE, type TableColumns as cF, type TableRelationships as cG, type TableRowType as cH, type TableSchemaComponent as cI, TableURNType as cJ, TimestampToken as cK, TimestamptzToken as cL, type TransactionResult as cM, TransientDatabaseError as cN, UniqueConstraintError as cO, type ValidateColumnReference as cP, type ValidateColumnTypeMatch as cQ, type ValidateColumnsMatch as cR, type ValidateDatabaseSchema as cS, type ValidateDatabaseSchemas as cT, type ValidateDatabaseSchemasWithMessages as cU, type ValidateReference as cV, type ValidateReferences as cW, type ValidateRelationship as cX, type ValidateRelationshipColumns as cY, type ValidateRelationshipLength as cZ, type ValidateSchemaTables as c_, SQL as ca, type SQLArrayMode as cb, SQLColumnToken as cc, SQLColumnTypeTokensFactory as cd, type SQLCommandOptions as ce, type SQLDefaultTokens as cf, type SQLDefaultTokensTypes as cg, type SQLExecutor as ch, type SQLFormatterOptions as ci, SQLPlain as cj, type SQLProcessorOptions as ck, type SQLProcessorsReadonlyRegistry as cl, SQLProcessorsRegistry as cm, type SQLQueryOptions as cn, type SQLQueryResultColumnMapping as co, SQLToken as cp, SQLValueMapper as cq, type SchemaColumnName as cr, type SchemaComponentOptions as cs, type SchemaComponentType as ct, type SchemaTablesWithSingle as cu, SerialToken as cv, type SerializationCodec as cw, SerializationError as cx, type Serializer as cy, type SingletonClientConnectionPoolOptions as cz, type DumboDatabaseDriver as d, runSQLMigrations as d$, type ValidateTableRelationships as d0, VarcharToken as d1, type WithConnectionFactory as d2, type WithConnectionOptions as d3, type WithDatabaseTransactionFactory as d4, type WithSQLExecutor as d5, type Writable as d6, canHandleDriverWithConnectionString as d7, columnSchemaComponent as d8, combineMigrations as d9, findSchemaComponentsOfType as dA, formatSQL as dB, fromDatabaseDriverType as dC, getDatabaseDriverName as dD, getDatabaseMetadata as dE, getDatabaseType as dF, getDefaultDatabase as dG, getDefaultDatabaseAsync as dH, getDefaultMigratorOptionsFromRegistry as dI, getFormatter as dJ, indexSchemaComponent as dK, isSQL as dL, isSchemaComponentOfType as dM, jsonSerializer as dN, mapANSISQLParamPlaceholder as dO, mapColumnToBigint as dP, mapColumnToDate as dQ, mapColumnToJSON as dR, mapSQLIdentifier as dS, mapSQLParamValue as dT, mapSQLQueryResult as dU, mapSchemaComponentsOfType as dV, parseConnectionString as dW, registerDefaultMigratorOptions as dX, registerFormatter as dY, relationship as dZ, resolveDatabaseMetadata as d_, composeJSONReplacers as da, composeJSONRevivers as db, createAlwaysNewConnectionPool as dc, createAmbientConnection as dd, createAmbientConnectionPool as de, createBoundedConnectionPool as df, createConnection as dg, createConnectionPool as dh, createSingletonClientConnectionPool as di, createSingletonConnection as dj, createSingletonConnectionPool as dk, createTransientConnection as dl, databaseSchemaComponent as dm, databaseSchemaSchemaComponent as dn, defaultDatabaseLockOptions as dp, defaultProcessorsRegistry as dq, describeSQL as dr, dumboDatabaseDriverRegistry as ds, dumboDatabaseMetadataRegistry as dt, dumboSchema as du, executeInAmbientConnection as dv, executeInNewConnection as dw, executeInNewDbClient as dx, executeInTransaction as dy, filterSchemaComponentsOfType as dz, type ConnectionOptions as e, schemaComponent as e0, sqlExecutor as e1, sqlExecutorInAmbientConnection as e2, sqlExecutorInNewConnection as e3, sqlMigration as e4, tableSchemaComponent as e5, toDatabaseDriverType as e6, transactionFactoryWithAmbientConnection as e7, transactionFactoryWithAsyncAmbientConnection as e8, transactionFactoryWithDbClient as e9, transactionFactoryWithNewConnection as ea, SQLFormatter as f, type DatabaseMetadata as g, type DatabaseTransactionOptions as h, type DatabaseTransaction as i, type ConnectionPool as j, type JSONSerializationOptions as k, type DbSQLExecutor as l, DumboError as m, SQLArray as n, SQLIn as o, SQLIdentifier as p, SQLLiteral as q, type AnySQLToken as r, DatabaseURN as s, DatabaseSchemaURN as t, ColumnURN as u, type QueryResult as v, type SchemaComponent as w, type DatabaseDriverType as x, type Dumbo as y, type SQLMigration as z };