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

package/dist/index-QWEAqtHF.d.ts

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