@event-driven-io/dumbo 0.13.0-beta.42 → 0.13.0-beta.43

package/dist/index.d.ts

@@ -1,2 +1,1676 @@
-import { $ as DatabaseTransactionOptions, $a as SerialToken, $i as ExtractAdditionalData, $n as RelationshipColumnsMismatchError, $r as AllColumnReferences, $t as SQLExecutor, A as createSingletonClientConnectionPool, Aa as SQLValueMapper, Ai as ColumnSchemaComponentOptions, An as DataError, Ao as composeJSONReplacers, Ar as databaseSchemaComponent, At as getDefaultMigratorOptionsFromRegistry, B as InferDbClientFromConnection, Ba as DefaultSQLColumnToken, Bi as formatSQL, Bn as QueryCanceledError, Br as TableColumns, Bt as DatabaseCapabilities, C as CreateConnectionPoolOptions, Ca as SQLProcessorContext, Ci as relationship, Cn as toCamelCase, Co as JSONReviver, Cr as IndentErrors, Ct as dumboDatabaseDriverRegistry, D as createAmbientConnectionPool, Da as DefaultMapSQLParamValueOptions, Di as indexSchemaComponent, Dn as CheckViolationError, Do as JSONSerializeOptions, Dr as DatabaseSchemas, Dt as MigratorOptions, E as createAlwaysNewConnectionPool, Ea as ANSISQLParamPlaceholder, Ei as IndexURNType, En as AdminShutdownError, Eo as JSONSerializationOptions, Er as DatabaseSchemaComponent, Et as MIGRATIONS_LOCK_ID, F as ConnectionOptions, Fa as AnyColumnTypeToken, Fi as FormatContext, Fn as InsufficientResourcesError, Fr as DatabaseSchemaURNType, Ft as DatabaseLock, G as WithConnectionFactory, Ga as JavaScriptValueType, Gi as SQLTag, Gn as schemaComponentURN, Gr as InferColumnType, Gt as getDefaultDatabase, H as InferTransactionFromConnection, Ha as JSONBToken, Hi as registerFormatter, Hn as SystemError, Hr as TableURN, Ht as DumboDatabaseMetadataRegistry, I as CreateAmbientConnectionOptions, Ia as AutoIncrementSQLColumnToken, Ii as FormatSQLOptions, In as IntegrityConstraintViolationError, Ir as databaseSchemaSchemaComponent, It as DatabaseLockOptions, J as createConnection, Ja as NotNullableSQLColumnTokenProps, Ji as isTokenizedSQL, Jn as ColumnReferenceError, Jr as InferTableRow, Jt as BatchCommandNoChangesError, K as WithConnectionOptions, Ka as JavaScriptValueTypeName, Ki as isSQL, Kn as CollectReferencesErrors, Kr as InferDatabaseSchemas, Kt as getDefaultDatabaseAsync, L as CreateConnectionOptions, La as BigIntegerToken, Li as SQLFormatter, Ln as InvalidOperationError, Lr as AnyTableSchemaComponent, Lt as NoDatabaseLock, M as AnyConnection, Ma as mapSQLIdentifier, Mi as ColumnURNType, Mn as DumboError, Mo as jsonSerializer, Mr as DatabaseSchemaSchemaComponent, Mt as runSQLMigrations, N as Connection, Na as mapSQLParamValue, Ni as columnSchemaComponent, Nn as ExclusionViolationError, No as DbClientSetup, Nr as DatabaseSchemaTables, Nt as AcquireDatabaseLockMode, O as createBoundedConnectionPool, Oa as MapSQLParamValue, Oi as AnyColumnSchemaComponent, On as ConcurrencyError, Oo as JSONSerializer, Or as DatabaseURN, Ot as RunSQLMigrationsResult, P as ConnectionFactory, Pa as ansiSqlReservedMap, Pi as JSONParam, Pn as ForeignKeyViolationError, Pr as DatabaseSchemaURN, Pt as AcquireDatabaseLockOptions, Q as DatabaseTransaction, Qa as SQLColumnTypeTokensFactory, Qi as DumboSchemaComponentType, Qn as NoError, Qr as Writable, Qt as SQLCommandOptions, R as CreateSingletonConnectionOptions, Ra as BigSerialToken, Ri as SQLFormatterOptions, Rn as LockNotAvailableError, Rr as InferTableSchemaComponentColumns, Rt as ReleaseDatabaseLockOptions, S as CreateBoundedConnectionPoolOptions, Sa as SQLProcessor, Si as TableRelationships, Sn as mapToCamelCase, So as JSONReplacers, Sr as FormatValidationErrors, St as canHandleDriverWithConnectionString, T as SingletonConnectionPoolOptions, Ta as ANSISQLIdentifierQuote, Ti as IndexURN, Tn as QueryResultRow, To as JSONRevivers, Tr as AnyDatabaseSchemaComponent, Tt as migrationTableSchemaComponent, U as InferTransactionOptionsFromConnection, Ua as JSONValueType, Ui as RawSQL, Un as TransientDatabaseError, Ur as TableURNType, Ut as dumboDatabaseMetadataRegistry, V as InferDriverTypeFromConnection, Va as IntegerToken, Vi as getFormatter, Vn as SerializationError, Vr as TableSchemaComponent, Vt as DatabaseMetadata, W as InitTransaction, Wa as JSONValueTypeName, Wi as SQL, Wn as UniqueConstraintError, Wr as tableSchemaComponent, Wt as getDatabaseMetadata, X as createTransientConnection, Xa as SQLColumnToken, Xi as AnySchemaComponent, Xn as ColumnReferenceTypeMismatchError, Xr as TableColumnType, Xt as DbSQLExecutor, Y as createSingletonConnection, Ya as NullableSQLColumnTokenProps, Yi as dumboSchema, Yn as ColumnReferenceExistanceError, Yr as TableColumnNames, Yt as BatchSQLCommandOptions, Z as AnyDatabaseTransaction, Za as SQLColumnTypeTokens, Zi as AnySchemaComponentOfType, Zn as DatabaseSchemasWithSingle, Zr as TableRowType, Zt as DbSQLExecutorOptions, _ as IsOK, _a as DefaultSQLColumnProcessors, _i as ParseReferencePath, _n as first, _o as Serializer, _r as FormatDatabaseValidationErrors, _t as AnyDumboDatabaseDriver, a as parseConnectionString, aa as isSchemaComponentOfType, ai as AnyTableRelationshipDefinitionWithColumns, an as executeInNewDbClient, ao as SQLArray, ar as ValidateColumnsMatch, at as transactionFactoryWithAsyncAmbientConnection, b as ConnectionPoolFactory, ba as SQLProcessorsRegistry, bi as SchemaColumnName, bn as singleOrNull, bo as JSONDeserializeOptions, br as FormatSingleError, bt as ExtractDumboDatabaseDriverOptions, c as LogLevel, ca as MigrationRecord, ci as ColumnPathToReference, cn as mapColumnToJSON, co as SQLDefaultTokensTypes, cr as ValidateDatabaseSchemasWithMessages, ct as DatabaseDriverName, d as tracer, da as sqlMigration, di as ExtractColumnTypeName, dn as sqlExecutorInAmbientConnection, do as SQLLiteral, dr as ValidateRelationship, dt as DatabaseType, ea as SchemaComponent, ei as AllColumnReferencesInSchema, en as SQLQueryOptions, eo as TimestampToken, er as RelationshipReferencesLengthMismatchError, et as InferTransactionOptionsFromTransaction, f as prettyJson, fa as defaultProcessorsRegistry, fi as ExtractSchemaNames, fn as sqlExecutorInNewConnection, fo as SQLPlain, fr as ValidateRelationshipColumns, ft as InferDriverDatabaseType, g as IsError, ga as MapLiteralProcessor, gi as NormalizeReference, gn as exists, go as SerializationCodec, gr as ValidateTableRelationships, gt as toDatabaseDriverType, h as Expect, ha as FormatIdentifierProcessor, hi as NormalizeColumnPath, hn as count, ho as ParametrizedSQLBuilder, hr as ValidateTable, ht as getDatabaseType, i as DatabaseConnectionString, ia as findSchemaComponentsOfType, ii as AnyTableRelationshipDefinition, in as executeInNewConnection, io as ExtractSQLTokenType, ir as ValidateColumnTypeMatch, it as transactionFactoryWithAmbientConnection, j as createSingletonConnectionPool, ja as mapANSISQLParamPlaceholder, ji as ColumnURN, jn as DeadlockError, jo as composeJSONRevivers, jr as AnyDatabaseSchemaSchemaComponent, jt as registerDefaultMigratorOptions, k as createConnectionPool, ka as MapSQLParamValueOptions, ki as ColumnSchemaComponent, kn as ConnectionError, ko as JSONSerializerOptions, kr as DatabaseURNType, kt as combineMigrations, l as LogStyle, la as MigrationStyle, li as ColumnReference, ln as mapSQLQueryResult, lo as SQLIdentifier, lr as ValidateReference, lt as DatabaseDriverType, m as Equals, ma as ExpandSQLInProcessor, mi as LookupColumnType, mn as ExistsSQLQueryResult, mo as ParametrizedSQL, mr as ValidateSchemaTables, mt as getDatabaseDriverName, na as SchemaComponentType, ni as AllColumnTypesInSchema, nn as WithSQLExecutor, no as VarcharToken, nr as SchemaTablesWithSingle, nt as WithDatabaseTransactionFactory, o as Dumbo, oa as mapSchemaComponentsOfType, oi as ColumnName, on as mapColumnToBigint, oo as SQLArrayMode, or as ValidateDatabaseSchema, ot as transactionFactoryWithDbClient, p as color, pa as ExpandArrayProcessor, pi as ExtractTableNames, pn as CountSQLQueryResult, po as SQLToken, pr as ValidateRelationshipLength, pt as fromDatabaseDriverType, q as createAmbientConnection, qa as JavaScriptValueTypeToNameMap, qi as TokenizedSQL, qn as CollectRelationshipErrors, qr as InferSchemaTables, qt as resolveDatabaseMetadata, ra as filterSchemaComponentsOfType, ri as AnyRelationshipDefinition, rn as executeInAmbientConnection, ro as AnySQLToken, rr as ValidateColumnReference, rt as executeInTransaction, s as DumboConnectionOptions, sa as schemaComponent, si as ColumnPath, sn as mapColumnToDate, so as SQLDefaultTokens, sr as ValidateDatabaseSchemas, st as transactionFactoryWithNewConnection, t as dumbo, ta as SchemaComponentOptions, ti as AllColumnTypes, tn as SQLQueryResultColumnMapping, to as TimestamptzToken, tr as RelationshipValidationError, tt as TransactionResult, u as LogType, ua as SQLMigration, ui as ExtractColumnNames, un as sqlExecutor, uo as SQLIn, ur as ValidateReferences, ut as DatabaseDriverTypeParts, v as AmbientConnectionPoolOptions, va as mapDefaultSQLColumnProcessors, vi as RelationshipDefinition, vn as firstOrNull, vo as JSONCodec, vr as FormatRelationshipBlock, vt as DumboDatabaseDriver, w as SingletonClientConnectionPoolOptions, wa as SQLProcessorOptions, wi as IndexSchemaComponent, wn as QueryResult, wo as JSONReviverContext, wr as Join, wt as SchemaComponentMigrator, x as CreateAlwaysNewConnectionPoolOptions, xa as AnySQLProcessor, xi as TableColumnName, xn as mapRows, xo as JSONReplacer, xr as FormatTableLevel, xt as ExtractDumboTypeFromDriver, y as ConnectionPool, ya as SQLProcessorsReadonlyRegistry, yi as RelationshipType, yn as single, yo as JSONCodecOptions, yr as FormatSchemaLevel, yt as DumboDatabaseDriverRegistry, z as CreateTransientConnectionOptions, za as ColumnTypeToken, zi as describeSQL, zn as NotNullViolationError, zr as InferTableSchemaComponentTypes, zt as defaultDatabaseLockOptions } from "./index-QWEAqtHF.js";
-export { ANSISQLIdentifierQuote, ANSISQLParamPlaceholder, AcquireDatabaseLockMode, AcquireDatabaseLockOptions, AdminShutdownError, AllColumnReferences, AllColumnReferencesInSchema, AllColumnTypes, AllColumnTypesInSchema, AmbientConnectionPoolOptions, AnyColumnSchemaComponent, AnyColumnTypeToken, AnyConnection, AnyDatabaseSchemaComponent, AnyDatabaseSchemaSchemaComponent, AnyDatabaseTransaction, AnyDumboDatabaseDriver, AnyRelationshipDefinition, AnySQLProcessor, AnySQLToken, AnySchemaComponent, AnySchemaComponentOfType, AnyTableRelationshipDefinition, AnyTableRelationshipDefinitionWithColumns, AnyTableSchemaComponent, AutoIncrementSQLColumnToken, BatchCommandNoChangesError, BatchSQLCommandOptions, BigIntegerToken, BigSerialToken, CheckViolationError, CollectReferencesErrors, CollectRelationshipErrors, ColumnName, ColumnPath, ColumnPathToReference, ColumnReference, ColumnReferenceError, ColumnReferenceExistanceError, ColumnReferenceTypeMismatchError, ColumnSchemaComponent, ColumnSchemaComponentOptions, ColumnTypeToken, ColumnURN, ColumnURNType, ConcurrencyError, Connection, ConnectionError, ConnectionFactory, ConnectionOptions, ConnectionPool, ConnectionPoolFactory, CountSQLQueryResult, CreateAlwaysNewConnectionPoolOptions, CreateAmbientConnectionOptions, CreateBoundedConnectionPoolOptions, CreateConnectionOptions, CreateConnectionPoolOptions, CreateSingletonConnectionOptions, CreateTransientConnectionOptions, DataError, DatabaseCapabilities, DatabaseConnectionString, DatabaseDriverName, DatabaseDriverType, DatabaseDriverTypeParts, DatabaseLock, DatabaseLockOptions, DatabaseMetadata, DatabaseSchemaComponent, DatabaseSchemaSchemaComponent, DatabaseSchemaTables, DatabaseSchemaURN, DatabaseSchemaURNType, DatabaseSchemas, DatabaseSchemasWithSingle, DatabaseTransaction, DatabaseTransactionOptions, DatabaseType, DatabaseURN, DatabaseURNType, DbClientSetup, DbSQLExecutor, DbSQLExecutorOptions, DeadlockError, DefaultMapSQLParamValueOptions, DefaultSQLColumnProcessors, DefaultSQLColumnToken, Dumbo, DumboConnectionOptions, DumboDatabaseDriver, DumboDatabaseDriverRegistry, DumboDatabaseMetadataRegistry, DumboError, DumboSchemaComponentType, Equals, ExclusionViolationError, ExistsSQLQueryResult, ExpandArrayProcessor, ExpandSQLInProcessor, Expect, ExtractAdditionalData, ExtractColumnNames, ExtractColumnTypeName, ExtractDumboDatabaseDriverOptions, ExtractDumboTypeFromDriver, ExtractSQLTokenType, ExtractSchemaNames, ExtractTableNames, ForeignKeyViolationError, FormatContext, FormatDatabaseValidationErrors, FormatIdentifierProcessor, FormatRelationshipBlock, FormatSQLOptions, FormatSchemaLevel, FormatSingleError, FormatTableLevel, FormatValidationErrors, IndentErrors, IndexSchemaComponent, IndexURN, IndexURNType, InferColumnType, InferDatabaseSchemas, InferDbClientFromConnection, InferDriverDatabaseType, InferDriverTypeFromConnection, InferSchemaTables, InferTableRow, InferTableSchemaComponentColumns, InferTableSchemaComponentTypes, InferTransactionFromConnection, InferTransactionOptionsFromConnection, InferTransactionOptionsFromTransaction, InitTransaction, InsufficientResourcesError, IntegerToken, IntegrityConstraintViolationError, InvalidOperationError, IsError, IsOK, JSONBToken, JSONCodec, JSONCodecOptions, JSONDeserializeOptions, JSONParam, JSONReplacer, JSONReplacers, JSONReviver, JSONReviverContext, JSONRevivers, JSONSerializationOptions, JSONSerializeOptions, JSONSerializer, JSONSerializerOptions, JSONValueType, JSONValueTypeName, JavaScriptValueType, JavaScriptValueTypeName, JavaScriptValueTypeToNameMap, Join, LockNotAvailableError, LogLevel, LogStyle, LogType, LookupColumnType, MIGRATIONS_LOCK_ID, MapLiteralProcessor, MapSQLParamValue, MapSQLParamValueOptions, MigrationRecord, MigrationStyle, MigratorOptions, NoDatabaseLock, NoError, NormalizeColumnPath, NormalizeReference, NotNullViolationError, NotNullableSQLColumnTokenProps, NullableSQLColumnTokenProps, ParametrizedSQL, ParametrizedSQLBuilder, ParseReferencePath, QueryCanceledError, QueryResult, QueryResultRow, RawSQL, RelationshipColumnsMismatchError, RelationshipDefinition, RelationshipReferencesLengthMismatchError, RelationshipType, RelationshipValidationError, ReleaseDatabaseLockOptions, RunSQLMigrationsResult, SQL, SQLArray, SQLArrayMode, SQLColumnToken, SQLColumnTypeTokens, SQLColumnTypeTokensFactory, SQLCommandOptions, SQLDefaultTokens, SQLDefaultTokensTypes, SQLExecutor, SQLFormatter, SQLFormatterOptions, SQLIdentifier, SQLIn, SQLLiteral, SQLMigration, SQLPlain, SQLProcessor, SQLProcessorContext, SQLProcessorOptions, SQLProcessorsReadonlyRegistry, SQLProcessorsRegistry, SQLQueryOptions, SQLQueryResultColumnMapping, SQLTag, SQLToken, SQLValueMapper, SchemaColumnName, SchemaComponent, SchemaComponentMigrator, SchemaComponentOptions, SchemaComponentType, SchemaTablesWithSingle, SerialToken, SerializationCodec, SerializationError, Serializer, SingletonClientConnectionPoolOptions, SingletonConnectionPoolOptions, SystemError, TableColumnName, TableColumnNames, TableColumnType, TableColumns, TableRelationships, TableRowType, TableSchemaComponent, TableURN, TableURNType, TimestampToken, TimestamptzToken, TokenizedSQL, TransactionResult, TransientDatabaseError, UniqueConstraintError, ValidateColumnReference, ValidateColumnTypeMatch, ValidateColumnsMatch, ValidateDatabaseSchema, ValidateDatabaseSchemas, ValidateDatabaseSchemasWithMessages, ValidateReference, ValidateReferences, ValidateRelationship, ValidateRelationshipColumns, ValidateRelationshipLength, ValidateSchemaTables, ValidateTable, ValidateTableRelationships, VarcharToken, WithConnectionFactory, WithConnectionOptions, WithDatabaseTransactionFactory, WithSQLExecutor, Writable, ansiSqlReservedMap, canHandleDriverWithConnectionString, color, columnSchemaComponent, combineMigrations, composeJSONReplacers, composeJSONRevivers, count, createAlwaysNewConnectionPool, createAmbientConnection, createAmbientConnectionPool, createBoundedConnectionPool, createConnection, createConnectionPool, createSingletonClientConnectionPool, createSingletonConnection, createSingletonConnectionPool, createTransientConnection, databaseSchemaComponent, databaseSchemaSchemaComponent, defaultDatabaseLockOptions, defaultProcessorsRegistry, describeSQL, dumbo, dumboDatabaseDriverRegistry, dumboDatabaseMetadataRegistry, dumboSchema, executeInAmbientConnection, executeInNewConnection, executeInNewDbClient, executeInTransaction, exists, filterSchemaComponentsOfType, findSchemaComponentsOfType, first, firstOrNull, formatSQL, fromDatabaseDriverType, getDatabaseDriverName, getDatabaseMetadata, getDatabaseType, getDefaultDatabase, getDefaultDatabaseAsync, getDefaultMigratorOptionsFromRegistry, getFormatter, indexSchemaComponent, isSQL, isSchemaComponentOfType, isTokenizedSQL, jsonSerializer, mapANSISQLParamPlaceholder, mapColumnToBigint, mapColumnToDate, mapColumnToJSON, mapDefaultSQLColumnProcessors, mapRows, mapSQLIdentifier, mapSQLParamValue, mapSQLQueryResult, mapSchemaComponentsOfType, mapToCamelCase, migrationTableSchemaComponent, parseConnectionString, prettyJson, registerDefaultMigratorOptions, registerFormatter, relationship, resolveDatabaseMetadata, runSQLMigrations, schemaComponent, schemaComponentURN, single, singleOrNull, sqlExecutor, sqlExecutorInAmbientConnection, sqlExecutorInNewConnection, sqlMigration, tableSchemaComponent, toCamelCase, toDatabaseDriverType, tracer, transactionFactoryWithAmbientConnection, transactionFactoryWithAsyncAmbientConnection, transactionFactoryWithDbClient, transactionFactoryWithNewConnection };
+//#region src/core/connections/client.d.ts
+type DbClientSetup<DbClient = unknown> = {
+  connect: () => Promise<DbClient> | void;
+  close: (client: DbClient) => Promise<void> | void;
+};
+//#endregion
+//#region src/core/serializer/json/index.d.ts
+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;
+}
+type JSONSerializerOptions = {
+  parseDates?: boolean;
+  parseBigInts?: boolean;
+  failOnBigIntSerialization?: boolean;
+  useDefaultDateSerialization?: boolean;
+};
+type JSONSerializeOptions = {
+  replacer?: JSONReplacer;
+} & JSONSerializerOptions;
+type JSONDeserializeOptions = {
+  reviver?: JSONReviver;
+} & JSONSerializerOptions;
+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;
+}
+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 JSONReplacer = (this: any, key: string, value: any) => any;
+type JSONReviver = (this: any, key: string, value: any, context: JSONReviverContext) => any;
+type JSONReviverContext = {
+  source: string;
+};
+declare const composeJSONReplacers: (...replacers: (JSONReplacer | undefined)[]) => JSONReplacer | undefined;
+declare const composeJSONRevivers: (...revivers: (JSONReviver | undefined)[]) => JSONReviver | undefined;
+declare const JSONReplacer: (opts?: JSONSerializeOptions) => JSONReplacer | undefined;
+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;
+declare const JSONSerializer: JSONSerializer & {
+  from: <SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions>(options?: JSONSerializationOptions<SerializeOptions, DeserializeOptions>) => JSONSerializer<SerializeOptions, DeserializeOptions>;
+};
+declare const JSONCodec: <T, Payload = T, SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions>(options: JSONCodecOptions<T, Payload, SerializeOptions, DeserializeOptions>) => JSONCodec<T, SerializeOptions, DeserializeOptions>;
+//#endregion
+//#region src/core/serializer/index.d.ts
+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;
+}
+//#endregion
+//#region src/core/sql/parametrizedSQL/parametrizedSQL.d.ts
+interface ParametrizedSQL {
+  query: string;
+  params: unknown[];
+}
+interface ParametrizedSQLBuilder {
+  addSQL: (str: string) => ParametrizedSQLBuilder;
+  addParam(value: unknown): ParametrizedSQLBuilder;
+  addParams(values: unknown[]): ParametrizedSQLBuilder;
+  build: () => ParametrizedSQL;
+}
+declare const ParametrizedSQLBuilder: ({
+  mapParamPlaceholder
+}: {
+  mapParamPlaceholder: (index: number, value: unknown) => string;
+}) => ParametrizedSQLBuilder;
+//#endregion
+//#region src/core/sql/tokens/sqlToken.d.ts
+type SQLToken<TSymbol extends string = string, TProps extends Omit<Record<string, unknown>, 'sqlTokenType'> | undefined = Omit<Record<string, unknown>, 'sqlTokenType'> | undefined> = {
+  sqlTokenType: TSymbol;
+} & (TProps extends undefined ? void : Omit<TProps, 'sqlTokenType'>);
+type ExtractSQLTokenType<T> = T extends ((...args: never[]) => infer R) ? R extends SQLToken ? R : never : T extends SQLToken ? T : never;
+type AnySQLToken = SQLToken<string, any>;
+declare const SQLToken: {
+  <SQLTokenType extends AnySQLToken, TInput = (Exclude<keyof SQLTokenType, "sqlTokenType"> extends never ? void : Omit<SQLTokenType, "sqlTokenType">)>(sqlTokenType: SQLTokenType["sqlTokenType"], map?: (input: TInput) => Omit<SQLTokenType, "sqlTokenType">): {
+    from: (input: TInput) => SQLTokenType;
+    check: (token: unknown) => token is SQLTokenType;
+    type: SQLTokenType["sqlTokenType"];
+  };
+  check<SQLTokenType extends AnySQLToken>(token: unknown): token is SQLTokenType;
+};
+type SQLIdentifier = SQLToken<'SQL_IDENTIFIER', {
+  value: string;
+}>;
+declare const SQLIdentifier: {
+  from: (input: string) => SQLIdentifier;
+  check: (token: unknown) => token is SQLIdentifier;
+  type: "SQL_IDENTIFIER";
+};
+type SQLPlain = SQLToken<'SQL_RAW', {
+  value: string;
+}>;
+declare const SQLPlain: {
+  from: (input: string) => SQLPlain;
+  check: (token: unknown) => token is SQLPlain;
+  type: "SQL_RAW";
+};
+type SQLLiteral = SQLToken<'SQL_LITERAL', {
+  value: unknown;
+}>;
+declare const SQLLiteral: {
+  from: (input: unknown) => 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[] | {
+    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";
+};
+type SQLDefaultTokens = SQLIdentifier | SQLPlain | SQLLiteral | SQLArray;
+type SQLDefaultTokensTypes = SQLDefaultTokens['sqlTokenType'];
+//#endregion
+//#region src/core/sql/tokens/columnTokens.d.ts
+type JSONValueType = Record<string, unknown> | Array<unknown> | string | number | boolean | null;
+type JSONValueTypeName = 'value_type:json:object' | 'value_type:json:array' | 'value_type:json:string' | 'value_type:json:number' | 'value_type:json:boolean' | 'value_type:json:null';
+type JavaScriptValueType = Record<string, unknown> | Array<unknown> | string | number | boolean | null | undefined | Date | bigint;
+type JavaScriptValueTypeName = 'value_type:js:object' | 'value_type:js:array' | 'value_type:js:string' | 'value_type:js:number' | 'value_type:js:boolean' | 'value_type:js:null' | 'value_type:js:undefined' | 'value_type:js:date' | 'value_type:js:bigint';
+type JavaScriptValueTypeToNameMap = { [K in JavaScriptValueType as K extends Record<string, unknown> ? 'value_type:js:object' : K extends Array<unknown> ? 'value_type:js:array' : K extends string ? 'value_type:js:string' : K extends number ? 'value_type:js:number' : K extends boolean ? 'value_type:js:boolean' : K extends null ? 'value_type:js:null' : K extends undefined ? 'value_type:js:undefined' : K extends Date ? 'value_type:js:date' : K extends bigint ? 'value_type:js:bigint' : never]: K };
+type ColumnTypeToken<JSValueTypeName extends JavaScriptValueTypeName = JavaScriptValueTypeName, ColumnTypeName extends string = string, TProps extends Omit<Record<string, unknown>, 'sqlTokenType'> | undefined = Omit<Record<string, unknown>, 'sqlTokenType'> | undefined, ValueType = undefined> = SQLToken<`SQL_COLUMN_${ColumnTypeName}`, TProps> & {
+  __brand: ValueType extends undefined ? JavaScriptValueTypeToNameMap[JSValueTypeName] : ValueType;
+  jsTypeName: JSValueTypeName;
+};
+declare const ColumnTypeToken: <SQLTokenType extends AnyColumnTypeToken, TInput = (keyof Omit<SQLTokenType, "sqlTokenType" | "__brand" | "jsTypeName"> extends never ? void : Omit<SQLTokenType, "sqlTokenType" | "__brand" | "jsTypeName">)>(sqlTokenType: SQLTokenType["sqlTokenType"], jsTypeName: SQLTokenType["jsTypeName"], map?: (input: TInput) => Omit<SQLTokenType, "sqlTokenType" | "__brand" | "jsTypeName">) => {
+  from: (input: TInput) => SQLTokenType;
+  check: (token: unknown) => token is SQLTokenType;
+  type: SQLTokenType["sqlTokenType"];
+};
+type AnyColumnTypeToken = ColumnTypeToken<any, string, any>;
+type SerialToken = ColumnTypeToken<'value_type:js:number', 'SERIAL'>;
+declare const SerialToken: {
+  from: (input: void) => SerialToken;
+  check: (token: unknown) => token is SerialToken;
+  type: "SQL_COLUMN_SERIAL";
+};
+type BigSerialToken = ColumnTypeToken<'value_type:js:bigint', 'BIGSERIAL'>;
+declare const BigSerialToken: {
+  from: (input: void) => BigSerialToken;
+  check: (token: unknown) => token is BigSerialToken;
+  type: "SQL_COLUMN_BIGSERIAL";
+};
+type IntegerToken = ColumnTypeToken<'value_type:js:number', 'INTEGER'>;
+declare const IntegerToken: {
+  from: (input: void) => IntegerToken;
+  check: (token: unknown) => token is IntegerToken;
+  type: "SQL_COLUMN_INTEGER";
+};
+type BigIntegerToken = ColumnTypeToken<'value_type:js:bigint', 'BIGINT'>;
+declare const BigIntegerToken: {
+  from: (input: void) => BigIntegerToken;
+  check: (token: unknown) => token is BigIntegerToken;
+  type: "SQL_COLUMN_BIGINT";
+};
+type JSONBToken<ValueType extends Record<string, unknown> = Record<string, unknown>> = ColumnTypeToken<'value_type:js:object', 'JSONB', undefined, ValueType>;
+declare const JSONBToken: {
+  type: string;
+  from: <ValueType extends Record<string, unknown> = Record<string, unknown>>() => JSONBToken<ValueType>;
+  check: <ValueType extends Record<string, unknown> = Record<string, unknown>>(token: unknown) => token is JSONBToken<ValueType>;
+};
+type TimestampToken = ColumnTypeToken<'value_type:js:date', 'TIMESTAMP'>;
+declare const TimestampToken: {
+  from: (input: void) => TimestampToken;
+  check: (token: unknown) => token is TimestampToken;
+  type: "SQL_COLUMN_TIMESTAMP";
+};
+type TimestamptzToken = ColumnTypeToken<'value_type:js:date', 'TIMESTAMPTZ'>;
+declare const TimestamptzToken: {
+  from: (input: void) => TimestamptzToken;
+  check: (token: unknown) => token is TimestamptzToken;
+  type: "SQL_COLUMN_TIMESTAMPTZ";
+};
+type VarcharToken = ColumnTypeToken<'value_type:js:string', 'VARCHAR', {
+  length: number | 'max';
+}>;
+declare const VarcharToken: {
+  from: (input: number | "max") => VarcharToken;
+  check: (token: unknown) => token is VarcharToken;
+  type: "SQL_COLUMN_VARCHAR";
+};
+type NotNullableSQLColumnTokenProps<ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string> = {
+  name: string;
+  type: ColumnType;
+  notNull: true;
+  unique?: boolean;
+  primaryKey?: boolean;
+  default?: ColumnType | SQLToken;
+} | {
+  name: string;
+  type: ColumnType;
+  notNull?: false;
+  unique?: boolean;
+  primaryKey: never;
+  default?: ColumnType | SQLToken;
+};
+type NullableSQLColumnTokenProps<ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string> = {
+  name: string;
+  type: ColumnType;
+  notNull?: false;
+  unique?: boolean;
+  primaryKey?: false;
+  default?: ColumnType | SQLToken;
+};
+type SQLColumnToken<ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string> = SQLToken<'SQL_COLUMN', NotNullableSQLColumnTokenProps<ColumnType> | NullableSQLColumnTokenProps<ColumnType>>;
+type AutoIncrementSQLColumnToken = ColumnTypeToken<'value_type:js:bigint', 'AUTO_INCREMENT', {
+  primaryKey: boolean;
+  bigint?: boolean;
+}, bigint>;
+declare const AutoIncrementSQLColumnToken: {
+  from: (input: Omit<AutoIncrementSQLColumnToken, "sqlTokenType" | "__brand" | "jsTypeName">) => AutoIncrementSQLColumnToken;
+  check: (token: unknown) => token is AutoIncrementSQLColumnToken;
+  type: "SQL_COLUMN_AUTO_INCREMENT";
+};
+declare const SQLColumnTypeTokens: {
+  AutoIncrement: {
+    from: (input: Omit<AutoIncrementSQLColumnToken, "sqlTokenType" | "__brand" | "jsTypeName">) => AutoIncrementSQLColumnToken;
+    check: (token: unknown) => token is AutoIncrementSQLColumnToken;
+    type: "SQL_COLUMN_AUTO_INCREMENT";
+  };
+  BigInteger: {
+    from: (input: void) => BigIntegerToken;
+    check: (token: unknown) => token is BigIntegerToken;
+    type: "SQL_COLUMN_BIGINT";
+  };
+  BigSerial: {
+    from: (input: void) => BigSerialToken;
+    check: (token: unknown) => token is BigSerialToken;
+    type: "SQL_COLUMN_BIGSERIAL";
+  };
+  Integer: {
+    from: (input: void) => IntegerToken;
+    check: (token: unknown) => token is IntegerToken;
+    type: "SQL_COLUMN_INTEGER";
+  };
+  JSONB: {
+    type: string;
+    from: <ValueType extends Record<string, unknown> = Record<string, unknown>>() => JSONBToken<ValueType>;
+    check: <ValueType extends Record<string, unknown> = Record<string, unknown>>(token: unknown) => token is JSONBToken<ValueType>;
+  };
+  Serial: {
+    from: (input: void) => SerialToken;
+    check: (token: unknown) => token is SerialToken;
+    type: "SQL_COLUMN_SERIAL";
+  };
+  Timestamp: {
+    from: (input: void) => TimestampToken;
+    check: (token: unknown) => token is TimestampToken;
+    type: "SQL_COLUMN_TIMESTAMP";
+  };
+  Timestamptz: {
+    from: (input: void) => TimestamptzToken;
+    check: (token: unknown) => token is TimestamptzToken;
+    type: "SQL_COLUMN_TIMESTAMPTZ";
+  };
+  Varchar: {
+    from: (input: number | "max") => VarcharToken;
+    check: (token: unknown) => token is VarcharToken;
+    type: "SQL_COLUMN_VARCHAR";
+  };
+};
+type SQLColumnTypeTokens = {
+  AutoIncrement: AutoIncrementSQLColumnToken;
+  BigInteger: BigIntegerToken;
+  BigSerial: BigSerialToken;
+  Integer: IntegerToken;
+  JSONB: JSONBToken;
+  Serial: SerialToken;
+  Timestamp: TimestampToken;
+  Timestamptz: TimestamptzToken;
+  Varchar: VarcharToken;
+};
+declare const SQLColumnTypeTokensFactory: {
+  AutoIncrement: (input: Omit<AutoIncrementSQLColumnToken, "sqlTokenType" | "__brand" | "jsTypeName">) => AutoIncrementSQLColumnToken;
+  BigInteger: BigIntegerToken;
+  BigSerial: BigSerialToken;
+  Integer: IntegerToken;
+  JSONB: <ValueType extends Record<string, unknown> = Record<string, unknown>>() => JSONBToken<ValueType>;
+  Serial: SerialToken;
+  Timestamp: TimestampToken;
+  Timestamptz: TimestamptzToken;
+  Varchar: (input: number | "max") => VarcharToken;
+};
+type DefaultSQLColumnToken = AutoIncrementSQLColumnToken | SerialToken | BigSerialToken | IntegerToken | JSONBToken | BigIntegerToken | TimestampToken | TimestamptzToken | VarcharToken;
+declare const SQLColumnToken: {
+  from: (input: Omit<SQLColumnToken<string | AnyColumnTypeToken>, "sqlTokenType">) => SQLColumnToken<string | AnyColumnTypeToken>;
+  check: (token: unknown) => token is SQLColumnToken<string | AnyColumnTypeToken>;
+  type: "SQL_COLUMN";
+};
+//#endregion
+//#region src/core/sql/valueMappers/reservedSqlWords.d.ts
+declare const ansiSqlReservedMap: {
+  [key: string]: boolean;
+};
+//#endregion
+//#region src/core/sql/valueMappers/sqlValueMapper.d.ts
+interface SQLValueMapper {
+  mapValue: MapSQLParamValue;
+  mapPlaceholder: (index: number, value: unknown) => string;
+  mapIdentifier: (value: string) => string;
+}
+type MapSQLParamValue = (value: unknown, serializer: JSONSerializer, options?: MapSQLParamValueOptions) => unknown;
+interface MapSQLParamValueOptions {
+  mapBoolean?: (value: boolean) => unknown;
+  mapArray?: (array: unknown[], mapValue: MapSQLParamValue) => unknown[];
+  mapDate?: (value: Date) => unknown;
+  mapObject?: (value: object) => unknown;
+  mapBigInt?: (value: bigint) => unknown;
+  mapValue?: MapSQLParamValue;
+  mapPlaceholder?: (index: number, value: unknown) => string;
+  mapIdentifier?: (value: string) => string;
+}
+declare const ANSISQLParamPlaceholder = "?";
+declare const ANSISQLIdentifierQuote = "\"";
+declare const mapANSISQLParamPlaceholder: () => string;
+declare const mapSQLIdentifier: (value: string, options?: {
+  reservedWords: {
+    [key: string]: boolean;
+  };
+  quote?: string;
+}) => string;
+declare const DefaultMapSQLParamValueOptions: {
+  mapPlaceholder: () => string;
+  mapIdentifier: (value: string, options?: {
+    reservedWords: {
+      [key: string]: boolean;
+    };
+    quote?: string;
+  }) => string;
+};
+declare const SQLValueMapper: (options?: MapSQLParamValueOptions) => SQLValueMapper;
+declare function mapSQLParamValue(value: unknown, serializer: JSONSerializer, options?: MapSQLParamValueOptions): unknown;
+//#endregion
+//#region src/core/sql/processors/sqlProcessor.d.ts
+type SQLProcessorContext = {
+  mapper: SQLValueMapper;
+  builder: ParametrizedSQLBuilder;
+  processorsRegistry: SQLProcessorsReadonlyRegistry;
+  serializer: JSONSerializer;
+};
+type SQLProcessor<Token extends AnySQLToken = AnySQLToken> = {
+  canHandle: Token['sqlTokenType'];
+  handle: (value: Token, context: SQLProcessorContext) => void;
+};
+type AnySQLProcessor = SQLProcessor<any>;
+type SQLProcessorOptions<Token extends AnySQLToken = AnySQLToken> = {
+  canHandle: Token['sqlTokenType'];
+  handle: (value: Token, context: SQLProcessorContext) => void;
+};
+declare const SQLProcessor: <Token extends AnySQLToken = AnySQLToken>(options: SQLProcessorOptions<Token>) => SQLProcessor<Token>;
+//#endregion
+//#region src/core/sql/processors/sqlProcessorRegistry.d.ts
+interface SQLProcessorsReadonlyRegistry {
+  get<Token extends AnySQLToken = AnySQLToken>(tokenType: Token['sqlTokenType']): SQLProcessor<Token> | null;
+  all(): ReadonlyMap<string, AnySQLProcessor>;
+}
+interface SQLProcessorsRegistry extends SQLProcessorsReadonlyRegistry {
+  register(...processor: AnySQLProcessor[]): SQLProcessorsRegistry;
+  register(processor: Record<string, AnySQLProcessor>): SQLProcessorsRegistry;
+}
+declare const SQLProcessorsRegistry: (options?: {
+  from: SQLProcessorsRegistry;
+}) => SQLProcessorsRegistry;
+//#endregion
+//#region src/core/sql/processors/columnProcessors.d.ts
+type DefaultSQLColumnProcessors = { [key in keyof SQLColumnTypeTokens]: SQLProcessor<SQLColumnTypeTokens[key]> };
+declare const mapDefaultSQLColumnProcessors: (mapColumnType: (token: DefaultSQLColumnToken, context: SQLProcessorContext) => void) => DefaultSQLColumnProcessors;
+//#endregion
+//#region src/core/sql/processors/defaultProcessors.d.ts
+declare const ExpandArrayProcessor: SQLProcessor<SQLArray>;
+declare const ExpandSQLInProcessor: SQLProcessor<SQLIn>;
+declare const FormatIdentifierProcessor: SQLProcessor<SQLIdentifier>;
+declare const MapLiteralProcessor: SQLProcessor<SQLLiteral>;
+//#endregion
+//#region src/core/sql/processors/index.d.ts
+declare global {
+  var defaultProcessorsRegistry: ReturnType<typeof SQLProcessorsRegistry>;
+}
+declare const defaultProcessorsRegistry: SQLProcessorsRegistry;
+//#endregion
+//#region src/core/schema/sqlMigration.d.ts
+type MigrationStyle = 'None' | 'CreateOrUpdate';
+type SQLMigration = {
+  name: string;
+  sqls: SQL[];
+};
+declare const sqlMigration: (name: string, sqls: SQL[]) => SQLMigration;
+type MigrationRecord = {
+  id: number;
+  name: string;
+  application: string;
+  sqlHash: string;
+  timestamp: Date;
+};
+//#endregion
+//#region src/core/schema/schemaComponent.d.ts
+type SchemaComponent<ComponentKey extends string = string, AdditionalData extends Exclude<Record<string, unknown>, 'schemaComponentKey' | 'components' | 'migrations' | 'addComponent' | 'addMigration'> | undefined = undefined> = {
+  schemaComponentKey: ComponentKey;
+  components: ReadonlyMap<string, SchemaComponent>;
+  migrations: ReadonlyArray<SQLMigration>;
+  addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
+  addMigration: (migration: SQLMigration) => void;
+} & Exclude<AdditionalData extends undefined ? {} : AdditionalData, 'schemaComponentKey' | 'components' | 'migrations' | 'addComponent' | 'addMigration'>;
+type ExtractAdditionalData<T> = T extends SchemaComponent<infer _ComponentType, infer Data> ? Data : never;
+type AnySchemaComponent = SchemaComponent<string, Record<string, any>>;
+type AnySchemaComponentOfType<ComponentType extends string = string> = SchemaComponent<ComponentType, any>;
+type SchemaComponentOptions<AdditionalOptions extends Record<string, unknown> = Record<string, unknown>> = {
+  migrations?: ReadonlyArray<SQLMigration>;
+  components?: ReadonlyArray<SchemaComponent>;
+} & Omit<AdditionalOptions, 'migrations' | 'components'>;
+type SchemaComponentType<Kind extends string = string> = `sc:${Kind}`;
+type DumboSchemaComponentType<Kind extends string = string> = SchemaComponentType<`dumbo:${Kind}`>;
+declare const schemaComponent: <const ComponentKey extends string = string>(key: ComponentKey, options: SchemaComponentOptions) => SchemaComponent<ComponentKey>;
+declare const isSchemaComponentOfType: <SchemaComponentOfType extends AnySchemaComponent = AnySchemaComponent>(component: AnySchemaComponent, prefix: string) => component is SchemaComponentOfType;
+declare const filterSchemaComponentsOfType: <T extends AnySchemaComponent>(components: ReadonlyMap<string, AnySchemaComponent>, prefix: string) => ReadonlyMap<string, T>;
+declare const mapSchemaComponentsOfType: <T extends AnySchemaComponent>(components: ReadonlyMap<string, AnySchemaComponent>, prefix: string, keyMapper?: (component: T) => string) => ReadonlyMap<string, T>;
+declare const findSchemaComponentsOfType: <T extends AnySchemaComponent>(root: AnySchemaComponent, prefix: string) => T[];
+//#endregion
+//#region src/core/schema/dumboSchema/dumboSchema.d.ts
+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>;
+declare namespace dumboDatabaseSchema {
+  var from: (schemaName: string | undefined, tableNames: string[]) => DatabaseSchemaSchemaComponent;
+  var defaultName: string;
+}
+type ValidatedDatabaseSchemaComponent<Schemas extends DatabaseSchemas = DatabaseSchemas> = ValidateDatabaseSchemas<Schemas> extends {
+  valid: true;
+} ? DatabaseSchemaComponent<Schemas> : ValidateDatabaseSchemas<Schemas> extends {
+  valid: false;
+  error: infer E;
+} ? {
+  valid: false;
+  error: E;
+} : DatabaseSchemaComponent<Schemas>;
+declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(schemas: Schemas): ValidatedDatabaseSchemaComponent<Schemas>;
+declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(schema: DatabaseSchemaSchemaComponent): ValidatedDatabaseSchemaComponent<Schemas>;
+declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string, schemas: Schemas, options?: SchemaComponentOptions): ValidatedDatabaseSchemaComponent<Schemas>;
+declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string, schema: AnyDatabaseSchemaSchemaComponent, options?: SchemaComponentOptions): ValidatedDatabaseSchemaComponent<Schemas>;
+declare namespace dumboDatabase {
+  var from: <Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string | undefined, schemaNames: string[]) => ValidatedDatabaseSchemaComponent<Schemas>;
+  var defaultName: string;
+}
+declare const dumboSchema: {
+  database: typeof dumboDatabase;
+  schema: typeof dumboDatabaseSchema;
+  table: <const Columns extends TableColumns = TableColumns, const TableName extends string = string, const Relationships extends TableRelationships<keyof Columns & string> = TableRelationships<keyof Columns & string>>(name: TableName, definition: {
+    columns?: Columns;
+    primaryKey?: TableColumnNames<TableSchemaComponent<Columns, TableName, Relationships>>[];
+    relationships?: Relationships;
+    indexes?: Record<string, IndexSchemaComponent>;
+  } & SchemaComponentOptions) => TableSchemaComponent<Columns, TableName, Relationships>;
+  column: <const ColumnType extends AnyColumnTypeToken | string = string | AnyColumnTypeToken, const TOptions extends SchemaComponentOptions & Omit<SQLColumnToken<ColumnType>, "name" | "type" | "sqlTokenType"> = Omit<ColumnSchemaComponentOptions<ColumnType>, "type">, const ColumnName extends string = string>(name: ColumnName, type: ColumnType, options?: TOptions) => ({
+    schemaComponentKey: `sc:dumbo:column:${ColumnName}`;
+    components: ReadonlyMap<string, SchemaComponent>;
+    migrations: ReadonlyArray<SQLMigration>;
+    addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
+    addMigration: (migration: SQLMigration) => void;
+  } & Readonly<{
+    columnName: ColumnName;
+  }> & {
+    sqlTokenType: "SQL_COLUMN";
+  } & Omit<{
+    name: string;
+    type: ColumnType;
+    notNull?: false;
+    unique?: boolean;
+    primaryKey: never;
+    default?: ColumnType | SQLToken;
+  }, "sqlTokenType"> & (TOptions & {
+    type: ColumnType;
+  } extends infer T ? T extends TOptions & {
+    type: ColumnType;
+  } ? T extends {
+    notNull: true;
+  } | {
+    primaryKey: true;
+  } ? {
+    notNull: true;
+  } : {
+    notNull?: false;
+  } : never : never)) | ({
+    schemaComponentKey: `sc:dumbo:column:${ColumnName}`;
+    components: ReadonlyMap<string, SchemaComponent>;
+    migrations: ReadonlyArray<SQLMigration>;
+    addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
+    addMigration: (migration: SQLMigration) => void;
+  } & Readonly<{
+    columnName: ColumnName;
+  }> & {
+    sqlTokenType: "SQL_COLUMN";
+  } & Omit<NullableSQLColumnTokenProps<ColumnType>, "sqlTokenType"> & (TOptions & {
+    type: ColumnType;
+  } extends infer T_1 ? T_1 extends TOptions & {
+    type: ColumnType;
+  } ? T_1 extends {
+    notNull: true;
+  } | {
+    primaryKey: true;
+  } ? {
+    notNull: true;
+  } : {
+    notNull?: false;
+  } : never : never));
+  index: (name: string, columnNames: string[], options?: {
+    unique?: boolean;
+  } & SchemaComponentOptions) => IndexSchemaComponent;
+};
+//#endregion
+//#region src/core/sql/tokenizedSQL/tokenizedSQL.d.ts
+type TokenizedSQL = Readonly<{
+  __brand: 'tokenized-sql';
+  sqlChunks: ReadonlyArray<string>;
+  sqlTokens: ReadonlyArray<AnySQLToken>;
+}>;
+declare const TokenizedSQL: {
+  (strings: ReadonlyArray<string>, values: unknown[]): TokenizedSQL;
+  paramPlaceholder: string;
+  empty: {
+    __brand: "tokenized-sql";
+    sqlChunks: string[];
+    sqlTokens: never[];
+  };
+};
+declare const isTokenizedSQL: (value: unknown) => value is TokenizedSQL;
+//#endregion
+//#region src/core/sql/sql.d.ts
+/** A tokenized SQL statement created with the {@link SQL} template tag. */
+type SQL = string & {
+  __brand: 'sql';
+};
+type SQLTag = {
+  /**
+   * Creates a tokenized SQL statement.
+   *
+   * Interpolated values are treated as bound parameters by default. Use the
+   * helper methods on `SQL` for SQL syntax that cannot be represented as a bound
+   * parameter, such as identifiers or trusted raw fragments.
+   */
+  (strings: TemplateStringsArray, ...values: unknown[]): SQL; /** Empty SQL statement used when optional query fragments are absent. */
+  EMPTY: SQL; /** Concatenates SQL fragments without adding a separator. */
+  concat: (...sqls: SQL[]) => SQL;
+  /**
+   * Merges SQL fragments, skipping empty fragments and inserting a separator
+   * between non-empty fragments.
+   */
+  merge: (sqls: SQL[], separator?: string) => SQL; /** Formats SQL into a parametrized query and params using the selected formatter. */
+  format: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => ParametrizedSQL; /** Formats SQL into a readable SQL string for diagnostics and migrations. */
+  describe: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => string; /** Creates a SQL `IN`/native-array token for the provided column and values. */
+  in: (column: string, values: unknown[], options?: {
+    mode?: SQLArrayMode;
+  }) => SQLIn; /** Creates an array token that formatters can render as native or expanded params. */
+  array: (values: unknown[], options?: {
+    mode?: SQLArrayMode;
+  }) => SQLArray; /** Creates a SQL identifier token, quoting it when required by SQL rules. */
+  identifier: typeof SQLIdentifier.from;
+  /**
+   * Creates a trusted raw SQL fragment.
+   *
+   * This does not quote, escape, or bind the value. Prefer bound parameters for
+   * data values, `SQL.identifier` for identifiers, and `SQL.literal` only when
+   * SQL syntax requires an inline value literal.
+   */
+  plain: typeof SQLPlain.from;
+  /**
+   * Creates an inline SQL value literal.
+   *
+   * Use this for SQL syntax positions that cannot use bound parameters. Data
+   * values in ordinary queries should stay as template interpolations.
+   */
+  literal: (value: string) => SQLPlain; /** Type guards and helpers for SQL tokens. */
+  check: {
+    isSQL: (value: unknown) => value is SQL;
+    isTokenizedSQL: (value: unknown) => value is TokenizedSQL;
+    isEmpty: (sql: SQL) => boolean;
+    isIdentifier: typeof SQLIdentifier.check;
+    isPlain: typeof SQLPlain.check;
+    isSQLIn: typeof SQLIn.check;
+  }; /** Creates a schema column token for SQL generation. */
+  column: typeof SQLColumnToken.from & {
+    /** Column type token factory. */type: typeof SQLColumnTypeTokensFactory;
+  }; /** Creates a schema column token using Dumbo schema metadata. */
+  columnN: typeof dumboSchema.column & {
+    /** Column type token factory. */type: typeof SQLColumnTypeTokensFactory;
+  };
+};
+/**
+ * Creates SQL by interpolating values directly into the statement.
+ *
+ * Prefer {@link SQL} for query execution. `RawSQL` is for trusted SQL text that
+ * is already safe to inline.
+ */
+declare function RawSQL(strings: TemplateStringsArray, ...values: unknown[]): SQL;
+/** Returns true when the value is a tokenized SQL statement. */
+declare const isSQL: (value: unknown) => value is SQL;
+declare const SQL: SQLTag;
+//#endregion
+//#region src/core/sql/formatters/sqlFormatter.d.ts
+type FormatContext = Partial<SQLProcessorContext> & Pick<SQLProcessorContext, 'serializer'>;
+interface SQLFormatter {
+  format: (sql: SQL | SQL[], context: FormatContext) => ParametrizedSQL;
+  describe: (sql: SQL | SQL[], context: FormatContext) => string;
+  valueMapper: SQLValueMapper;
+}
+type FormatSQLOptions = {
+  mapper?: MapSQLParamValueOptions;
+  processorsRegistry?: SQLProcessorsReadonlyRegistry;
+  serializer?: JSONSerializer;
+};
+type SQLFormatterOptions = Partial<Omit<SQLFormatter, 'valueMapper'>> & {
+  valueMapper?: MapSQLParamValueOptions;
+  processorsRegistry?: SQLProcessorsReadonlyRegistry;
+};
+declare const SQLFormatter: ({
+  format,
+  describe,
+  valueMapper: valueMapperOptions,
+  processorsRegistry
+}: SQLFormatterOptions) => SQLFormatter;
+declare global {
+  var dumboSQLFormatters: Record<string, SQLFormatter>;
+}
+declare const registerFormatter: (dialect: string, formatter: SQLFormatter) => void;
+declare const getFormatter: (dialect: string) => SQLFormatter;
+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;
+//#endregion
+//#region src/core/sql/parameters/jsonParam.d.ts
+declare const JSONParam: {
+  readonly arrayContaining: (jsonValue: unknown, serializer: JSONSerializer) => string;
+  readonly document: (document: unknown, serializer: JSONSerializer) => string;
+  readonly value: (jsonValue: unknown, serializer: JSONSerializer) => string;
+};
+//#endregion
+//#region src/core/schema/components/columnSchemaComponent.d.ts
+type ColumnURNType = 'sc:dumbo:column';
+type ColumnURN<ColumnName extends string = string> = `${ColumnURNType}:${ColumnName}`;
+declare const ColumnURNType: ColumnURNType;
+declare const ColumnURN: <ColumnName extends string = string>({
+  name
+}: {
+  name: ColumnName;
+}) => ColumnURN<ColumnName>;
+type ColumnSchemaComponent<ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string, ColumnName extends string = string> = SchemaComponent<ColumnURN<ColumnName>, Readonly<{
+  columnName: ColumnName;
+}>> & SQLColumnToken<ColumnType>;
+type AnyColumnSchemaComponent = ColumnSchemaComponent<any>;
+type ColumnSchemaComponentOptions<ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string> = Omit<SQLColumnToken<ColumnType>, 'name' | 'sqlTokenType'> & SchemaComponentOptions;
+declare const columnSchemaComponent: <const ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string, const TOptions extends ColumnSchemaComponentOptions<ColumnType> = ColumnSchemaComponentOptions<ColumnType>, const ColumnName extends string = string>(params: {
+  columnName: ColumnName;
+} & TOptions) => ColumnSchemaComponent<ColumnType, ColumnName> & (TOptions extends {
+  notNull: true;
+} | {
+  primaryKey: true;
+} ? {
+  notNull: true;
+} : {
+  notNull?: false;
+});
+//#endregion
+//#region src/core/schema/components/indexSchemaComponent.d.ts
+type IndexURNType = 'sc:dumbo:index';
+type IndexURN = `${IndexURNType}:${string}`;
+type IndexSchemaComponent = SchemaComponent<IndexURN, Readonly<{
+  indexName: string;
+  columnNames: ReadonlyArray<string>;
+  isUnique: boolean;
+  addColumn: (column: string | ColumnSchemaComponent) => void;
+}>>;
+declare const IndexURNType: IndexURNType;
+declare const IndexURN: ({
+  name
+}: {
+  name: string;
+}) => IndexURN;
+declare const indexSchemaComponent: ({
+  indexName,
+  columnNames,
+  isUnique,
+  ...migrationsOrComponents
+}: {
+  indexName: string;
+  columnNames: string[];
+  isUnique: boolean;
+} & SchemaComponentOptions) => IndexSchemaComponent;
+//#endregion
+//#region src/core/typing/conditionals.d.ts
+type IF<Condition extends boolean, Then, Else> = Condition extends true ? Then : Else;
+type AND<A extends boolean, B extends boolean> = A extends true ? B extends true ? true : false : false;
+type ALL<A extends boolean[]> = A extends [infer First, ...infer Rest] ? First extends true ? Rest extends boolean[] ? ALL<Rest> : true : false : true;
+//#endregion
+//#region src/core/typing/records.d.ts
+type KeysOfString<T extends Record<string, unknown>> = Extract<keyof T, string>;
+//#endregion
+//#region src/core/typing/validation.d.ts
+type TypeValidationResult<Valid extends boolean = boolean, Error = never> = Valid extends true ? {
+  valid: true;
+} : {
+  valid: false;
+  error: Error;
+};
+type TypeValidationError<Error> = TypeValidationResult<false, Error>;
+type TypeValidationSuccess = TypeValidationResult<true>;
+type AnyTypeValidationError = TypeValidationError<any>;
+type AnyTypeValidationResult = TypeValidationResult<boolean, any>;
+type AnyTypeValidationFailed<Results = AnyTypeValidationResult[]> = Results extends readonly [infer First, ...infer Rest] ? First extends {
+  valid: false;
+} ? true : Rest extends AnyTypeValidationResult[] ? AnyTypeValidationFailed<Rest> : false : false;
+type UnwrapTypeValidationErrors<Results extends readonly AnyTypeValidationResult[]> = Results extends readonly [infer First, ...infer Rest] ? First extends TypeValidationResult<false, infer E> ? Rest extends readonly AnyTypeValidationResult[] ? [E, ...UnwrapTypeValidationErrors<Rest>] : [E] : Rest extends readonly AnyTypeValidationResult[] ? UnwrapTypeValidationErrors<Rest> : [] : [];
+type FailOnFirstTypeValidationError<Validations extends readonly AnyTypeValidationResult[]> = Validations extends readonly [infer First, ...infer Rest] ? First extends AnyTypeValidationError ? First : Rest extends readonly AnyTypeValidationResult[] ? FailOnFirstTypeValidationError<Rest> : First : null;
+//#endregion
+//#region src/core/typing/tuples.d.ts
+type GetTupleLength<T extends readonly unknown[]> = T['length'];
+type NotEmptyTuple<T extends readonly unknown[]> = GetTupleLength<T> extends 0 ? never : T;
+type HaveTuplesTheSameLength<T extends readonly unknown[], U extends readonly unknown[]> = GetTupleLength<T> extends GetTupleLength<U> ? true : false;
+type IsEmptyTuple<T extends readonly unknown[]> = T extends [] ? true : false;
+type IsNotEmptyTuple<T extends readonly unknown[]> = IsEmptyTuple<T> extends true ? false : true;
+type FilterNotExistingInUnion<Tuple extends readonly string[], Union extends string> = Tuple extends readonly [infer First, ...infer Rest] ? First extends Union ? [...FilterNotExistingInUnion<Rest extends readonly string[] ? Rest : [], Union>] : [First, ...FilterNotExistingInUnion<Rest extends readonly string[] ? Rest : [], Union>] : [];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : never> extends (() => infer R) ? R : never;
+type UnionToTuple<T, L = LastOfUnion<T>> = [T] extends [never] ? [] : [...UnionToTuple<Exclude<T, L>>, L];
+type ZipTuplesCollectErrors<TupleA extends readonly unknown[], TupleB extends readonly unknown[], ValidateMap, Accumulated extends AnyTypeValidationError[] = []> = [TupleA, TupleB] extends [readonly [infer FirstA, ...infer RestA], readonly [infer FirstB, ...infer RestB]] ? FirstA extends keyof ValidateMap ? FirstB extends keyof ValidateMap[FirstA] ? ValidateMap[FirstA][FirstB] extends infer Result extends AnyTypeValidationError ? ZipTuplesCollectErrors<RestA, RestB, ValidateMap, [...Accumulated, Result]> : ZipTuplesCollectErrors<RestA, RestB, ValidateMap, Accumulated> : ZipTuplesCollectErrors<RestA, RestB, ValidateMap, Accumulated> : ZipTuplesCollectErrors<RestA, RestB, ValidateMap, Accumulated> : Accumulated;
+type MapRecordCollectErrors<Record extends object, ValidateMap, Accumulated extends AnyTypeValidationError[] = [], Keys extends readonly unknown[] = UnionToTuple<keyof Record>> = Keys extends readonly [infer K, ...infer Rest] ? K extends keyof ValidateMap ? ValidateMap[K] extends infer Result extends AnyTypeValidationError ? MapRecordCollectErrors<Record, ValidateMap, [...Accumulated, Result], Rest> : MapRecordCollectErrors<Record, ValidateMap, Accumulated, Rest> : MapRecordCollectErrors<Record, ValidateMap, Accumulated, Rest> : Accumulated;
+//#endregion
+//#region src/core/schema/components/relationships/relationshipTypes.d.ts
+type ExtractSchemaNames<DB> = DB extends DatabaseSchemaComponent<infer Schemas extends DatabaseSchemas> ? keyof Schemas : never;
+type ExtractTableNames<Schema extends AnyDatabaseSchemaSchemaComponent> = Schema extends DatabaseSchemaSchemaComponent<infer Tables extends DatabaseSchemaTables> ? keyof Tables : never;
+type ExtractColumnNames<Table extends AnyTableSchemaComponent> = Table extends TableSchemaComponent<infer Columns extends TableColumns> ? TableColumnNames<TableSchemaComponent<Columns>> : never;
+type ExtractColumnTypeName<T> = T extends ColumnTypeToken<any, infer TypeName, any, any> ? Uppercase<TypeName> : never;
+type AllColumnTypes<Schemas extends DatabaseSchemas> = { [SchemaName in keyof Schemas]: Schemas[SchemaName] extends DatabaseSchemaSchemaComponent<infer Tables> ? Writable<{ [TableName in keyof Tables]: Tables[TableName] extends TableSchemaComponent<infer Columns> ? Writable<{ [ColumnName in keyof Columns]: {
+  columnTypeName: ExtractColumnTypeName<Columns[ColumnName$1]['type']>;
+} }> : never }> : never };
+type AllColumnReferences<Schemas extends DatabaseSchemas> = { [SchemaName in keyof Schemas]: Schemas[SchemaName] extends DatabaseSchemaSchemaComponent<infer Tables> ? { [TableName in keyof Tables]: Tables[TableName] extends TableSchemaComponent<infer Columns> ? { [ColumnName in keyof Columns]: `${SchemaName & string}.${TableName & string}.${ColumnName$1 & string}` }[keyof Columns] : never }[keyof Tables] : never }[keyof Schemas];
+type AllColumnTypesInSchema<Schema extends AnyDatabaseSchemaSchemaComponent> = Schema extends DatabaseSchemaSchemaComponent<infer Tables> ? { [TableName in keyof Tables]: Tables[TableName] extends TableSchemaComponent<infer Columns> ? { [ColumnName in keyof Columns]: {
+  columnTypeName: ExtractColumnTypeName<Columns[ColumnName$1]['type']>;
+} } : never } : never;
+type AllColumnReferencesInSchema<Schema extends AnyDatabaseSchemaSchemaComponent, SchemaName extends string> = Schema extends DatabaseSchemaSchemaComponent<infer Tables> ? { [TableName in keyof Tables]: Tables[TableName] extends TableSchemaComponent<infer Columns> ? { [ColumnName in keyof Columns]: `${SchemaName & string}.${TableName & string}.${ColumnName$1 & string}` }[keyof Columns] : never }[keyof Tables] : never;
+type NormalizeReference<Path extends string, CurrentSchema extends string, CurrentTable extends string> = Path extends `${infer Schema}.${infer Table}.${infer Column}` ? `${Schema}.${Table}.${Column}` : Path extends `${infer Table}.${infer Column}` ? `${CurrentSchema}.${Table}.${Column}` : Path extends string ? `${CurrentSchema}.${CurrentTable}.${Path}` : never;
+type NormalizeColumnPath<References extends readonly string[], SchemaName extends string, TableName extends string> = References extends readonly [infer First, ...infer Rest] ? First extends string ? Rest extends readonly string[] ? readonly [NormalizeReference<First, SchemaName, TableName>, ...NormalizeColumnPath<Rest, SchemaName, TableName>] : readonly [] : readonly [] : readonly [];
+type ColumnName$1<ColName extends string = string> = `${ColName}`;
+type TableColumnName<TableName extends string = string, ColName extends string = string> = `${TableName}.${ColName}`;
+type SchemaColumnName<SchemaName extends string = string, TableName extends string = string, ColumnName extends string = string> = `${SchemaName}.${TableName}.${ColumnName}`;
+type ColumnPath<SchemaName extends string = string, TableName extends string = string, ColName extends string = string> = SchemaColumnName<SchemaName, TableName, ColName> | TableColumnName<TableName, ColName> | ColumnName$1<ColName>;
+type ColumnReference<SchemaName extends string = string, TableName extends string = string, ColumnName extends string = string> = {
+  schemaName: SchemaName;
+  tableName: TableName;
+  columnName: ColumnName;
+};
+type ColumnPathToReference<Reference extends ColumnPath = ColumnPath, CurrentSchema extends string = string, CurrentTable extends string = string> = NormalizeReference<Reference, CurrentSchema, CurrentTable> extends `${infer S}.${infer T}.${infer C}` ? {
+  schemaName: S;
+  tableName: T;
+  columnName: C;
+} : never;
+type ParseReferencePath<Path extends string> = Path extends `${infer Schema}.${infer Table}.${infer Column}` ? {
+  schema: Schema;
+  table: Table;
+  column: Column;
+} : never;
+type LookupColumnType<AllTypes, Path extends string> = ParseReferencePath<Path> extends {
+  schema: infer S;
+  table: infer T;
+  column: infer C;
+} ? S extends keyof AllTypes ? T extends keyof AllTypes[S] ? C extends keyof AllTypes[S][T] ? AllTypes[S][T][C] extends {
+  columnTypeName: infer TypeName;
+} ? TypeName : never : never : never : never : never;
+type RelationshipType = 'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many';
+type RelationshipDefinition<Columns extends string = string, Reference extends string = string, RelType extends RelationshipType = RelationshipType> = {
+  readonly columns: NotEmptyTuple<readonly Columns[]>;
+  readonly references: NotEmptyTuple<readonly Reference[]>;
+  readonly type: RelType;
+};
+type AnyTableRelationshipDefinition = RelationshipDefinition<any, any, any>;
+type AnyTableRelationshipDefinitionWithColumns<Columns extends string = string> = RelationshipDefinition<Columns, any, any>;
+type TableRelationships<Columns extends string = string> = Record<string, AnyTableRelationshipDefinitionWithColumns<Columns>>;
+declare const relationship: <const Columns extends readonly string[], const References extends readonly string[], const RelType extends RelationshipType = RelationshipType>(columns: Columns, references: References, type: RelType) => {
+  readonly columns: Columns;
+  readonly references: References;
+  readonly type: RelType;
+};
+type AnyRelationshipDefinition = RelationshipDefinition<any, any, any>;
+//#endregion
+//#region src/core/schema/components/tableTypesInference.d.ts
+type Writable<T> = { -readonly [P in keyof T]: T[P] };
+type InferColumnType<ColumnType> = ColumnType extends ColumnTypeToken<infer _JSType, infer _ColumnTypeName, infer _TProps, infer ValueType> ? ValueType : ColumnType;
+type TableColumnType<T extends AnyColumnSchemaComponent> = T extends ColumnSchemaComponent<infer ColumnType> ? T extends {
+  notNull: true;
+} | {
+  primaryKey: true;
+} ? InferColumnType<ColumnType> : InferColumnType<ColumnType> | null : unknown;
+type TableColumnNames<T extends AnyTableSchemaComponent> = Exclude<keyof T['columns'], keyof ReadonlyMap<string, AnyColumnSchemaComponent>>;
+type InferTableRow<Columns extends TableColumns> = Writable<{ [K in keyof Columns]: TableColumnType<Columns[K]> }>;
+type TableRowType<T extends AnyTableSchemaComponent> = T extends TableSchemaComponent<infer Columns> ? InferTableRow<Columns> : never;
+type InferSchemaTables<T extends AnyDatabaseSchemaSchemaComponent> = T extends DatabaseSchemaSchemaComponent<infer Tables> ? Tables : never;
+type InferDatabaseSchemas<T extends AnyDatabaseSchemaComponent> = T extends DatabaseSchemaComponent<infer Schemas> ? Schemas : never;
+//#endregion
+//#region src/core/schema/components/tableSchemaComponent.d.ts
+type TableURNType = 'sc:dumbo:table';
+type TableURN = `${TableURNType}:${string}`;
+declare const TableURNType: TableURNType;
+declare const TableURN: ({
+  name
+}: {
+  name: string;
+}) => TableURN;
+type TableColumns = Record<string, AnyColumnSchemaComponent>;
+type TableSchemaComponent<Columns extends TableColumns = TableColumns, TableName extends string = string, Relationships extends TableRelationships<keyof Columns & string> = {} & TableRelationships<keyof Columns & string>> = SchemaComponent<TableURN, Readonly<{
+  tableName: TableName;
+  columns: ReadonlyMap<string, AnyColumnSchemaComponent> & Columns;
+  primaryKey: TableColumnNames<TableSchemaComponent<Columns, TableName, Relationships>>[];
+  relationships: Relationships;
+  indexes: ReadonlyMap<string, IndexSchemaComponent>;
+  addColumn: (column: AnyColumnSchemaComponent) => AnyColumnSchemaComponent;
+  addIndex: (index: IndexSchemaComponent) => IndexSchemaComponent;
+}>>;
+type InferTableSchemaComponentTypes<T extends AnyTableSchemaComponent> = T extends TableSchemaComponent<infer Columns, infer TableName, infer Relationships> ? [Columns, TableName, Relationships] : never;
+type InferTableSchemaComponentColumns<T extends AnyTableSchemaComponent> = InferTableSchemaComponentTypes<T>[0];
+type AnyTableSchemaComponent = TableSchemaComponent<any, any, any>;
+declare const tableSchemaComponent: <const Columns extends TableColumns = TableColumns, const TableName extends string = string, const Relationships extends TableRelationships<keyof Columns & string> = {}>({
+  tableName,
+  columns,
+  primaryKey,
+  relationships,
+  ...migrationsOrComponents
+}: {
+  tableName: TableName;
+  columns?: Columns;
+  primaryKey?: TableColumnNames<TableSchemaComponent<Columns, TableName, Relationships>>[];
+  relationships?: Relationships;
+} & SchemaComponentOptions) => TableSchemaComponent<Columns, TableName, Relationships> & {
+  relationships: Relationships;
+};
+//#endregion
+//#region src/core/schema/components/databaseSchemaSchemaComponent.d.ts
+type DatabaseSchemaURNType = 'sc:dumbo:database_schema';
+type DatabaseSchemaURN<SchemaName extends string = string> = `${DatabaseSchemaURNType}:${SchemaName}`;
+declare const DatabaseSchemaURNType: DatabaseSchemaURNType;
+declare const DatabaseSchemaURN: <SchemaName extends string = string>({
+  name
+}: {
+  name: SchemaName;
+}) => DatabaseSchemaURN<SchemaName>;
+type DatabaseSchemaTables<Tables extends AnyTableSchemaComponent = AnyTableSchemaComponent> = Record<string, Tables>;
+type DatabaseSchemaSchemaComponent<Tables extends DatabaseSchemaTables = DatabaseSchemaTables, SchemaName extends string = string> = SchemaComponent<DatabaseSchemaURN<SchemaName>, Readonly<{
+  schemaName: SchemaName;
+  tables: ReadonlyMap<string, TableSchemaComponent> & Tables;
+  addTable: (table: string | TableSchemaComponent) => TableSchemaComponent;
+}>>;
+type AnyDatabaseSchemaSchemaComponent = DatabaseSchemaSchemaComponent<any, any>;
+declare const databaseSchemaSchemaComponent: <const Tables extends DatabaseSchemaTables = DatabaseSchemaTables, const SchemaName extends string = string>({
+  schemaName,
+  tables,
+  ...migrationsOrComponents
+}: {
+  schemaName: SchemaName;
+  tables?: Tables;
+} & SchemaComponentOptions) => DatabaseSchemaSchemaComponent<Tables, SchemaName>;
+//#endregion
+//#region src/core/schema/components/databaseSchemaComponent.d.ts
+type DatabaseURNType = 'sc:dumbo:database';
+type DatabaseURN = `${DatabaseURNType}:${string}`;
+declare const DatabaseURNType: DatabaseURNType;
+declare const DatabaseURN: ({
+  name
+}: {
+  name: string;
+}) => DatabaseURN;
+type DatabaseSchemas<Schemas extends AnyDatabaseSchemaSchemaComponent = AnyDatabaseSchemaSchemaComponent> = Record<string, Schemas>;
+type DatabaseSchemaComponent<Schemas extends DatabaseSchemas = DatabaseSchemas> = SchemaComponent<DatabaseURN, Readonly<{
+  databaseName: string;
+  schemas: ReadonlyMap<string, DatabaseSchemaSchemaComponent> & Schemas;
+  addSchema: (schema: string | DatabaseSchemaSchemaComponent) => DatabaseSchemaSchemaComponent;
+}>>;
+type AnyDatabaseSchemaComponent = DatabaseSchemaComponent<any>;
+declare const databaseSchemaComponent: <Schemas extends DatabaseSchemas = DatabaseSchemas>({
+  databaseName,
+  schemas,
+  ...migrationsOrComponents
+}: {
+  databaseName: string;
+  schemas?: Schemas;
+} & SchemaComponentOptions) => DatabaseSchemaComponent<Schemas>;
+//#endregion
+//#region src/core/schema/components/relationships/formatRelationshipErrors.d.ts
+type Join<T extends readonly string[], Sep extends string> = T extends readonly [infer First extends string, ...infer Rest extends readonly string[]] ? Rest extends readonly [] ? First : `${First}${Sep}${Join<Rest, Sep>}` : '';
+type IndentErrors<Messages extends readonly string[]> = Messages extends readonly [infer First extends string, ...infer Rest extends readonly string[]] ? [`  - ${First}`, ...IndentErrors<Rest>] : [];
+type ExtractSchemaFromReference<T extends string> = T extends `${infer Schema}.${string}.${string}` ? Schema : never;
+type ExtractTableFromReference<T extends string> = T extends `${string}.${infer Table}.${string}` ? Table : never;
+type ExtractColumnFromReference<T extends string> = T extends `${string}.${string}.${infer Column}` ? Column : never;
+type TupleLength<T extends readonly unknown[]> = T extends {
+  length: infer L;
+} ? L : never;
+type FormatSingleError<E> = E extends {
+  errorCode: 'reference_columns_mismatch';
+  invalidColumns: infer InvalidCols extends readonly string[];
+  availableColumns: infer AvailableCols extends readonly string[];
+} ? `Invalid columns: ${Join<InvalidCols, ', '>}. Available columns: ${Join<AvailableCols, ', '>}` : E extends {
+  errorCode: 'reference_length_mismatch';
+  columns: infer Cols extends readonly string[];
+  references: infer Refs extends readonly string[];
+} ? `Column count mismatch: ${TupleLength<Cols>} columns ([${Join<Cols, ', '>}]) but ${TupleLength<Refs>} references ([${Join<Refs, ', '>}])` : E extends {
+  errorCode: 'missing_schema';
+  reference: infer Ref extends string;
+} ? `Schema "${ExtractSchemaFromReference<Ref>}" does not exist (${Ref})` : E extends {
+  errorCode: 'missing_table';
+  reference: infer Ref extends string;
+} ? `Table "${ExtractTableFromReference<Ref>}" does not exist in schema "${ExtractSchemaFromReference<Ref>}" (${Ref})` : E extends {
+  errorCode: 'missing_column';
+  reference: infer Ref extends string;
+} ? `Column "${ExtractColumnFromReference<Ref>}" does not exist in table "${ExtractSchemaFromReference<Ref>}.${ExtractTableFromReference<Ref>}" (${Ref})` : E extends {
+  errorCode: 'type_mismatch';
+  reference: infer Ref extends string;
+  referenceType: infer RefType extends string;
+  columnTypeName: infer ColType extends string;
+} ? `Type mismatch: column type "${ColType}" does not match referenced column type "${RefType}" (${Ref})` : never;
+type FormatErrorMessages<Errors extends readonly unknown[]> = Errors extends readonly [infer First, ...infer Rest extends readonly unknown[]] ? [FormatSingleError<First>, ...FormatErrorMessages<Rest>] : [];
+type FormatRelationshipBlock<E> = E extends {
+  relationship: infer RelName extends string;
+  errors: infer Errors extends readonly unknown[];
+} ? Join<[`Relationship "${RelName}":`, ...IndentErrors<FormatErrorMessages<Errors>>], '\n'> : never;
+type IndentLine<Line extends string> = `  ${Line}`;
+type IndentRelationshipBlock<Block extends string> = Block extends `${infer FirstLine}\n${infer Rest}` ? `${IndentLine<FirstLine>}\n${IndentRelationshipBlock<Rest>}` : IndentLine<Block>;
+type FormatRelationshipBlocks<RelErrors extends readonly unknown[]> = RelErrors extends readonly [infer First, ...infer Rest extends readonly unknown[]] ? Rest extends readonly [] ? IndentRelationshipBlock<FormatRelationshipBlock<First>> : `${IndentRelationshipBlock<FormatRelationshipBlock<First>>}\n${FormatRelationshipBlocks<Rest>}` : '';
+type FormatTableLevel<E> = E extends {
+  table: infer TableName extends string;
+  errors: infer RelErrors extends readonly unknown[];
+} ? `Table "${TableName}":\n${FormatRelationshipBlocks<RelErrors>}` : never;
+type IndentTableBlock<Block extends string> = Block extends `${infer FirstLine}\n${infer Rest}` ? `  ${FirstLine}\n${IndentTableBlock<Rest>}` : `  ${Block}`;
+type FormatTableBlocks<TableErrors extends readonly unknown[]> = TableErrors extends readonly [infer First, ...infer Rest extends readonly unknown[]] ? Rest extends readonly [] ? IndentTableBlock<FormatTableLevel<First>> : `${IndentTableBlock<FormatTableLevel<First>>}\n${FormatTableBlocks<Rest>}` : '';
+type FormatSchemaLevel<E> = E extends {
+  schema: infer SchemaName extends string;
+  errors: infer TableErrors extends readonly unknown[];
+} ? `Schema "${SchemaName}":\n${FormatTableBlocks<TableErrors>}` : never;
+type FormatSchemaBlocks<SchemaErrors extends readonly unknown[]> = SchemaErrors extends readonly [infer First, ...infer Rest extends readonly unknown[]] ? Rest extends readonly [] ? FormatSchemaLevel<First> : `${FormatSchemaLevel<First>}\n${FormatSchemaBlocks<Rest>}` : '';
+type FormatDatabaseValidationErrors<Errors extends readonly unknown[]> = FormatSchemaBlocks<Errors>;
+type FormatValidationErrors<Result> = Result extends {
+  valid: false;
+  error: infer Errors extends readonly unknown[];
+} ? `Relationship validation errors:\n\n${FormatDatabaseValidationErrors<Errors>}` : never;
+//#endregion
+//#region src/core/schema/components/relationships/relationshipValidation.d.ts
+type RelationshipColumnsMismatchError<ColumnPath extends SchemaColumnName = SchemaColumnName> = {
+  valid: false;
+  error: {
+    errorCode: 'reference_columns_mismatch';
+    invalidColumns: ColumnPath[];
+    availableColumns: ColumnPath[];
+  };
+};
+type RelationshipReferencesLengthMismatchError<ColumnPath extends SchemaColumnName = SchemaColumnName> = {
+  valid: false;
+  error: {
+    errorCode: 'reference_length_mismatch';
+    columns: ColumnPath[];
+    references: ColumnPath[];
+  };
+};
+type ColumnReferenceExistanceError<ErrorCode extends 'missing_schema' | 'missing_table' | 'missing_column' = 'missing_schema' | 'missing_table' | 'missing_column', ColumnPath extends SchemaColumnName = SchemaColumnName> = {
+  valid: false;
+  error: {
+    errorCode: ErrorCode;
+    reference: ColumnPath;
+  };
+};
+type ColumnReferenceTypeMismatchError<Reference extends SchemaColumnName = SchemaColumnName, ReferenceTypeName extends string = string, ColumnTypeName extends string = string> = {
+  valid: false;
+  error: {
+    errorCode: 'type_mismatch';
+    reference: Reference;
+    referenceType: ReferenceTypeName;
+    columnTypeName: ColumnTypeName;
+  };
+};
+type NoError = TypeValidationSuccess;
+type ColumnReferenceError = ColumnReferenceExistanceError | ColumnReferenceTypeMismatchError;
+type RelationshipValidationError = RelationshipColumnsMismatchError | RelationshipReferencesLengthMismatchError | ColumnReferenceError;
+type ValidateRelationshipLength<Rel extends AnyTableRelationshipDefinition> = IF<ALL<[HaveTuplesTheSameLength<Rel['columns'], Rel['references']>, IsNotEmptyTuple<Rel['columns']>, IsNotEmptyTuple<Rel['references']>]>, TypeValidationSuccess, TypeValidationResult<false, {
+  errorCode: 'reference_length_mismatch';
+  columns: Rel['columns'];
+  references: Rel['references'];
+}>>;
+type ValidateRelationshipColumns<Relationship extends AnyTableRelationshipDefinition, ValidColumns extends TableColumns> = FilterNotExistingInUnion<Relationship['columns'], KeysOfString<ValidColumns>> extends infer InvalidColumns extends NotEmptyTuple<string[]> ? IF<AND<IsEmptyTuple<InvalidColumns>, IsNotEmptyTuple<Relationship['columns']>>, TypeValidationSuccess, TypeValidationResult<false, {
+  errorCode: 'reference_columns_mismatch';
+  invalidColumns: InvalidColumns;
+  availableColumns: KeysOfString<ValidColumns>;
+}>> : TypeValidationSuccess;
+type ValidateColumnReference<ColReference extends SchemaColumnName, Schemas extends DatabaseSchemas> = ColReference extends SchemaColumnName<infer SchemaName, infer TableName, infer ColumnName> ? SchemaName extends keyof Schemas ? TableName extends keyof Schemas[SchemaName]['tables'] ? Schemas[SchemaName]['tables'][TableName] extends TableSchemaComponent<infer Columns, infer _TableName, infer _Relationships> ? ColumnName extends keyof Columns ? Columns[ColumnName] : ColumnReferenceExistanceError<'missing_column', `${SchemaName}.${TableName}.${ColumnName}`> : never : ColumnReferenceExistanceError<'missing_table', `${SchemaName}.${TableName}.${ColumnName}`> : ColumnReferenceExistanceError<'missing_schema', `${SchemaName}.${TableName}.${ColumnName}`> : never;
+type ValidateColumnTypeMatch<RefColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string, ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string, Reference extends SchemaColumnName = SchemaColumnName> = ColumnType extends ColumnTypeToken<infer _JsType, infer ColumnTypeName, infer _TProps> ? RefColumnType extends ColumnTypeToken<infer _JsType, infer RefColumnTypeName, infer _TProps> ? RefColumnTypeName extends ColumnTypeName ? TypeValidationSuccess : ColumnReferenceTypeMismatchError<Reference, RefColumnTypeName, ColumnTypeName> : RefColumnType extends ColumnTypeName ? TypeValidationSuccess : ColumnReferenceTypeMismatchError<Reference, Extract<RefColumnType, string>, ColumnTypeName> : RefColumnType extends ColumnTypeToken<infer _JsType, infer RefColumnTypeName, infer _TProps> ? RefColumnTypeName extends ColumnType ? TypeValidationSuccess : ColumnReferenceTypeMismatchError<Reference, RefColumnTypeName, Extract<ColumnType, string>> : RefColumnType extends ColumnType ? TypeValidationSuccess : ColumnReferenceTypeMismatchError<Reference, Extract<RefColumnType, string>, Extract<ColumnType, string>>;
+type ValidateColumnsMatch<ReferenceColumn extends AnyColumnSchemaComponent, Column extends AnyColumnSchemaComponent, references extends SchemaColumnName = SchemaColumnName> = Column extends ColumnSchemaComponent<infer ColumnType> ? ReferenceColumn extends ColumnSchemaComponent<infer RefColumnType> ? ValidateColumnTypeMatch<RefColumnType, ColumnType, references> : never : never;
+type ValidateReference<RefPath extends SchemaColumnName = SchemaColumnName, ColPath extends SchemaColumnName = SchemaColumnName, Schemas extends DatabaseSchemas = DatabaseSchemas> = ColPath extends SchemaColumnName<infer SchemaName, infer TableName, infer Column> ? ValidateColumnReference<RefPath, Schemas> extends infer RefColumn ? RefColumn extends AnyColumnSchemaComponent ? ValidateColumnsMatch<RefColumn, Schemas[SchemaName]['tables'][TableName]['columns'][Column], RefPath> : RefColumn extends {
+  valid: false;
+  error: infer E;
+} ? TypeValidationError<E> : never : never : never;
+type ValidateReferences<RefPath extends SchemaColumnName = SchemaColumnName, ColPath extends SchemaColumnName = SchemaColumnName, Schemas extends DatabaseSchemas = DatabaseSchemas> = ColPath extends SchemaColumnName<infer SchemaName, infer TableName, infer Column> ? ValidateColumnReference<RefPath, Schemas> extends infer RefColumn ? RefColumn extends AnyColumnSchemaComponent ? ValidateColumnsMatch<RefColumn, Schemas[SchemaName]['tables'][TableName]['columns'][Column], RefPath> : RefColumn extends {
+  valid: false;
+  error: infer E;
+} ? TypeValidationError<E> : never : never : never;
+type CollectReferencesErrors<Columns extends readonly SchemaColumnName[], References extends readonly SchemaColumnName[], _CurrentSchema extends string, _CurrentTable extends string, Schemas extends DatabaseSchemas = DatabaseSchemas, Errors extends AnyTypeValidationError[] = []> = ZipTuplesCollectErrors<References, Columns, { [R in References[number]]: { [C in Columns[number]]: ValidateReference<R, C, Schemas> } }, Errors>;
+type SchemaTablesWithSingle<Table extends AnyTableSchemaComponent> = Table extends TableSchemaComponent<infer _Columns, infer TableName, infer _FKs> ? DatabaseSchemaSchemaComponent<{ [K in TableName]: Table }> : never;
+type DatabaseSchemasWithSingle<Schema extends AnyDatabaseSchemaSchemaComponent> = Schema extends DatabaseSchemaSchemaComponent<infer _Tables, infer _SchemaName> ? { [K in _SchemaName]: Schema } : never;
+type ValidateRelationship<Columns extends TableColumns, Relationship extends AnyTableRelationshipDefinitionWithColumns<Extract<keyof Columns, string>>, RelationshipName extends string, CurrentTableName extends string, Table extends AnyTableSchemaComponent = AnyTableSchemaComponent, Schema extends AnyDatabaseSchemaSchemaComponent = SchemaTablesWithSingle<Table>, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>> = FailOnFirstTypeValidationError<[ValidateRelationshipLength<Relationship>, ValidateRelationshipColumns<Relationship, Columns>, CollectReferencesErrors<NormalizeColumnPath<Relationship['columns'], Schema['schemaName'], CurrentTableName>, NormalizeColumnPath<Relationship['references'], Schema['schemaName'], CurrentTableName>, Schema['schemaName'], CurrentTableName, Schemas> extends infer Results extends readonly AnyTypeValidationError[] ? IF<AnyTypeValidationFailed<Results>, TypeValidationError<UnwrapTypeValidationErrors<Results>>, TypeValidationSuccess> : TypeValidationSuccess]> extends infer Error extends AnyTypeValidationError ? TypeValidationError<{
+  relationship: RelationshipName;
+  errors: Error extends TypeValidationError<infer E> ? E extends readonly unknown[] ? E : [E] : never;
+}> : TypeValidationSuccess;
+type CollectRelationshipErrors<Columns extends TableColumns = TableColumns, Relationships extends TableRelationships<keyof Columns & string> = {} & TableRelationships<keyof Columns & string>, Table extends AnyTableSchemaComponent = AnyTableSchemaComponent, Schema extends AnyDatabaseSchemaSchemaComponent = SchemaTablesWithSingle<Table>, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>, Errors extends AnyTypeValidationError[] = []> = MapRecordCollectErrors<Relationships, { [R in keyof Relationships]: ValidateRelationship<Columns, Relationships[R] extends AnyTableRelationshipDefinitionWithColumns<Extract<keyof Columns, string>> ? Relationships[R] : never, Extract<R, string>, Table['tableName'], Table, Schema, Schemas> }, Errors>;
+type ValidateTableRelationships<Table extends AnyTableSchemaComponent, Schema extends AnyDatabaseSchemaSchemaComponent = SchemaTablesWithSingle<Table>, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>> = Table extends TableSchemaComponent<infer Columns, infer TableName, infer Relationships> ? keyof Relationships extends Extract<keyof Relationships, string> ? CollectRelationshipErrors<Columns, Relationships, Table, Schema, Schemas> extends infer Results ? AnyTypeValidationFailed<Results> extends true ? TypeValidationError<{
+  table: TableName;
+  errors: UnwrapTypeValidationErrors<Results extends readonly AnyTypeValidationError[] ? Results : never>;
+}> : Results : TypeValidationSuccess : TypeValidationSuccess : TypeValidationSuccess;
+type ValidateTable<Table extends AnyTableSchemaComponent, Schema extends AnyDatabaseSchemaSchemaComponent = SchemaTablesWithSingle<Table>, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>> = ValidateTableRelationships<Table, Schema, Schemas>;
+type ValidateSchemaTables<Tables extends Record<string, AnyTableSchemaComponent>, SchemaName extends string, Schema extends AnyDatabaseSchemaSchemaComponent, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>> = MapRecordCollectErrors<Tables, { [TableName in keyof Tables]: ValidateTable<Tables[TableName], Schema, Schemas> }> extends infer Results ? AnyTypeValidationFailed<Results> extends true ? TypeValidationError<{
+  schema: SchemaName;
+  errors: UnwrapTypeValidationErrors<Results extends readonly AnyTypeValidationError[] ? Results : never>;
+}> : TypeValidationSuccess : TypeValidationSuccess;
+type ValidateDatabaseSchema<Schema extends AnyDatabaseSchemaSchemaComponent, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>> = Schema extends DatabaseSchemaSchemaComponent<infer Tables, infer SchemaName> ? ValidateSchemaTables<Tables, SchemaName, Schema, Schemas> : TypeValidationSuccess;
+type ValidateDatabaseSchemas<Schemas extends DatabaseSchemas> = MapRecordCollectErrors<Schemas, { [SchemaName in keyof Schemas]: ValidateDatabaseSchema<Schemas[SchemaName], Schemas> }> 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>>;
+//#endregion
+//#region src/core/schema/components/index.d.ts
+declare const schemaComponentURN: {
+  readonly database: ({
+    name
+  }: {
+    name: string;
+  }) => DatabaseURN;
+  readonly schema: <SchemaName extends string = string>({
+    name
+  }: {
+    name: SchemaName;
+  }) => DatabaseSchemaURN<SchemaName>;
+  readonly table: ({
+    name
+  }: {
+    name: string;
+  }) => TableURN;
+  readonly column: <ColumnName extends string = string>({
+    name
+  }: {
+    name: ColumnName;
+  }) => ColumnURN<ColumnName>;
+  readonly index: ({
+    name
+  }: {
+    name: string;
+  }) => IndexURN;
+  readonly extractName: (urn: string) => string;
+};
+//#endregion
+//#region src/core/errors/index.d.ts
+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);
+}
+//#endregion
+//#region src/core/query/query.d.ts
+interface QueryResultRow {
+  [column: string]: any;
+}
+type QueryResult<Result extends QueryResultRow = QueryResultRow> = {
+  rowCount: number | null;
+  rows: Result[];
+};
+//#endregion
+//#region src/core/query/mappers.d.ts
+declare const mapRows: <Result extends QueryResultRow = QueryResultRow, Mapped = unknown>(getResult: Promise<QueryResult<Result>>, map: (row: Result) => Mapped) => Promise<Mapped[]>;
+declare const toCamelCase: (snakeStr: string) => string;
+declare const mapToCamelCase: <T extends Record<string, unknown>>(obj: Record<string, unknown>) => T;
+//#endregion
+//#region src/core/query/selectors.d.ts
+declare const firstOrNull: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result | null>;
+declare const first: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result>;
+declare const singleOrNull: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result | null>;
+declare const single: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result>;
+type CountSQLQueryResult = {
+  count: number;
+};
+declare const count: (getResult: Promise<QueryResult<CountSQLQueryResult>>) => Promise<number>;
+type ExistsSQLQueryResult = {
+  exists: boolean | 1 | 0;
+};
+declare const exists: (getResult: Promise<QueryResult<ExistsSQLQueryResult>>) => Promise<boolean>;
+//#endregion
+//#region src/core/execute/execute.d.ts
+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 {
+  static readonly ErrorCode: number;
+  static readonly ErrorType: string;
+  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>;
+//#endregion
+//#region src/core/schema/databaseMetadata/databaseMetadata.d.ts
+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>;
+//#endregion
+//#region src/core/locks/databaseLock.d.ts
+type DatabaseLockOptions = {
+  lockId: number;
+  timeoutMs?: number;
+};
+type AcquireDatabaseLockMode = 'Permanent' | 'Session';
+type AcquireDatabaseLockOptions = DatabaseLockOptions & {
+  mode?: AcquireDatabaseLockMode;
+};
+type ReleaseDatabaseLockOptions = DatabaseLockOptions;
+declare const defaultDatabaseLockOptions: Required<Omit<DatabaseLockOptions, 'lockId'>>;
+type DatabaseLock = {
+  acquire(execute: SQLExecutor, options: AcquireDatabaseLockOptions): Promise<void>;
+  tryAcquire(execute: SQLExecutor, options: AcquireDatabaseLockOptions): Promise<boolean>;
+  release(execute: SQLExecutor, options: ReleaseDatabaseLockOptions): Promise<boolean>;
+  withAcquire: <Result = unknown>(execute: SQLExecutor, handle: () => Promise<Result>, options: AcquireDatabaseLockOptions) => Promise<Result>;
+};
+declare const NoDatabaseLock: DatabaseLock;
+//#endregion
+//#region src/core/schema/migrators/migrator.d.ts
+declare const MIGRATIONS_LOCK_ID = 999956789;
+declare global {
+  var defaultMigratorOptions: Record<DatabaseType, MigratorOptions>;
+}
+declare const registerDefaultMigratorOptions: (databaseType: DatabaseType, options: MigratorOptions) => void;
+declare const getDefaultMigratorOptionsFromRegistry: (databaseType: DatabaseType) => MigratorOptions;
+type MigratorOptions = {
+  schema?: {
+    migrationTable?: SchemaComponent;
+  };
+  lock?: {
+    databaseLock?: DatabaseLock;
+    options?: Omit<DatabaseLockOptions, 'lockId'> & Partial<Pick<DatabaseLockOptions, 'lockId'>>;
+  };
+  dryRun?: boolean | undefined;
+  ignoreMigrationHashMismatch?: boolean | undefined;
+  migrationTimeoutMs?: number | undefined;
+};
+type RunSQLMigrationsResult = {
+  applied: SQLMigration[];
+  skipped: SQLMigration[];
+};
+declare const runSQLMigrations: (pool: Dumbo, migrations: ReadonlyArray<SQLMigration>, partialOptions?: Partial<MigratorOptions>) => Promise<RunSQLMigrationsResult>;
+declare const combineMigrations: (...migration: Pick<SQLMigration, "sqls">[]) => SQL[];
+//#endregion
+//#region src/core/schema/migrators/schemaComponentMigrator.d.ts
+declare const migrationTableSchemaComponent: {
+  schemaComponentKey: "dumbo:schema-component:migrations-table";
+  components: ReadonlyMap<string, SchemaComponent>;
+  migrations: ReadonlyArray<SQLMigration>;
+  addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
+  addMigration: (migration: SQLMigration) => void;
+};
+type SchemaComponentMigrator = {
+  component: SchemaComponent;
+  run: (options?: Partial<MigratorOptions>) => Promise<void>;
+};
+declare const SchemaComponentMigrator: <DriverType extends DatabaseDriverType>(component: SchemaComponent, dumbo: Dumbo<DriverType>) => SchemaComponentMigrator;
+//#endregion
+//#region src/core/drivers/databaseDriver.d.ts
+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;
+  readonly databaseMetadata: DatabaseMetadata;
+  createPool(options: DumboConnectionOptions<this>): DumboType;
+  canHandle(options: DumboConnectionOptions<this>): boolean;
+}
+type AnyDumboDatabaseDriver = DumboDatabaseDriver<AnyConnection, any>;
+type ExtractDumboDatabaseDriverOptions<DatabaseDriver> = DatabaseDriver extends DumboDatabaseDriver<any, infer O, any> ? O : never;
+type ExtractDumboTypeFromDriver<DatabaseDriver> = DatabaseDriver extends DumboDatabaseDriver<any, any, infer D> ? D : never;
+declare const canHandleDriverWithConnectionString: <DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<DatabaseDriver> = DumboConnectionOptions<DatabaseDriver>>(driver: DatabaseDriver["driverType"], tryParseConnectionString: (connectionString: string) => string | null) => (options: ConnectionOptions) => boolean;
+declare const DumboDatabaseDriverRegistry: () => {
+  register: <Driver extends AnyDumboDatabaseDriver>(driverType: Driver["driverType"], plugin: Driver | (() => Promise<Driver>)) => void;
+  tryResolve: <Driver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<Driver> = DumboConnectionOptions<Driver>>(options: ConnectionOptions) => Promise<Driver | null>;
+  tryGet: <Driver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<Driver> = DumboConnectionOptions<Driver>>(options: ConnectionOptions) => Driver | null;
+  has: (driverType: DatabaseDriverType) => boolean;
+  readonly databaseDriverTypes: DatabaseDriverType[];
+};
+declare global {
+  var dumboDatabaseDriverRegistry: ReturnType<typeof DumboDatabaseDriverRegistry>;
+}
+declare const dumboDatabaseDriverRegistry: {
+  register: <Driver extends AnyDumboDatabaseDriver>(driverType: Driver["driverType"], plugin: Driver | (() => Promise<Driver>)) => void;
+  tryResolve: <Driver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<Driver> = DumboConnectionOptions<Driver>>(options: ConnectionOptions) => Promise<Driver | null>;
+  tryGet: <Driver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<Driver> = DumboConnectionOptions<Driver>>(options: ConnectionOptions) => Driver | null;
+  has: (driverType: DatabaseDriverType) => boolean;
+  readonly databaseDriverTypes: DatabaseDriverType[];
+};
+//#endregion
+//#region src/core/drivers/index.d.ts
+type DatabaseType = string;
+type DatabaseDriverName = string;
+type DatabaseDriverType<DatabaseTypeName extends DatabaseType = DatabaseType, DriverName extends DatabaseDriverName = DatabaseDriverName> = `${DatabaseTypeName}:${DriverName}`;
+type InferDriverDatabaseType<T extends string> = T extends `${infer DatabaseType}:${string}` ? DatabaseType : never;
+type DatabaseDriverTypeParts<T extends DatabaseType = DatabaseType> = {
+  databaseType: T;
+  driverName: string;
+};
+/**
+ * Accepts a `databaseType` (e.g. PostgreSQL, SQLite) and a `driverName`
+ * (the library name, e.g. pg, sqlite3) and combines them to a singular
+ * `databaseDriverType` which can be used in database handling.
+ */
+declare function toDatabaseDriverType<T extends DatabaseType>(databaseType: T, driverName: string): DatabaseDriverType<T>;
+/**
+ * Accepts a fully formatted `driverType` and returns the broken down
+ * `databaseType` and `driverName`.
+ */
+declare function fromDatabaseDriverType<T extends DatabaseType>(databaseDriverType: DatabaseDriverType<T>): DatabaseDriverTypeParts<T>;
+/**
+ * Accepts a fully formatted `databaseDriverType` and returns the `driverName`.
+ */
+declare function getDatabaseDriverName<T extends DatabaseType>(databaseDriverType: DatabaseDriverType<T>): DatabaseDriverName;
+/**
+ * Accepts a fully formatted `databaseDriverType` and returns the `databaseType`.
+ */
+declare function getDatabaseType<T extends DatabaseType>(databaseDriverType: DatabaseDriverType<T>): DatabaseType;
+//#endregion
+//#region src/core/connections/transaction.d.ts
+interface DatabaseTransaction<ConnectionType extends AnyConnection = AnyConnection, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> extends WithSQLExecutor {
+  driverType: ConnectionType['driverType'];
+  connection: ConnectionType;
+  begin: () => Promise<void>;
+  commit: () => Promise<void>;
+  rollback: (error?: unknown) => Promise<void>;
+  _transactionOptions: TransactionOptionsType;
+}
+type AnyDatabaseTransaction = DatabaseTransaction<any, any>;
+type DatabaseTransactionOptions = {
+  allowNestedTransactions?: boolean;
+  readonly?: boolean;
+};
+type InferTransactionOptionsFromTransaction<C extends AnyDatabaseTransaction> = C extends DatabaseTransaction<any, infer TO> ? TO : never;
+interface WithDatabaseTransactionFactory<ConnectionType extends AnyConnection = AnyConnection> {
+  transaction: (options?: InferTransactionOptionsFromConnection<ConnectionType>) => InferTransactionFromConnection<ConnectionType>;
+  withTransaction: <Result = never>(handle: (transaction: InferTransactionFromConnection<ConnectionType>) => Promise<TransactionResult<Result> | Result>, options?: InferTransactionOptionsFromConnection<ConnectionType>) => Promise<Result>;
+}
+type TransactionResult<Result> = {
+  success: boolean;
+  result: Result;
+};
+declare const executeInTransaction: <DatabaseTransactionType extends AnyDatabaseTransaction = AnyDatabaseTransaction, Result = void>(transaction: DatabaseTransactionType, handle: (transaction: DatabaseTransactionType) => Promise<TransactionResult<Result> | Result>) => Promise<Result>;
+declare const transactionFactoryWithDbClient: <ConnectionType extends AnyConnection = AnyConnection>(connect: () => Promise<InferDbClientFromConnection<ConnectionType>>, initTransaction: (client: Promise<InferDbClientFromConnection<ConnectionType>>, options?: InferTransactionOptionsFromConnection<ConnectionType> & {
+  close: (client: InferDbClientFromConnection<ConnectionType>, error?: unknown) => Promise<void>;
+}) => InferTransactionFromConnection<ConnectionType>) => WithDatabaseTransactionFactory<ConnectionType>;
+declare const transactionFactoryWithNewConnection: <ConnectionType extends AnyConnection = AnyConnection>(connect: () => ConnectionType) => WithDatabaseTransactionFactory<ConnectionType>;
+declare const transactionFactoryWithAmbientConnection: <ConnectionType extends AnyConnection = AnyConnection>(connect: () => ConnectionType) => WithDatabaseTransactionFactory<ConnectionType>;
+declare const transactionFactoryWithAsyncAmbientConnection: <ConnectionType extends AnyConnection = AnyConnection>(driverType: ConnectionType["driverType"], connect: () => Promise<ConnectionType>, close?: (connection: ConnectionType) => void | Promise<void>) => WithDatabaseTransactionFactory<ConnectionType>;
+//#endregion
+//#region src/core/connections/connection.d.ts
+interface Connection<Self extends AnyConnection = AnyConnection, DriverType extends DatabaseDriverType = DatabaseDriverType, DbClient = unknown, TransactionType extends DatabaseTransaction<Self, any> = DatabaseTransaction<Self, any>> extends WithSQLExecutor, WithDatabaseTransactionFactory<Self> {
+  driverType: DriverType;
+  open: () => Promise<DbClient>;
+  close: () => Promise<void>;
+  _transactionType: TransactionType;
+}
+type AnyConnection = Connection<AnyConnection, DatabaseDriverType, unknown, AnyDatabaseTransaction>;
+type InferDriverTypeFromConnection<C extends AnyConnection> = C extends Connection<any, infer DT, any, any> ? DT : never;
+type InferDbClientFromConnection<C extends AnyConnection> = C extends Connection<any, any, infer DC, any> ? DC : never;
+type InferTransactionFromConnection<C extends AnyConnection> = C extends Connection<any, any, any, infer DT> ? DT : never;
+type InferTransactionOptionsFromConnection<C extends AnyConnection> = InferTransactionOptionsFromTransaction<InferTransactionFromConnection<C>>;
+type ConnectionOptions<ConnectionType extends AnyConnection = AnyConnection> = {
+  driverType?: ConnectionType['driverType'];
+  transactionOptions?: InferTransactionOptionsFromConnection<ConnectionType>;
+};
+type ConnectionFactory<ConnectionType extends AnyConnection = AnyConnection> = (options: ConnectionOptions<ConnectionType>) => ConnectionType;
+type WithConnectionOptions = {
+  readonly?: boolean;
+};
+interface WithConnectionFactory<ConnectionType extends AnyConnection = AnyConnection> {
+  connection: (options?: WithConnectionOptions) => Promise<ConnectionType>;
+  withConnection: <Result = unknown>(handle: (connection: ConnectionType) => Promise<Result>, options?: WithConnectionOptions) => Promise<Result>;
+}
+type InitTransaction<ConnectionType extends AnyConnection = AnyConnection> = (connection: () => ConnectionType) => (client: Promise<InferDbClientFromConnection<ConnectionType>>, options?: InferTransactionOptionsFromConnection<ConnectionType> & {
+  close: (client: InferDbClientFromConnection<ConnectionType>, error?: unknown) => Promise<void>;
+}) => InferTransactionFromConnection<ConnectionType>;
+type CreateConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor> = {
+  driverType: InferDriverTypeFromConnection<ConnectionType>;
+  connect: () => Promise<InferDbClientFromConnection<ConnectionType>>;
+  close: (client: InferDbClientFromConnection<ConnectionType>) => Promise<void>;
+  initTransaction: InitTransaction<ConnectionType>;
+  serializer: JSONSerializer;
+  executor: (options: DbSQLExecutorOptions) => Executor;
+};
+type CreateAmbientConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor> = {
+  driverType: InferDriverTypeFromConnection<ConnectionType>;
+  client: InferDbClientFromConnection<ConnectionType>;
+  serializer: JSONSerializer;
+  initTransaction: InitTransaction<ConnectionType>;
+  executor: (options: DbSQLExecutorOptions) => Executor;
+};
+declare const createAmbientConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor>(options: CreateAmbientConnectionOptions<ConnectionType, Executor>) => ConnectionType;
+type CreateSingletonConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor> = {
+  driverType: InferDriverTypeFromConnection<ConnectionType>;
+  connect: () => Promise<InferDbClientFromConnection<ConnectionType>>;
+  close: (client: InferDbClientFromConnection<ConnectionType>) => Promise<void>;
+  initTransaction: InitTransaction<ConnectionType>;
+  serializer: JSONSerializer;
+  executor: (options: DbSQLExecutorOptions) => Executor;
+};
+declare const createSingletonConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor>(options: CreateSingletonConnectionOptions<ConnectionType, Executor>) => ConnectionType;
+type CreateTransientConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor> = {
+  driverType: InferDriverTypeFromConnection<ConnectionType>;
+  open: () => Promise<InferDbClientFromConnection<ConnectionType>>;
+  close: () => Promise<void>;
+  initTransaction: InitTransaction<ConnectionType>;
+  serializer: JSONSerializer;
+  executor: (options: DbSQLExecutorOptions) => Executor;
+};
+declare const createTransientConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor>(options: CreateTransientConnectionOptions<ConnectionType, Executor>) => ConnectionType;
+declare const createConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor>(options: CreateConnectionOptions<ConnectionType, Executor>) => ConnectionType;
+//#endregion
+//#region src/core/connections/pool.d.ts
+interface ConnectionPool<ConnectionType extends AnyConnection = AnyConnection> extends WithSQLExecutor, WithConnectionFactory<ConnectionType>, WithDatabaseTransactionFactory<ConnectionType> {
+  driverType: ConnectionType['driverType'];
+  close: () => Promise<void>;
+}
+type ConnectionPoolFactory<ConnectionPoolType extends ConnectionPool = ConnectionPool, ConnectionPoolOptions = unknown> = (options: ConnectionPoolOptions) => ConnectionPoolType;
+type AmbientConnectionPoolOptions<ConnectionType extends AnyConnection> = {
+  driverType: ConnectionType['driverType'];
+  connection: ConnectionType;
+};
+declare const createAmbientConnectionPool: <ConnectionType extends AnyConnection>(options: AmbientConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
+type SingletonConnectionPoolOptions<ConnectionType extends AnyConnection> = {
+  driverType: ConnectionType['driverType'];
+  getConnection: () => ConnectionType | Promise<ConnectionType>;
+  closeConnection?: (connection: ConnectionType) => void | Promise<void>;
+  connectionOptions?: never;
+};
+declare const createSingletonConnectionPool: <ConnectionType extends AnyConnection>(options: SingletonConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
+type CreateBoundedConnectionPoolOptions<ConnectionType extends AnyConnection> = {
+  driverType: ConnectionType['driverType'];
+  getConnection: () => ConnectionType | Promise<ConnectionType>;
+  maxConnections: number;
+};
+declare const createBoundedConnectionPool: <ConnectionType extends AnyConnection>(options: CreateBoundedConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
+type SingletonClientConnectionPoolOptions<ConnectionType extends AnyConnection> = {
+  driverType: ConnectionType['driverType'];
+  dbClient: InferDbClientFromConnection<ConnectionType>;
+  connectionFactory: (options: {
+    dbClient: InferDbClientFromConnection<ConnectionType>;
+  }) => ConnectionType;
+};
+declare const 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;
+  connectionOptions?: never;
+} : {
+  driverType: ConnectionType['driverType'];
+  getConnection: (options: ConnectionOptions) => ConnectionType;
+  connectionOptions: ConnectionOptions;
+};
+declare const createAlwaysNewConnectionPool: <ConnectionType extends AnyConnection, ConnectionOptions extends Record<string, unknown> | undefined = undefined>(options: CreateAlwaysNewConnectionPoolOptions<ConnectionType, ConnectionOptions>) => ConnectionPool<ConnectionType>;
+type CreateConnectionPoolOptions<ConnectionType extends AnyConnection> = Pick<ConnectionPool<ConnectionType>, 'driverType'> & Partial<ConnectionPool<ConnectionType>> & {
+  getConnection: () => ConnectionType;
+};
+declare const createConnectionPool: <ConnectionType extends AnyConnection>(pool: CreateConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
+//#endregion
+//#region src/core/testing/typesTesting.d.ts
+type Expect<T extends true> = T;
+type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+type IsError<T> = T extends AnyTypeValidationError ? true : false;
+type IsOK<T> = T extends TypeValidationSuccess ? true : false;
+//#endregion
+//#region src/core/tracing/printing/color.d.ts
+declare const color: {
+  level: 0 | 1;
+  hex: (value: string) => (text: string) => string;
+  red: (value: string) => string;
+  green: (value: string) => string;
+  blue: (value: string) => string;
+  cyan: (value: string) => string;
+  yellow: (value: string) => string;
+};
+//#endregion
+//#region src/core/tracing/printing/pretty.d.ts
+declare const prettyJson: (obj: unknown, options?: {
+  handleMultiline?: boolean;
+}) => string;
+//#endregion
+//#region src/core/tracing/index.d.ts
+declare const tracer: {
+  (): void;
+  info(eventName: string, attributes?: Record<string, any>): void;
+  warn(eventName: string, attributes?: Record<string, any>): void;
+  log(eventName: string, attributes?: Record<string, any>): void;
+  error(eventName: string, attributes?: Record<string, any>): void;
+};
+type LogLevel = 'DISABLED' | 'INFO' | 'LOG' | 'WARN' | 'ERROR';
+declare const LogLevel: {
+  DISABLED: LogLevel;
+  INFO: LogLevel;
+  LOG: LogLevel;
+  WARN: LogLevel;
+  ERROR: LogLevel;
+};
+type LogType = 'CONSOLE';
+type LogStyle = 'RAW' | 'PRETTY';
+declare const LogStyle: {
+  RAW: LogStyle;
+  PRETTY: LogStyle;
+};
+//#endregion
+//#region src/core/index.d.ts
+type Dumbo<DriverType extends DatabaseDriverType = DatabaseDriverType, ConnectionType extends AnyConnection = AnyConnection> = ConnectionPool<ConnectionType>;
+type DumboConnectionOptions<DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver> = ExtractDumboDatabaseDriverOptions<DatabaseDriver> extends infer Options ? Options extends unknown ? {
+  driver?: DatabaseDriver;
+  driverType?: DatabaseDriver['driverType'];
+} & Omit<Options, 'driver' | 'driverType' | 'connectionString'> : never : never;
+//#endregion
+//#region src/storage/all/connections/connectionString.d.ts
+type DatabaseConnectionString<DatabaseTypeName extends DatabaseType = DatabaseType, Format extends string = string> = Format & {
+  _databaseType: DatabaseTypeName;
+};
+declare const parseConnectionString: (connectionString: DatabaseConnectionString | string) => DatabaseDriverTypeParts;
+//#endregion
+//#region src/storage/all/index.d.ts
+declare function dumbo<Driver extends AnyDumboDatabaseDriver>(options: ExtractDumboDatabaseDriverOptions<Driver> & {
+  driver: Driver;
+} & JSONSerializationOptions): ExtractDumboTypeFromDriver<Driver>;
+declare function dumbo<DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<DatabaseDriver> = DumboConnectionOptions<DatabaseDriver>>(options: ConnectionOptions & {
+  driver?: never;
+}): ExtractDumboTypeFromDriver<DatabaseDriver>;
+//#endregion
+export { ANSISQLIdentifierQuote, ANSISQLParamPlaceholder, AcquireDatabaseLockMode, AcquireDatabaseLockOptions, AdminShutdownError, AllColumnReferences, AllColumnReferencesInSchema, AllColumnTypes, AllColumnTypesInSchema, AmbientConnectionPoolOptions, AnyColumnSchemaComponent, AnyColumnTypeToken, AnyConnection, AnyDatabaseSchemaComponent, AnyDatabaseSchemaSchemaComponent, AnyDatabaseTransaction, AnyDumboDatabaseDriver, AnyRelationshipDefinition, AnySQLProcessor, AnySQLToken, AnySchemaComponent, AnySchemaComponentOfType, AnyTableRelationshipDefinition, AnyTableRelationshipDefinitionWithColumns, AnyTableSchemaComponent, AutoIncrementSQLColumnToken, BatchCommandNoChangesError, BatchSQLCommandOptions, BigIntegerToken, BigSerialToken, CheckViolationError, CollectReferencesErrors, CollectRelationshipErrors, ColumnName$1 as ColumnName, ColumnPath, ColumnPathToReference, ColumnReference, ColumnReferenceError, ColumnReferenceExistanceError, ColumnReferenceTypeMismatchError, ColumnSchemaComponent, ColumnSchemaComponentOptions, ColumnTypeToken, ColumnURN, ColumnURNType, ConcurrencyError, Connection, ConnectionError, ConnectionFactory, ConnectionOptions, ConnectionPool, ConnectionPoolFactory, CountSQLQueryResult, CreateAlwaysNewConnectionPoolOptions, CreateAmbientConnectionOptions, CreateBoundedConnectionPoolOptions, CreateConnectionOptions, CreateConnectionPoolOptions, CreateSingletonConnectionOptions, CreateTransientConnectionOptions, DataError, DatabaseCapabilities, DatabaseConnectionString, DatabaseDriverName, DatabaseDriverType, DatabaseDriverTypeParts, DatabaseLock, DatabaseLockOptions, DatabaseMetadata, DatabaseSchemaComponent, DatabaseSchemaSchemaComponent, DatabaseSchemaTables, DatabaseSchemaURN, DatabaseSchemaURNType, DatabaseSchemas, DatabaseSchemasWithSingle, DatabaseTransaction, DatabaseTransactionOptions, DatabaseType, DatabaseURN, DatabaseURNType, DbClientSetup, DbSQLExecutor, DbSQLExecutorOptions, DeadlockError, DefaultMapSQLParamValueOptions, DefaultSQLColumnProcessors, DefaultSQLColumnToken, Dumbo, DumboConnectionOptions, DumboDatabaseDriver, DumboDatabaseDriverRegistry, DumboDatabaseMetadataRegistry, DumboError, DumboSchemaComponentType, Equals, ExclusionViolationError, ExistsSQLQueryResult, ExpandArrayProcessor, ExpandSQLInProcessor, Expect, ExtractAdditionalData, ExtractColumnNames, ExtractColumnTypeName, ExtractDumboDatabaseDriverOptions, ExtractDumboTypeFromDriver, ExtractSQLTokenType, ExtractSchemaNames, ExtractTableNames, ForeignKeyViolationError, FormatContext, FormatDatabaseValidationErrors, FormatIdentifierProcessor, FormatRelationshipBlock, FormatSQLOptions, FormatSchemaLevel, FormatSingleError, FormatTableLevel, FormatValidationErrors, IndentErrors, IndexSchemaComponent, IndexURN, IndexURNType, InferColumnType, InferDatabaseSchemas, InferDbClientFromConnection, InferDriverDatabaseType, InferDriverTypeFromConnection, InferSchemaTables, InferTableRow, InferTableSchemaComponentColumns, InferTableSchemaComponentTypes, InferTransactionFromConnection, InferTransactionOptionsFromConnection, InferTransactionOptionsFromTransaction, InitTransaction, InsufficientResourcesError, IntegerToken, IntegrityConstraintViolationError, InvalidOperationError, IsError, IsOK, JSONBToken, JSONCodec, type JSONCodecOptions, type JSONDeserializeOptions, JSONParam, JSONReplacer, JSONReplacers, JSONReviver, JSONReviverContext, JSONRevivers, type JSONSerializationOptions, type JSONSerializeOptions, JSONSerializer, type JSONSerializerOptions, JSONValueType, JSONValueTypeName, JavaScriptValueType, JavaScriptValueTypeName, JavaScriptValueTypeToNameMap, Join, LockNotAvailableError, LogLevel, LogStyle, LogType, LookupColumnType, MIGRATIONS_LOCK_ID, MapLiteralProcessor, MapSQLParamValue, MapSQLParamValueOptions, MigrationRecord, MigrationStyle, MigratorOptions, NoDatabaseLock, NoError, NormalizeColumnPath, NormalizeReference, NotNullViolationError, NotNullableSQLColumnTokenProps, NullableSQLColumnTokenProps, ParametrizedSQL, ParametrizedSQLBuilder, ParseReferencePath, QueryCanceledError, QueryResult, QueryResultRow, RawSQL, RelationshipColumnsMismatchError, RelationshipDefinition, RelationshipReferencesLengthMismatchError, RelationshipType, RelationshipValidationError, ReleaseDatabaseLockOptions, RunSQLMigrationsResult, SQL, SQLArray, SQLArrayMode, SQLColumnToken, SQLColumnTypeTokens, SQLColumnTypeTokensFactory, SQLCommandOptions, SQLDefaultTokens, SQLDefaultTokensTypes, SQLExecutor, SQLFormatter, SQLFormatterOptions, SQLIdentifier, SQLIn, SQLLiteral, SQLMigration, SQLPlain, SQLProcessor, SQLProcessorContext, SQLProcessorOptions, SQLProcessorsReadonlyRegistry, SQLProcessorsRegistry, SQLQueryOptions, SQLQueryResultColumnMapping, SQLTag, SQLToken, SQLValueMapper, SchemaColumnName, SchemaComponent, SchemaComponentMigrator, SchemaComponentOptions, SchemaComponentType, SchemaTablesWithSingle, SerialToken, SerializationCodec, SerializationError, Serializer, SingletonClientConnectionPoolOptions, SingletonConnectionPoolOptions, SystemError, TableColumnName, TableColumnNames, TableColumnType, TableColumns, TableRelationships, TableRowType, TableSchemaComponent, TableURN, TableURNType, TimestampToken, TimestamptzToken, TokenizedSQL, TransactionResult, TransientDatabaseError, UniqueConstraintError, ValidateColumnReference, ValidateColumnTypeMatch, ValidateColumnsMatch, ValidateDatabaseSchema, ValidateDatabaseSchemas, ValidateDatabaseSchemasWithMessages, ValidateReference, ValidateReferences, ValidateRelationship, ValidateRelationshipColumns, ValidateRelationshipLength, ValidateSchemaTables, ValidateTable, ValidateTableRelationships, VarcharToken, WithConnectionFactory, WithConnectionOptions, WithDatabaseTransactionFactory, WithSQLExecutor, Writable, ansiSqlReservedMap, canHandleDriverWithConnectionString, color, columnSchemaComponent, combineMigrations, composeJSONReplacers, composeJSONRevivers, count, createAlwaysNewConnectionPool, createAmbientConnection, createAmbientConnectionPool, createBoundedConnectionPool, createConnection, createConnectionPool, createSingletonClientConnectionPool, createSingletonConnection, createSingletonConnectionPool, createTransientConnection, databaseSchemaComponent, databaseSchemaSchemaComponent, defaultDatabaseLockOptions, defaultProcessorsRegistry, describeSQL, dumbo, dumboDatabaseDriverRegistry, dumboDatabaseMetadataRegistry, dumboSchema, executeInAmbientConnection, executeInNewConnection, executeInNewDbClient, executeInTransaction, exists, filterSchemaComponentsOfType, findSchemaComponentsOfType, first, firstOrNull, formatSQL, fromDatabaseDriverType, getDatabaseDriverName, getDatabaseMetadata, getDatabaseType, getDefaultDatabase, getDefaultDatabaseAsync, getDefaultMigratorOptionsFromRegistry, getFormatter, indexSchemaComponent, isSQL, isSchemaComponentOfType, isTokenizedSQL, jsonSerializer, mapANSISQLParamPlaceholder, mapColumnToBigint, mapColumnToDate, mapColumnToJSON, mapDefaultSQLColumnProcessors, mapRows, mapSQLIdentifier, mapSQLParamValue, mapSQLQueryResult, mapSchemaComponentsOfType, mapToCamelCase, migrationTableSchemaComponent, parseConnectionString, prettyJson, registerDefaultMigratorOptions, registerFormatter, relationship, resolveDatabaseMetadata, runSQLMigrations, schemaComponent, schemaComponentURN, single, singleOrNull, sqlExecutor, sqlExecutorInAmbientConnection, sqlExecutorInNewConnection, sqlMigration, tableSchemaComponent, toCamelCase, toDatabaseDriverType, tracer, transactionFactoryWithAmbientConnection, transactionFactoryWithAsyncAmbientConnection, transactionFactoryWithDbClient, transactionFactoryWithNewConnection };
+//# sourceMappingURL=index.d.ts.map