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

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