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

package/dist/sqlite.d.ts

@@ -1,3 +1,1107 @@
-import { n as sqliteMetadata } from "./index-QWEAqtHF.js";
-import { $ as SQLiteConnectionString, A as SQLiteClientConnection, B as SQLiteError, C as AnySQLiteClientConnection, D as DEFAULT_SQLITE_PRAGMA_OPTIONS, E as BatchSQLiteCommandOptions, F as SQLiteCommandOptions, G as SqliteAmbientClientConnectionOptions, H as SQLitePoolClient, I as SQLiteConnection, J as sqliteAmbientClientConnection, K as TransactionNestingCounter, L as SQLiteConnectionDefinitionOptions, M as SQLiteClientFactory, N as SQLiteClientOptions, O as InMemorySQLiteDatabase, P as SQLiteClientOrPoolClient, Q as transactionNestingCounter, R as SQLiteConnectionFactory, S as mapSqliteError, T as AnySQLitePoolClientConnection, U as SQLitePoolClientConnection, V as SQLiteParameters, W as SQLitePoolConnectionDefinitionOptions, X as sqliteConnection, Y as sqliteClientConnection, Z as sqlitePoolClientConnection, _ as sqliteAlwaysNewConnectionPool, a as sqliteFormatter, at as sqliteTransaction, b as sqliteSingletonConnectionPool, c as DefaultSQLiteMigratorOptions, ct as sqliteExecute, d as SQLiteFileNameOrConnectionString, et as SQLitePragmaOptions, f as SQLitePool, g as isInMemoryDatabase, h as SQLiteSingletonConnectionPool, i as SQLiteJSON, it as SQLiteTransactionOptions, j as SQLiteClientConnectionDefinitionOptions, k as SQLiteClient, l as SQLiteAlwaysNewConnectionPool, lt as sqliteSQLExecutor, m as SQLitePoolOptions, n as SQLiteDatabaseType, nt as SQLiteTransaction, o as defaultSQLiteDatabase, ot as SQLiteErrorMapper, p as SQLitePoolFactoryOptions, q as isSQLiteError, r as SQLiteDriverType, rt as SQLiteTransactionMode, s as tableExists, st as SQLiteSQLExecutor, t as SQLiteDatabaseName, tt as parsePragmasFromConnectionString, u as SQLiteAmbientConnectionPool, v as sqliteAmbientConnectionPool, w as AnySQLiteConnection, x as toSqlitePoolOptions, y as sqlitePool, z as SQLiteConnectionOptions } from "./index-BJC_v03L.js";
-export { AnySQLiteClientConnection, AnySQLiteConnection, AnySQLitePoolClientConnection, BatchSQLiteCommandOptions, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLiteAlwaysNewConnectionPool, SQLiteAmbientConnectionPool, SQLiteClient, SQLiteClientConnection, SQLiteClientConnectionDefinitionOptions, SQLiteClientFactory, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteCommandOptions, SQLiteConnection, SQLiteConnectionDefinitionOptions, SQLiteConnectionFactory, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDatabaseName, SQLiteDatabaseType, SQLiteDriverType, SQLiteError, SQLiteErrorMapper, SQLiteFileNameOrConnectionString, SQLiteJSON, SQLiteParameters, SQLitePool, SQLitePoolClient, SQLitePoolClientConnection, SQLitePoolConnectionDefinitionOptions, SQLitePoolFactoryOptions, SQLitePoolOptions, SQLitePragmaOptions, SQLiteSQLExecutor, SQLiteSingletonConnectionPool, SQLiteTransaction, SQLiteTransactionMode, SQLiteTransactionOptions, SqliteAmbientClientConnectionOptions, TransactionNestingCounter, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapSqliteError, parsePragmasFromConnectionString, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, transactionNestingCounter };
+//#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;
+type JSONSerializationOptions<SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> = {
+  serialization?: {
+    serializer?: JSONSerializer<SerializeOptions, DeserializeOptions>;
+    options?: JSONSerializeOptions | JSONDeserializeOptions;
+  } | undefined;
+};
+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 JSONReplacer: (opts?: JSONSerializeOptions) => JSONReplacer | undefined;
+declare const JSONReviver: (opts?: JSONDeserializeOptions) => JSONReviver | undefined;
+declare const JSONSerializer: JSONSerializer & {
+  from: <SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions>(options?: JSONSerializationOptions<SerializeOptions, DeserializeOptions>) => JSONSerializer<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;
+}
+//#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 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 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";
+};
+//#endregion
+//#region src/core/sql/tokens/columnTokens.d.ts
+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 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;
+};
+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/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 SQLValueMapper: (options?: MapSQLParamValueOptions) => SQLValueMapper;
+//#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/index.d.ts
+declare global {
+  var defaultProcessorsRegistry: ReturnType<typeof SQLProcessorsRegistry>;
+}
+//#endregion
+//#region src/core/schema/sqlMigration.d.ts
+type SQLMigration = {
+  name: string;
+  sqls: SQL[];
+};
+//#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 SchemaComponentOptions<AdditionalOptions extends Record<string, unknown> = Record<string, unknown>> = {
+  migrations?: ReadonlyArray<SQLMigration>;
+  components?: ReadonlyArray<SchemaComponent>;
+} & Omit<AdditionalOptions, 'migrations' | 'components'>;
+//#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[];
+  };
+};
+//#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;
+  };
+};
+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>;
+}
+//#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;
+//#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;
+//#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 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 SchemaColumnName<SchemaName extends string = string, TableName extends string = string, ColumnName extends string = string> = `${SchemaName}.${TableName}.${ColumnName}`;
+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>>;
+//#endregion
+//#region src/core/schema/components/tableTypesInference.d.ts
+type TableColumnNames<T extends AnyTableSchemaComponent> = Exclude<keyof T['columns'], keyof ReadonlyMap<string, AnyColumnSchemaComponent>>;
+//#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 AnyTableSchemaComponent = TableSchemaComponent<any, any, any>;
+//#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>;
+//#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;
+}>>;
+//#endregion
+//#region src/core/schema/components/relationships/relationshipValidation.d.ts
+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 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 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;
+//#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;
+}
+//#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/execute/execute.d.ts
+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;
+};
+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;
+}
+//#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>;
+}
+//#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;
+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>;
+};
+//#endregion
+//#region src/core/schema/migrators/migrator.d.ts
+declare global {
+  var defaultMigratorOptions: Record<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;
+};
+//#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;
+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>;
+}
+//#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}`;
+//#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;
+};
+//#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 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>;
+//#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>;
+}
+//#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;
+};
+//#endregion
+//#region src/storage/sqlite/core/schema/sqliteMetadata.d.ts
+declare const sqliteMetadata: DatabaseMetadata<false, false, false>;
+//#endregion
+//#region src/storage/sqlite/core/execute/execute.d.ts
+type SQLiteErrorMapper = (error: unknown) => DumboError;
+declare const sqliteExecute: <Result = void>(database: SQLiteClient, handle: (client: SQLiteClient) => Promise<Result>) => Promise<Result>;
+type SQLiteSQLExecutor<DriverType extends SQLiteDriverType = SQLiteDriverType> = DbSQLExecutor<DriverType, SQLiteClient>;
+declare const sqliteSQLExecutor: <DriverType extends SQLiteDriverType = SQLiteDriverType>(driverType: DriverType, serializer: JSONSerializer, formatter?: SQLFormatter, errorMapper?: SQLiteErrorMapper) => SQLiteSQLExecutor<DriverType>;
+//#endregion
+//#region src/storage/sqlite/core/transactions/index.d.ts
+type SQLiteTransaction<ConnectionType extends AnySQLiteConnection = AnySQLiteConnection, TransactionOptions extends SQLiteTransactionOptions = SQLiteTransactionOptions> = DatabaseTransaction<ConnectionType, TransactionOptions>;
+type SQLiteTransactionMode = 'DEFERRED' | 'IMMEDIATE' | 'EXCLUSIVE';
+type SQLiteTransactionOptions = DatabaseTransactionOptions & {
+  mode?: SQLiteTransactionMode;
+  useSavepoints?: boolean;
+};
+declare const sqliteTransaction: <ConnectionType extends AnySQLiteConnection = AnySQLiteConnection>(driverType: ConnectionType["driverType"], connection: () => ConnectionType, allowNestedTransactions: boolean, serializer: JSONSerializer, defaultTransactionMode?: "IMMEDIATE" | "DEFERRED" | "EXCLUSIVE") => (getClient: Promise<InferDbClientFromConnection<ConnectionType>>, options?: {
+  close: (client: InferDbClientFromConnection<ConnectionType>, error?: unknown) => Promise<void>;
+} & SQLiteTransactionOptions) => InferTransactionFromConnection<ConnectionType>;
+//#endregion
+//#region src/storage/sqlite/core/connections/connectionString.d.ts
+type SQLitePragmaOptions = {
+  journal_mode?: 'DELETE' | 'TRUNCATE' | 'PERSIST' | 'MEMORY' | 'WAL' | 'OFF';
+  synchronous?: 'OFF' | 'NORMAL' | 'FULL' | 'EXTRA';
+  cache_size?: number;
+  foreign_keys?: boolean;
+  temp_store?: 'DEFAULT' | 'FILE' | 'MEMORY';
+  busy_timeout?: number;
+  mmap_size?: number;
+};
+type SQLiteConnectionString = DatabaseConnectionString<'SQLite', `file:${string}` | `:memory:` | `/${string}` | `./${string}`>;
+declare const SQLiteConnectionString: (connectionString: string) => SQLiteConnectionString;
+declare const parsePragmasFromConnectionString: (connectionString: string | SQLiteConnectionString) => Partial<SQLitePragmaOptions>;
+//#endregion
+//#region src/storage/sqlite/core/connections/index.d.ts
+type SQLiteCommandOptions = SQLCommandOptions & {
+  ignoreChangesCount?: boolean;
+};
+type BatchSQLiteCommandOptions = SQLiteCommandOptions & BatchSQLCommandOptions;
+type SQLiteParameters = object | string | bigint | number | boolean | null;
+type SQLiteClient = {
+  connect: () => Promise<void>;
+  close: () => Promise<void>;
+} & SQLExecutor;
+type SQLitePoolClient = {
+  release: () => void;
+} & SQLExecutor;
+type SQLiteClientFactory<SQLiteClientType extends SQLiteClient = SQLiteClient, ClientOptions = SQLiteClientOptions> = (options: ClientOptions) => SQLiteClientType;
+type SQLiteClientOrPoolClient = SQLitePoolClient | SQLiteClient;
+interface SQLiteError extends Error {
+  errno: number;
+}
+declare const isSQLiteError: (error: unknown) => error is SQLiteError;
+type SQLiteClientConnection<Self extends AnyConnection = AnyConnection, DriverType extends SQLiteDriverType = SQLiteDriverType, SQLiteClientType extends SQLiteClient = SQLiteClient, TransactionType extends DatabaseTransaction<Self> = DatabaseTransaction<Self>> = Connection<Self, DriverType, SQLiteClientType, TransactionType>;
+type SQLitePoolClientConnection<Self extends AnyConnection = AnyConnection, DriverType extends SQLiteDriverType = SQLiteDriverType, SQLitePoolClientType extends SQLitePoolClient = SQLitePoolClient, TransactionType extends DatabaseTransaction<Self> = DatabaseTransaction<Self>> = Connection<Self, DriverType, SQLitePoolClientType, TransactionType>;
+type SQLiteConnection<Self extends AnyConnection = AnyConnection, DriverType extends SQLiteDriverType = SQLiteDriverType, SQLiteClientType extends SQLiteClientOrPoolClient = SQLiteClient | SQLitePoolClient, TransactionType extends DatabaseTransaction<Self> = DatabaseTransaction<Self>> = (SQLiteClientType extends SQLiteClient ? SQLiteClientConnection<Self, DriverType, SQLiteClientType, TransactionType> : never) | (SQLiteClientType extends SQLitePoolClient ? SQLitePoolClientConnection<Self, DriverType, SQLiteClientType, TransactionType> : never);
+type AnySQLiteClientConnection = SQLiteClientConnection<any, any>;
+type AnySQLitePoolClientConnection = SQLitePoolClientConnection<any, any, any, any>;
+type AnySQLiteConnection = SQLiteConnection<any, any, any, any>;
+type SQLiteConnectionOptions<ConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionOptions<ConnectionType> & SQLiteClientOptions;
+type SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection, ConnectionOptions = SQLiteConnectionOptions> = {
+  driverType: InferDriverTypeFromConnection<SQLiteConnectionType>;
+  type: 'Client';
+  sqliteClientFactory: SQLiteClientFactory<InferDbClientFromConnection<SQLiteConnectionType>, ConnectionOptions>;
+  connectionOptions: SQLiteConnectionOptions<SQLiteConnectionType>;
+  serializer: JSONSerializer;
+};
+type SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLitePoolClientConnection = AnySQLitePoolClientConnection, ConnectionOptions = SQLiteConnectionOptions> = {
+  driverType: InferDriverTypeFromConnection<SQLiteConnectionType>;
+  type: 'PoolClient';
+  sqliteClientFactory: SQLiteClientFactory<InferDbClientFromConnection<SQLiteConnectionType>, ConnectionOptions>;
+  connectionOptions: SQLiteConnectionOptions<SQLiteConnectionType>;
+  serializer: JSONSerializer;
+};
+type SQLiteConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLitePoolClientConnection = AnySQLitePoolClientConnection, ClientOptions = SQLiteClientOptions> = SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions> | SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>;
+type SQLiteConnectionFactory<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = (options: ConnectionOptions) => SQLiteConnectionType;
+type TransactionNestingCounter = {
+  increment: () => void;
+  decrement: () => void;
+  reset: () => void;
+  level: number;
+};
+declare const transactionNestingCounter: () => TransactionNestingCounter;
+type SqliteAmbientClientConnectionOptions<SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection> = {
+  driverType: SQLiteConnectionType['driverType'];
+  client: InferDbClientFromConnection<SQLiteConnectionType>;
+  initTransaction?: InitTransaction<SQLiteConnectionType>;
+  allowNestedTransactions?: boolean;
+  defaultTransactionMode?: SQLiteTransactionMode;
+  serializer: JSONSerializer;
+  errorMapper?: SQLiteErrorMapper;
+};
+declare const sqliteAmbientClientConnection: <SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection>(options: SqliteAmbientClientConnectionOptions<SQLiteConnectionType>) => SQLiteConnectionType;
+declare const sqliteClientConnection: <SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection, ClientOptions = SQLiteClientOptions>(options: SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>) => SQLiteConnectionType;
+declare const sqlitePoolClientConnection: <SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection, ClientOptions = SQLiteClientOptions>(options: SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>) => SQLiteConnectionType;
+declare function sqliteConnection<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ClientOptions = SQLiteClientOptions>(options: SQLiteConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>): SQLiteConnectionType;
+type InMemorySQLiteDatabase = ':memory:';
+declare const InMemorySQLiteDatabase: SQLiteConnectionString;
+declare const DEFAULT_SQLITE_PRAGMA_OPTIONS: SQLitePragmaOptions;
+type SQLiteClientOptions = {
+  pragmaOptions?: Partial<SQLitePragmaOptions>;
+  defaultTransactionMode?: SQLiteTransactionMode;
+  skipDatabasePragmas?: boolean;
+  readonly?: boolean;
+};
+//#endregion
+//#region src/storage/sqlite/core/errors/errorMapper.d.ts
+/**
+ * Maps a SQLite error (from the `sqlite3` / node-sqlite3 driver) to a typed
+ * DumboError based on the SQLite result code.
+ *
+ * Result code reference: https://www.sqlite.org/rescode.html
+ *
+ * Falls back to a generic DumboError (500) if the error is not a recognized SQLite error.
+ */
+declare const mapSqliteError: (error: unknown) => DumboError;
+//#endregion
+//#region src/storage/sqlite/core/pool/pool.d.ts
+type SQLiteFileNameOrConnectionString = {
+  fileName: string | SQLiteConnectionString;
+  connectionString?: never;
+} | {
+  connectionString: string | SQLiteConnectionString;
+  fileName?: never;
+};
+declare const isInMemoryDatabase: (options: Record<string, unknown>) => boolean;
+type SQLiteAmbientConnectionPool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionPool<SQLiteConnectionType>;
+type SQLiteAmbientConnectionPoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = {
+  singleton?: true;
+  pooled?: false;
+  sqliteConnectionFactory?: never;
+  connection: SQLiteConnectionType;
+  connectionOptions?: never;
+};
+declare const sqliteAmbientConnectionPool: <SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection>(options: {
+  driverType: SQLiteConnectionType["driverType"];
+} & SQLiteAmbientConnectionPoolOptions<SQLiteConnectionType["driverType"]>) => SQLiteAmbientConnectionPool<SQLiteConnectionType["driverType"]>;
+type SQLiteSingletonConnectionPoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = {
+  singleton: true;
+  pooled?: true;
+  sqliteConnectionFactory: SQLiteConnectionFactory<SQLiteConnectionType, ConnectionOptions>;
+  connection?: never;
+  connectionOptions: ConnectionOptions;
+};
+type SQLiteSingletonConnectionPool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionPool<SQLiteConnectionType>;
+declare const sqliteSingletonConnectionPool: <SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions & Record<string, unknown> = SQLiteConnectionOptions & Record<string, unknown>>(options: {
+  driverType: SQLiteConnectionType["driverType"];
+} & SQLiteSingletonConnectionPoolOptions<SQLiteConnectionType, ConnectionOptions>) => SQLiteSingletonConnectionPool<SQLiteConnectionType>;
+type SQLiteAlwaysNewPoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = {
+  singleton?: false;
+  pooled?: true;
+  sqliteConnectionFactory: SQLiteConnectionFactory<SQLiteConnectionType, ConnectionOptions>;
+  connection?: never;
+  connectionOptions: ConnectionOptions;
+};
+type SQLiteAlwaysNewConnectionPool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionPool<SQLiteConnectionType>;
+declare const sqliteAlwaysNewConnectionPool: <SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions & Record<string, unknown> = SQLiteConnectionOptions & Record<string, unknown>>(options: {
+  driverType: SQLiteConnectionType["driverType"];
+} & SQLiteAlwaysNewPoolOptions<SQLiteConnectionType, ConnectionOptions>) => SQLiteAlwaysNewConnectionPool<SQLiteConnectionType>;
+type SQLitePoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = (SQLiteAlwaysNewPoolOptions<SQLiteConnectionType, ConnectionOptions> | SQLiteSingletonConnectionPoolOptions<SQLiteConnectionType, ConnectionOptions> | SQLiteAmbientConnectionPoolOptions<SQLiteConnectionType>) & {
+  driverType: SQLiteConnectionType['driverType'];
+  serializer?: JSONSerializer;
+};
+type SQLitePool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = SQLiteAmbientConnectionPool<SQLiteConnectionType> | SQLiteSingletonConnectionPool<SQLiteConnectionType> | SQLiteAlwaysNewConnectionPool<SQLiteConnectionType>;
+type SQLitePoolFactoryOptions<SQLiteConnectionType extends AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions> = Omit<SQLitePoolOptions<SQLiteConnectionType, ConnectionOptions>, 'singleton'> & {
+  singleton?: boolean;
+};
+declare const toSqlitePoolOptions: <SQLiteConnectionType extends AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions>(options: SQLitePoolFactoryOptions<SQLiteConnectionType, ConnectionOptions>) => SQLitePoolOptions<SQLiteConnectionType, ConnectionOptions>;
+declare function sqlitePool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions>(options: SQLitePoolOptions<SQLiteConnectionType, ConnectionOptions>): SQLitePool<SQLiteConnectionType>;
+//#endregion
+//#region src/storage/sqlite/core/schema/migrations.d.ts
+declare const DefaultSQLiteMigratorOptions: MigratorOptions;
+//#endregion
+//#region src/storage/sqlite/core/schema/schema.d.ts
+declare const defaultSQLiteDatabase = ":memory:";
+declare const tableExists: (execute: SQLExecutor, tableName: string) => Promise<boolean>;
+//#endregion
+//#region src/storage/sqlite/core/sql/formatter/index.d.ts
+declare const sqliteFormatter: SQLFormatter;
+//#endregion
+//#region src/storage/sqlite/core/sql/json.d.ts
+declare const SQLiteJSON: {
+  readonly path: (path: string) => SQLPlain;
+};
+//#endregion
+//#region src/storage/sqlite/core/index.d.ts
+type SQLiteDatabaseName = 'SQLite';
+declare const SQLiteDatabaseName = "SQLite";
+type SQLiteDriverType<DriverName extends string = string> = DatabaseDriverType<SQLiteDatabaseName, DriverName>;
+type SQLiteDatabaseType = 'SQLite';
+//#endregion
+export { AnySQLiteClientConnection, AnySQLiteConnection, AnySQLitePoolClientConnection, BatchSQLiteCommandOptions, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLiteAlwaysNewConnectionPool, SQLiteAmbientConnectionPool, SQLiteClient, SQLiteClientConnection, SQLiteClientConnectionDefinitionOptions, SQLiteClientFactory, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteCommandOptions, SQLiteConnection, SQLiteConnectionDefinitionOptions, SQLiteConnectionFactory, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDatabaseName, SQLiteDatabaseType, SQLiteDriverType, SQLiteError, SQLiteErrorMapper, SQLiteFileNameOrConnectionString, SQLiteJSON, SQLiteParameters, SQLitePool, SQLitePoolClient, SQLitePoolClientConnection, SQLitePoolConnectionDefinitionOptions, SQLitePoolFactoryOptions, SQLitePoolOptions, type SQLitePragmaOptions, SQLiteSQLExecutor, SQLiteSingletonConnectionPool, SQLiteTransaction, SQLiteTransactionMode, SQLiteTransactionOptions, SqliteAmbientClientConnectionOptions, TransactionNestingCounter, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapSqliteError, parsePragmasFromConnectionString, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, transactionNestingCounter };
+//# sourceMappingURL=sqlite.d.ts.map