@event-driven-io/dumbo 0.13.0-beta.2 → 0.13.0-beta.21

package/dist/{connectionString-B1wm0TFc.d.cts → connectionString-oeg1LD5V.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;
 };
-declare const runSQLMigrations: (pool: Dumbo, migrations: ReadonlyArray<SQLMigration>, partialOptions?: Partial<MigratorOptions>) => Promise<void>;
+type RunSQLMigrationsResult = {
+    applied: SQLMigration[];
+    skipped: SQLMigration[];
+};
+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,120 +1338,6 @@ 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 {
     driverType: ConnectionType['driverType'];
     connection: ConnectionType;
@@ -1142,6 +1348,7 @@ interface DatabaseTransaction<ConnectionType extends AnyConnection = AnyConnecti
 type AnyDatabaseTransaction = DatabaseTransaction<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;
@@ -1173,9 +1380,12 @@ type ConnectionOptions<ConnectionType extends AnyConnection = AnyConnection> = {
     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>;
+    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 & {
     close: (client: InferDbClientFromConnection<ConnectionType>, error?: unknown) => Promise<void>;
@@ -1185,13 +1395,15 @@ type CreateConnectionOptions<ConnectionType extends AnyConnection = AnyConnectio
     connect: () => Promise<InferDbClientFromConnection<ConnectionType>>;
     close: (client: InferDbClientFromConnection<ConnectionType>) => Promise<void>;
     initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
+    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> = {
     driverType: InferDriverTypeFromConnection<ConnectionType>;
     client: InferDbClientFromConnection<ConnectionType>;
+    serializer: JSONSerializer;
     initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
+    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> = {
@@ -1199,7 +1411,8 @@ type CreateSingletonConnectionOptions<ConnectionType extends AnyConnection = Any
     connect: () => Promise<InferDbClientFromConnection<ConnectionType>>;
     close: (client: InferDbClientFromConnection<ConnectionType>) => Promise<void>;
     initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
+    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> = {
@@ -1207,7 +1420,8 @@ type CreateTransientConnectionOptions<ConnectionType extends AnyConnection = Any
     open: () => Promise<InferDbClientFromConnection<ConnectionType>>;
     close: () => Promise<void>;
     initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
+    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;
@@ -1217,24 +1431,25 @@ interface ConnectionPool<ConnectionType extends AnyConnection = AnyConnection, T
     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;
     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 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 +1483,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 CreateTransientConnectionOptions as $, type AnyConnection as A, type Dumbo as B, type Connection as C, type DefaultSQLColumnToken as D, type AnyTypeValidationError as E, type TypeValidationSuccess as F, type AnyDumboDatabaseDriver as G, type ExtractDumboDatabaseDriverOptions as H, type InferTransactionFromConnection as I, JSONSerializer as J, type ExtractDumboTypeFromDriver as K, type InferDriverTypeFromConnection as L, type MigratorOptions as M, type InferDbClientFromConnection as N, type ConnectionOptions as O, type ConnectionFactory as P, type QueryResultRow as Q, type WithConnectionFactory as R, SQLColumnTypeTokens as S, TableURN as T, type InitTransaction as U, type CreateConnectionOptions as V, type WithConnectionOptions as W, type CreateAmbientConnectionOptions as X, createAmbientConnection as Y, type CreateSingletonConnectionOptions as Z, createSingletonConnection as _, SQLProcessor as a, sqlExecutorInAmbientConnection as a$, createTransientConnection as a0, createConnection as a1, type ConnectionPoolFactory as a2, type AmbientConnectionPoolOptions as a3, createAmbientConnectionPool as a4, type SingletonConnectionPoolOptions as a5, createSingletonConnectionPool as a6, type SingletonClientConnectionPoolOptions as a7, createSingletonClientConnectionPool as a8, type CreateAlwaysNewConnectionPoolOptions as a9, LockNotAvailableError as aA, InsufficientResourcesError as aB, SystemError as aC, AdminShutdownError as aD, QueryCanceledError as aE, IntegrityConstraintViolationError as aF, UniqueConstraintError as aG, ForeignKeyViolationError as aH, NotNullViolationError as aI, CheckViolationError as aJ, ExclusionViolationError as aK, DataError as aL, InvalidOperationError as aM, mapColumnToJSON as aN, mapColumnToBigint as aO, mapColumnToDate as aP, mapSQLQueryResult as aQ, type SQLQueryResultColumnMapping as aR, type SQLQueryOptions as aS, type SQLCommandOptions as aT, type BatchSQLCommandOptions as aU, BatchCommandNoChangesError as aV, type DbSQLExecutorOptions as aW, type SQLExecutor as aX, type WithSQLExecutor as aY, sqlExecutor as aZ, sqlExecutorInNewConnection as a_, createAlwaysNewConnectionPool as aa, type CreateConnectionPoolOptions as ab, createConnectionPool as ac, type AnyDatabaseTransaction as ad, type WithDatabaseTransactionFactory as ae, type TransactionResult as af, executeInTransaction as ag, transactionFactoryWithDbClient as ah, transactionFactoryWithNewConnection as ai, transactionFactoryWithAmbientConnection as aj, type DatabaseType as ak, type DatabaseDriverName as al, type InferDriverDatabaseType as am, type DatabaseDriverTypeParts as an, toDatabaseDriverType as ao, fromDatabaseDriverType as ap, getDatabaseDriverName as aq, getDatabaseType as ar, canHandleDriverWithConnectionString as as, DumboDatabaseDriverRegistry as at, dumboDatabaseDriverRegistry as au, ConcurrencyError as av, TransientDatabaseError as aw, ConnectionError as ax, SerializationError as ay, DeadlockError as az, type SQLProcessorContext as b, type ValidateColumnTypeMatch as b$, executeInNewDbClient as b0, executeInNewConnection as b1, executeInAmbientConnection as b2, type DatabaseLockOptions as b3, type AcquireDatabaseLockMode as b4, type AcquireDatabaseLockOptions as b5, type ReleaseDatabaseLockOptions as b6, defaultDatabaseLockOptions as b7, type DatabaseLock as b8, NoDatabaseLock as b9, type NormalizeReference as bA, type NormalizeColumnPath as bB, type ColumnName as bC, type TableColumnName as bD, type SchemaColumnName as bE, type ColumnPath as bF, type ColumnReference as bG, type ColumnPathToReference as bH, type ParseReferencePath as bI, type LookupColumnType as bJ, type RelationshipType as bK, type RelationshipDefinition as bL, type AnyTableRelationshipDefinition as bM, type AnyTableRelationshipDefinitionWithColumns as bN, type TableRelationships as bO, relationship as bP, type AnyRelationshipDefinition as bQ, type RelationshipColumnsMismatchError as bR, type RelationshipReferencesLengthMismatchError as bS, type ColumnReferenceExistanceError as bT, type ColumnReferenceTypeMismatchError as bU, type NoError as bV, type ColumnReferenceError as bW, type RelationshipValidationError as bX, type ValidateRelationshipLength as bY, type ValidateRelationshipColumns as bZ, type ValidateColumnReference as b_, ColumnURNType as ba, type ColumnSchemaComponent as bb, type AnyColumnSchemaComponent as bc, type ColumnSchemaComponentOptions as bd, columnSchemaComponent as be, DatabaseURNType as bf, type DatabaseSchemas as bg, type DatabaseSchemaComponent as bh, type AnyDatabaseSchemaComponent as bi, databaseSchemaComponent as bj, DatabaseSchemaURNType as bk, type DatabaseSchemaTables as bl, type DatabaseSchemaSchemaComponent as bm, type AnyDatabaseSchemaSchemaComponent as bn, databaseSchemaSchemaComponent as bo, IndexURNType as bp, type IndexSchemaComponent as bq, indexSchemaComponent as br, type ExtractSchemaNames as bs, type ExtractTableNames as bt, type ExtractColumnNames as bu, type ExtractColumnTypeName as bv, type AllColumnTypes as bw, type AllColumnReferences as bx, type AllColumnTypesInSchema as by, type AllColumnReferencesInSchema as bz, type DumboDatabaseDriver as c, sqlMigration as c$, type ValidateColumnsMatch as c0, type ValidateReference as c1, type ValidateReferences as c2, type CollectReferencesErrors as c3, type SchemaTablesWithSingle as c4, type DatabaseSchemasWithSingle as c5, type ValidateRelationship as c6, type CollectRelationshipErrors as c7, type ValidateTableRelationships as c8, type ValidateTable as c9, type InferDatabaseSchemas as cA, type DatabaseCapabilities as cB, DumboDatabaseMetadataRegistry as cC, dumboDatabaseMetadataRegistry as cD, getDatabaseMetadata as cE, resolveDatabaseMetadata as cF, getDefaultDatabase as cG, getDefaultDatabaseAsync as cH, dumboSchema as cI, MIGRATIONS_LOCK_ID as cJ, registerDefaultMigratorOptions as cK, getDefaultMigratorOptionsFromRegistry as cL, type RunSQLMigrationsResult as cM, runSQLMigrations as cN, combineMigrations as cO, type ExtractAdditionalData as cP, type AnySchemaComponent as cQ, type AnySchemaComponentOfType as cR, type SchemaComponentOptions as cS, type SchemaComponentType as cT, type DumboSchemaComponentType as cU, schemaComponent as cV, isSchemaComponentOfType as cW, filterSchemaComponentsOfType as cX, mapSchemaComponentsOfType as cY, findSchemaComponentsOfType as cZ, type MigrationStyle as c_, type ValidateSchemaTables as ca, type ValidateDatabaseSchema as cb, type ValidateDatabaseSchemas as cc, type ValidateDatabaseSchemasWithMessages as cd, type Join as ce, type IndentErrors as cf, type FormatSingleError as cg, type FormatRelationshipBlock as ch, type FormatTableLevel as ci, type FormatSchemaLevel as cj, type FormatDatabaseValidationErrors as ck, type FormatValidationErrors as cl, TableURNType as cm, type TableColumns as cn, type TableSchemaComponent as co, type InferTableSchemaComponentTypes as cp, type InferTableSchemaComponentColumns as cq, type AnyTableSchemaComponent as cr, tableSchemaComponent as cs, type Writable as ct, type InferColumnType as cu, type TableColumnType as cv, type TableColumnNames as cw, type InferTableRow as cx, type TableRowType as cy, type InferSchemaTables as cz, SQLFormatter as d, ANSISQLParamPlaceholder as d$, type MigrationRecord as d0, type Serializer as d1, type SerializationCodec as d2, composeJSONReplacers as d3, composeJSONRevivers as d4, JSONCodec as d5, JSONReplacer as d6, JSONReplacers as d7, JSONReviver as d8, JSONRevivers as d9, type JavaScriptValueType as dA, type JavaScriptValueTypeName as dB, type JavaScriptValueTypeToNameMap as dC, ColumnTypeToken as dD, type AnyColumnTypeToken as dE, SerialToken as dF, BigSerialToken as dG, IntegerToken as dH, BigIntegerToken as dI, JSONBToken as dJ, TimestampToken as dK, TimestamptzToken as dL, VarcharToken as dM, type NotNullableSQLColumnTokenProps as dN, type NullableSQLColumnTokenProps as dO, SQLColumnToken as dP, AutoIncrementSQLColumnToken as dQ, SQLColumnTypeTokensFactory as dR, SQLToken as dS, type ExtractSQLTokenType as dT, SQLPlain as dU, type SQLArrayMode as dV, type SQLDefaultTokens as dW, type SQLDefaultTokensTypes as dX, SQLValueMapper as dY, type MapSQLParamValue as dZ, type MapSQLParamValueOptions as d_, jsonSerializer as da, type JSONCodecOptions as db, type JSONDeserializeOptions as dc, type JSONSerializeOptions as dd, type JSONSerializerOptions as de, type JSONReviverContext as df, type FormatContext as dg, type FormatSQLOptions as dh, type SQLFormatterOptions as di, registerFormatter as dj, getFormatter as dk, formatSQL as dl, describeSQL as dm, type ParametrizedSQL as dn, ParametrizedSQLBuilder as dp, defaultProcessorsRegistry as dq, type AnySQLProcessor as dr, type SQLProcessorOptions as ds, type SQLProcessorsReadonlyRegistry as dt, SQLProcessorsRegistry as du, SQL as dv, RawSQL as dw, isSQL as dx, type JSONValueType as dy, type JSONValueTypeName as dz, type DatabaseMetadata as e, ANSISQLIdentifierQuote as e0, mapANSISQLParamPlaceholder as e1, mapSQLIdentifier as e2, DefaultMapSQLParamValueOptions as e3, mapSQLParamValue as e4, type DatabaseConnectionString as e5, parseConnectionString as e6, type DumboConnectionOptions as f, type DatabaseTransactionOptions as g, type DatabaseTransaction as h, type ConnectionPool as i, type InferTransactionOptionsFromConnection 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, IndexURN as v, type QueryResult as w, type SchemaComponent as x, type SQLMigration as y, type DatabaseDriverType as z };