@event-driven-io/dumbo 0.13.0-beta.4 → 0.13.0-beta.41

package/dist/index-Cmdlb0KP.d.cts

@@ -0,0 +1,1587 @@
+//#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/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/sql/sql.d.ts
+type SQL = string & {
+  __brand: 'sql';
+};
+declare function SQL(strings: TemplateStringsArray, ...values: unknown[]): SQL;
+declare namespace SQL {
+  export var EMPTY: SQL;
+  export var concat: (...sqls: SQL[]) => SQL;
+  export var merge: (sqls: SQL[], separator?: string) => SQL;
+  export var format: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => ParametrizedSQL;
+  export var describe: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => string;
+  var _a: (column: string, values: unknown[], options?: {
+    mode?: SQLArrayMode;
+  }) => SQLIn;
+  export var array: (values: unknown[], options?: {
+    mode?: SQLArrayMode;
+  }) => SQLArray;
+  export var identifier: (input: string) => SQLIdentifier;
+  export var plain: (input: string) => SQLPlain;
+  export var check: {
+    isSQL: (value: unknown) => value is SQL;
+    isTokenizedSQL: (value: unknown) => value is Readonly<{
+      __brand: "tokenized-sql";
+      sqlChunks: ReadonlyArray<string>;
+      sqlTokens: ReadonlyArray<AnySQLToken>;
+    }>;
+    isEmpty: (sql: SQL) => boolean;
+    isIdentifier: (token: unknown) => token is SQLIdentifier;
+    isPlain: (token: unknown) => token is SQLPlain;
+    isSQLIn: (token: unknown) => token is SQLIn;
+  };
+  export var column: ((input: Omit<SQLColumnToken<string | AnyColumnTypeToken>, "sqlTokenType">) => SQLColumnToken<string | AnyColumnTypeToken>) & {
+    type: typeof SQLColumnTypeTokensFactory;
+  };
+  export { _a as in };
+}
+declare function RawSQL(strings: TemplateStringsArray, ...values: unknown[]): SQL;
+declare const isSQL: (value: unknown) => value is SQL;
+//#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/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/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/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/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/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/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;
+declare module './sql' {
+  namespace SQL {
+    const columnN: typeof dumboSchema.column & {
+      type: typeof SQLColumnTypeTokensFactory;
+    };
+  }
+}
+//#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/postgresql/core/schema/postgreSQLMetadata.d.ts
+declare const postgreSQLMetadata: DatabaseMetadata<true, true, true>;
+//#endregion
+//#region src/storage/sqlite/core/schema/sqliteMetadata.d.ts
+declare const sqliteMetadata: DatabaseMetadata<false, false, false>;
+//#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 { transactionFactoryWithAsyncAmbientConnection as $, JSONCodecOptions as $a, mapDefaultSQLColumnProcessors as $i, ValidateTable as $n, NormalizeColumnPath as $r, executeInNewConnection as $t, CreateAmbientConnectionOptions as A, SQLColumnToken as Aa, mapSchemaComponentsOfType as Ai, CollectReferencesErrors as An, InferDatabaseSchemas as Ar, DatabaseLockOptions as At, WithConnectionOptions as B, SQLArrayMode as Ba, describeSQL as Bi, SchemaTablesWithSingle as Bn, AllColumnTypesInSchema as Br, getDefaultDatabase as Bt, createConnectionPool as C, JSONValueType as Ca, ExtractAdditionalData as Ci, NotNullViolationError as Cn, InferTableSchemaComponentTypes as Cr, combineMigrations as Ct, Connection as D, JavaScriptValueTypeToNameMap as Da, filterSchemaComponentsOfType as Di, TransientDatabaseError as Dn, TableURNType as Dr, AcquireDatabaseLockMode as Dt, AnyConnection as E, JavaScriptValueTypeName as Ea, SchemaComponentType as Ei, SystemError as En, TableURN as Er, runSQLMigrations as Et, InferDriverTypeFromConnection as F, TimestamptzToken as Fa, sqlMigration as Fi, DatabaseSchemasWithSingle as Fn, TableRowType as Fr, DatabaseCapabilities as Ft, AnyDatabaseTransaction as G, SQLLiteral as Ga, SQL as Gi, ValidateDatabaseSchemas as Gn, ColumnPath as Gr, DbSQLExecutor as Gt, createConnection as H, SQLDefaultTokensTypes as Ha, getFormatter as Hi, ValidateColumnTypeMatch as Hn, AnyTableRelationshipDefinition as Hr, resolveDatabaseMetadata as Ht, InferTransactionFromConnection as I, VarcharToken as Ia, FormatContext as Ii, NoError as In, Writable as Ir, DatabaseMetadata as It, InferTransactionOptionsFromTransaction as J, ParametrizedSQL as Ja, ExpandArrayProcessor as Ji, ValidateReferences as Jn, ExtractColumnNames as Jr, SQLExecutor as Jt, DatabaseTransaction as K, SQLPlain as Ka, isSQL as Ki, ValidateDatabaseSchemasWithMessages as Kn, ColumnPathToReference as Kr, DbSQLExecutorOptions as Kt, InferTransactionOptionsFromConnection as L, AnySQLToken as La, FormatSQLOptions as Li, RelationshipColumnsMismatchError as Ln, AllColumnReferences as Lr, DumboDatabaseMetadataRegistry as Lt, CreateSingletonConnectionOptions as M, SQLColumnTypeTokensFactory as Ma, MigrationRecord as Mi, ColumnReferenceError as Mn, InferTableRow as Mr, ReleaseDatabaseLockOptions as Mt, CreateTransientConnectionOptions as N, SerialToken as Na, MigrationStyle as Ni, ColumnReferenceExistanceError as Nn, TableColumnNames as Nr, defaultDatabaseLockOptions as Nt, ConnectionFactory as O, NotNullableSQLColumnTokenProps as Oa, findSchemaComponentsOfType as Oi, UniqueConstraintError as On, tableSchemaComponent as Or, AcquireDatabaseLockOptions as Ot, InferDbClientFromConnection as P, TimestampToken as Pa, SQLMigration as Pi, ColumnReferenceTypeMismatchError as Pn, TableColumnType as Pr, dumboSchema as Pt, transactionFactoryWithAmbientConnection as Q, JSONCodec as Qa, DefaultSQLColumnProcessors as Qi, ValidateSchemaTables as Qn, LookupColumnType as Qr, executeInAmbientConnection as Qt, InitTransaction as R, ExtractSQLTokenType as Ra, SQLFormatter as Ri, RelationshipReferencesLengthMismatchError as Rn, AllColumnReferencesInSchema as Rr, dumboDatabaseMetadataRegistry as Rt, createBoundedConnectionPool as S, JSONBToken as Sa, DumboSchemaComponentType as Si, LockNotAvailableError as Sn, InferTableSchemaComponentColumns as Sr, RunSQLMigrationsResult as St, createSingletonConnectionPool as T, JavaScriptValueType as Ta, SchemaComponentOptions as Ti, SerializationError as Tn, TableSchemaComponent as Tr, registerDefaultMigratorOptions as Tt, createSingletonConnection as U, SQLIdentifier as Ua, registerFormatter as Ui, ValidateColumnsMatch as Un, AnyTableRelationshipDefinitionWithColumns as Ur, BatchCommandNoChangesError as Ut, createAmbientConnection as V, SQLDefaultTokens as Va, formatSQL as Vi, ValidateColumnReference as Vn, AnyRelationshipDefinition as Vr, getDefaultDatabaseAsync as Vt, createTransientConnection as W, SQLIn as Wa, RawSQL as Wi, ValidateDatabaseSchema as Wn, ColumnName$1 as Wr, BatchSQLCommandOptions as Wt, WithDatabaseTransactionFactory as X, SerializationCodec as Xa, FormatIdentifierProcessor as Xi, ValidateRelationshipColumns as Xn, ExtractSchemaNames as Xr, SQLQueryResultColumnMapping as Xt, TransactionResult as Y, ParametrizedSQLBuilder as Ya, ExpandSQLInProcessor as Yi, ValidateRelationship as Yn, ExtractColumnTypeName as Yr, SQLQueryOptions as Yt, executeInTransaction as Z, Serializer as Za, MapLiteralProcessor as Zi, ValidateRelationshipLength as Zn, ExtractTableNames as Zr, WithSQLExecutor as Zt, CreateConnectionPoolOptions as _, BigIntegerToken as _a, ColumnURN as _i, ExclusionViolationError as _n, DatabaseSchemaTables as _r, dumboDatabaseDriverRegistry as _t, parseConnectionString as a, SQLProcessorOptions as aa, TableColumnName as ai, sqlExecutor as an, JSONRevivers as ao, FormatTableLevel as ar, DatabaseType as at, createAlwaysNewConnectionPool as b, DefaultSQLColumnToken as ba, AnySchemaComponent as bi, IntegrityConstraintViolationError as bn, databaseSchemaSchemaComponent as br, MIGRATIONS_LOCK_ID as bt, LogLevel as c, DefaultMapSQLParamValueOptions as ca, AnyTypeValidationError as ci, QueryResult as cn, JSONSerializer as co, Join as cr, getDatabaseDriverName as ct, tracer as d, SQLValueMapper as da, IndexURN as di, CheckViolationError as dn, composeJSONRevivers as do, DatabaseSchemas as dr, AnyDumboDatabaseDriver as dt, SQLProcessorsReadonlyRegistry as ea, NormalizeReference as ei, executeInNewDbClient as en, JSONDeserializeOptions as eo, ValidateTableRelationships as er, transactionFactoryWithDbClient as et, AmbientConnectionPoolOptions as f, mapANSISQLParamPlaceholder as fa, IndexURNType as fi, ConcurrencyError as fn, jsonSerializer as fo, DatabaseURN as fr, DumboDatabaseDriver as ft, CreateBoundedConnectionPoolOptions as g, AutoIncrementSQLColumnToken as ga, ColumnSchemaComponentOptions as gi, DumboError as gn, DatabaseSchemaSchemaComponent as gr, canHandleDriverWithConnectionString as gt, CreateAlwaysNewConnectionPoolOptions as h, AnyColumnTypeToken as ha, ColumnSchemaComponent as hi, DeadlockError as hn, AnyDatabaseSchemaSchemaComponent as hr, ExtractDumboTypeFromDriver as ht, DatabaseConnectionString as i, SQLProcessorContext as ia, SchemaColumnName as ii, mapSQLQueryResult as in, JSONReviverContext as io, FormatSingleError as ir, DatabaseDriverTypeParts as it, CreateConnectionOptions as j, SQLColumnTypeTokens as ja, schemaComponent as ji, CollectRelationshipErrors as jn, InferSchemaTables as jr, NoDatabaseLock as jt, ConnectionOptions as k, NullableSQLColumnTokenProps as ka, isSchemaComponentOfType as ki, schemaComponentURN as kn, InferColumnType as kr, DatabaseLock as kt, LogStyle as l, MapSQLParamValue as la, TypeValidationSuccess as li, QueryResultRow as ln, JSONSerializerOptions as lo, AnyDatabaseSchemaComponent as lr, getDatabaseType as lt, ConnectionPoolFactory as m, mapSQLParamValue as ma, AnyColumnSchemaComponent as mi, DataError as mn, databaseSchemaComponent as mr, ExtractDumboDatabaseDriverOptions as mt, sqliteMetadata as n, AnySQLProcessor as na, RelationshipDefinition as ni, mapColumnToDate as nn, JSONReplacers as no, FormatRelationshipBlock as nr, DatabaseDriverName as nt, Dumbo as o, ANSISQLIdentifierQuote as oa, TableRelationships as oi, sqlExecutorInAmbientConnection as on, JSONSerializationOptions as oo, FormatValidationErrors as or, InferDriverDatabaseType as ot, ConnectionPool as p, mapSQLIdentifier as pa, indexSchemaComponent as pi, ConnectionError as pn, DbClientSetup as po, DatabaseURNType as pr, DumboDatabaseDriverRegistry as pt, DatabaseTransactionOptions as q, SQLToken as qa, defaultProcessorsRegistry as qi, ValidateReference as qn, ColumnReference as qr, SQLCommandOptions as qt, postgreSQLMetadata as r, SQLProcessor as ra, RelationshipType as ri, mapColumnToJSON as rn, JSONReviver as ro, FormatSchemaLevel as rr, DatabaseDriverType as rt, DumboConnectionOptions as s, ANSISQLParamPlaceholder as sa, relationship as si, sqlExecutorInNewConnection as sn, JSONSerializeOptions as so, IndentErrors as sr, fromDatabaseDriverType as st, dumbo as t, SQLProcessorsRegistry as ta, ParseReferencePath as ti, mapColumnToBigint as tn, JSONReplacer as to, FormatDatabaseValidationErrors as tr, transactionFactoryWithNewConnection as tt, LogType as u, MapSQLParamValueOptions as ua, IndexSchemaComponent as ui, AdminShutdownError as un, composeJSONReplacers as uo, DatabaseSchemaComponent as ur, toDatabaseDriverType as ut, SingletonClientConnectionPoolOptions as v, BigSerialToken as va, ColumnURNType as vi, ForeignKeyViolationError as vn, DatabaseSchemaURN as vr, SchemaComponentMigrator as vt, createSingletonClientConnectionPool as w, JSONValueTypeName as wa, SchemaComponent as wi, QueryCanceledError as wn, TableColumns as wr, getDefaultMigratorOptionsFromRegistry as wt, createAmbientConnectionPool as x, IntegerToken as xa, AnySchemaComponentOfType as xi, InvalidOperationError as xn, AnyTableSchemaComponent as xr, MigratorOptions as xt, SingletonConnectionPoolOptions as y, ColumnTypeToken as ya, columnSchemaComponent as yi, InsufficientResourcesError as yn, DatabaseSchemaURNType as yr, migrationTableSchemaComponent as yt, WithConnectionFactory as z, SQLArray as za, SQLFormatterOptions as zi, RelationshipValidationError as zn, AllColumnTypes as zr, getDatabaseMetadata as zt };
+//# sourceMappingURL=index-Cmdlb0KP.d.cts.map