@event-driven-io/dumbo 0.13.0-beta.35 → 0.13.0-beta.36

package/dist/{connectionString-Dch_MIRU.d.cts → index-BDSQvDH2.d.cts}

@@ -1,489 +1,523 @@
+//#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;
+  parseDates?: boolean;
+  parseBigInts?: boolean;
+  failOnBigIntSerialization?: boolean;
+  useDefaultDateSerialization?: boolean;
 };
 type JSONSerializeOptions = {
-    replacer?: JSONReplacer;
+  replacer?: JSONReplacer;
 } & JSONSerializerOptions;
 type JSONDeserializeOptions = {
-    reviver?: JSONReviver;
+  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?: JSONSerializer<SerializeOptions, DeserializeOptions>;
+  serializerOptions?: never;
 } | {
-    serializer?: never;
-    serializerOptions?: JSONSerializerOptions;
+  serializer?: never;
+  serializerOptions?: JSONSerializerOptions;
 };
 type JSONSerializationOptions<SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> = {
-    serialization?: {
-        serializer?: JSONSerializer<SerializeOptions, DeserializeOptions>;
-        options?: JSONSerializeOptions | JSONDeserializeOptions;
-    } | undefined;
+  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;
+  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;
+  source: string;
 };
 declare const composeJSONReplacers: (...replacers: (JSONReplacer | undefined)[]) => JSONReplacer | undefined;
 declare const composeJSONRevivers: (...revivers: (JSONReviver | undefined)[]) => JSONReviver | undefined;
-type JSONReplacer = (this: any, key: string, value: any) => any;
 declare const JSONReplacer: (opts?: JSONSerializeOptions) => JSONReplacer | undefined;
-type JSONReviver = (this: any, key: string, value: any, context: JSONReviverContext) => any;
 declare const JSONReviver: (opts?: JSONDeserializeOptions) => JSONReviver | undefined;
 declare const JSONReplacers: {
-    bigInt: JSONReplacer;
-    date: JSONReplacer;
+  bigInt: JSONReplacer;
+  date: JSONReplacer;
 };
 declare const JSONRevivers: {
-    bigInt: JSONReviver;
-    date: JSONReviver;
+  bigInt: JSONReviver;
+  date: JSONReviver;
 };
 declare const jsonSerializer: (options?: JSONSerializerOptions & JSONDeserializeOptions & JSONSerializeOptions) => JSONSerializer;
-interface JSONSerializer<SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> extends Serializer<string, SerializeOptions, DeserializeOptions> {
-    serialize<T>(object: T, options?: SerializeOptions): string;
-    deserialize<T>(payload: string, options?: DeserializeOptions): T;
-}
 declare const JSONSerializer: JSONSerializer & {
-    from: <SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions>(options?: JSONSerializationOptions<SerializeOptions, DeserializeOptions>) => JSONSerializer<SerializeOptions, DeserializeOptions>;
+  from: <SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions>(options?: JSONSerializationOptions<SerializeOptions, DeserializeOptions>) => JSONSerializer<SerializeOptions, DeserializeOptions>;
 };
-interface JSONCodec<T, SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions> extends SerializationCodec<T, string, SerializeOptions, DeserializeOptions> {
-    encode(object: T, options?: SerializeOptions): string;
-    decode(payload: string, options?: DeserializeOptions): T;
-}
 declare const JSONCodec: <T, Payload = T, SerializeOptions extends JSONSerializeOptions = JSONSerializeOptions, DeserializeOptions extends JSONDeserializeOptions = JSONDeserializeOptions>(options: JSONCodecOptions<T, Payload, SerializeOptions, DeserializeOptions>) => JSONCodec<T, SerializeOptions, DeserializeOptions>;
-
+//#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;
+  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;
+  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[];
+  query: string;
+  params: unknown[];
 }
 interface ParametrizedSQLBuilder {
-    addSQL: (str: string) => ParametrizedSQLBuilder;
-    addParam(value: unknown): ParametrizedSQLBuilder;
-    addParams(values: unknown[]): ParametrizedSQLBuilder;
-    build: () => ParametrizedSQL;
+  addSQL: (str: string) => ParametrizedSQLBuilder;
+  addParam(value: unknown): ParametrizedSQLBuilder;
+  addParams(values: unknown[]): ParametrizedSQLBuilder;
+  build: () => ParametrizedSQL;
 }
-declare const ParametrizedSQLBuilder: ({ mapParamPlaceholder, }: {
-    mapParamPlaceholder: (index: number, value: unknown) => string;
+declare const ParametrizedSQLBuilder: ({
+  mapParamPlaceholder
+}: {
+  mapParamPlaceholder: (index: number, value: unknown) => string;
 }) => ParametrizedSQLBuilder;
-
-type ExtractSQLTokenType<T> = T extends (...args: never[]) => infer R ? R extends SQLToken ? R : never : T extends SQLToken ? T : never;
-type AnySQLToken = SQLToken<string, any>;
+//#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;
+  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;
+  <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;
+  value: string;
 }>;
 declare const SQLIdentifier: {
-    from: (input: string) => SQLIdentifier;
-    check: (token: unknown) => token is SQLIdentifier;
-    type: "SQL_IDENTIFIER";
+  from: (input: string) => SQLIdentifier;
+  check: (token: unknown) => token is SQLIdentifier;
+  type: "SQL_IDENTIFIER";
 };
 type SQLPlain = SQLToken<'SQL_RAW', {
-    value: string;
+  value: string;
 }>;
 declare const SQLPlain: {
-    from: (input: string) => SQLPlain;
-    check: (token: unknown) => token is SQLPlain;
-    type: "SQL_RAW";
+  from: (input: string) => SQLPlain;
+  check: (token: unknown) => token is SQLPlain;
+  type: "SQL_RAW";
 };
 type SQLLiteral = SQLToken<'SQL_LITERAL', {
-    value: unknown;
+  value: unknown;
 }>;
 declare const SQLLiteral: {
-    from: (input: unknown) => SQLLiteral;
-    check: (token: unknown) => token is SQLLiteral;
-    type: "SQL_LITERAL";
+  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;
+  value: unknown[];
+  mode?: SQLArrayMode;
 }>;
 declare const SQLArray: {
-    from: (input: unknown[] | {
-        value: unknown[];
-        mode?: SQLArrayMode;
-    }) => SQLArray;
-    check: (token: unknown) => token is SQLArray;
-    type: "SQL_ARRAY";
+  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;
+  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";
+  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 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;
+  __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"];
+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";
+  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";
+  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";
+  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";
+  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: 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";
+  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";
+  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';
+  length: number | 'max';
 }>;
 declare const VarcharToken: {
-    from: (input: number | "max") => VarcharToken;
-    check: (token: unknown) => token is VarcharToken;
-    type: "SQL_COLUMN_VARCHAR";
+  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: true;
+  unique?: boolean;
+  primaryKey?: boolean;
+  default?: ColumnType | SQLToken;
 } | {
-    name: string;
-    type: ColumnType;
-    notNull?: false;
-    unique?: boolean;
-    primaryKey: never;
-    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;
+  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;
+  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";
-};
-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";
-    };
+  };
+  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;
+  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;
+  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;
-type SQLColumnToken<ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string> = SQLToken<'SQL_COLUMN', NotNullableSQLColumnTokenProps<ColumnType> | NullableSQLColumnTokenProps<ColumnType>>;
 declare const SQLColumnToken: {
-    from: (input: Omit<SQLColumnToken<string | AnyColumnTypeToken>, "sqlTokenType">) => SQLColumnToken<string | AnyColumnTypeToken>;
-    check: (token: unknown) => token is SQLColumnToken<string | AnyColumnTypeToken>;
-    type: "SQL_COLUMN";
+  from: (input: Omit<SQLColumnToken<string | AnyColumnTypeToken>, "sqlTokenType">) => SQLColumnToken<string | AnyColumnTypeToken>;
+  check: (token: unknown) => token is SQLColumnToken<string | AnyColumnTypeToken>;
+  type: "SQL_COLUMN";
 };
-
+//#endregion
+//#region src/core/sql/valueMappers/sqlValueMapper.d.ts
+interface SQLValueMapper {
+  mapValue: MapSQLParamValue;
+  mapPlaceholder: (index: number, value: unknown) => string;
+  mapIdentifier: (value: string) => string;
+}
 type MapSQLParamValue = (value: unknown, serializer: JSONSerializer, options?: MapSQLParamValueOptions) => unknown;
 interface MapSQLParamValueOptions {
-    mapBoolean?: (value: boolean) => unknown;
-    mapArray?: (array: unknown[], mapValue: MapSQLParamValue) => unknown[];
-    mapDate?: (value: Date) => unknown;
-    mapObject?: (value: object) => unknown;
-    mapBigInt?: (value: bigint) => unknown;
-    mapValue?: MapSQLParamValue;
-    mapPlaceholder?: (index: number, value: unknown) => string;
-    mapIdentifier?: (value: string) => string;
+  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;
+      [key: string]: boolean;
     };
     quote?: string;
-}) => string;
-declare const DefaultMapSQLParamValueOptions: {
-    mapPlaceholder: () => string;
-    mapIdentifier: (value: string, options?: {
-        reservedWords: {
-            [key: string]: boolean;
-        };
-        quote?: string;
-    }) => string;
+  }) => string;
 };
-interface SQLValueMapper {
-    mapValue: MapSQLParamValue;
-    mapPlaceholder: (index: number, value: unknown) => string;
-    mapIdentifier: (value: 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;
+  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;
-};
-type SQLProcessor<Token extends AnySQLToken = AnySQLToken> = {
-    canHandle: Token['sqlTokenType'];
-    handle: (value: Token, context: SQLProcessorContext) => void;
+  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>;
+  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;
+  register(...processor: AnySQLProcessor[]): SQLProcessorsRegistry;
+  register(processor: Record<string, AnySQLProcessor>): SQLProcessorsRegistry;
 }
 declare const SQLProcessorsRegistry: (options?: {
-    from: SQLProcessorsRegistry;
+  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>;
+  var defaultProcessorsRegistry: ReturnType<typeof SQLProcessorsRegistry>;
 }
 declare const defaultProcessorsRegistry: SQLProcessorsRegistry;
-
+//#endregion
+//#region src/core/sql/sql.d.ts
 type SQL = string & {
-    __brand: 'sql';
+  __brand: 'sql';
 };
 declare function SQL(strings: TemplateStringsArray, ...values: unknown[]): SQL;
 declare namespace SQL {
-    export var EMPTY: SQL;
-    export var concat: (...sqls: SQL[]) => SQL;
-    export var merge: (sqls: SQL[], separator?: string) => SQL;
-    export var format: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => ParametrizedSQL;
-    export var describe: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => string;
-    var _a: (column: string, values: unknown[], options?: {
-        mode?: SQLArrayMode;
-    }) => SQLIn;
-    export var array: (values: unknown[], options?: {
-        mode?: SQLArrayMode;
-    }) => SQLArray;
-    export var identifier: (input: string) => SQLIdentifier;
-    export var plain: (input: string) => SQLPlain;
-    export var check: {
-        isSQL: (value: unknown) => value is SQL;
-        isTokenizedSQL: (value: unknown) => value is Readonly<{
-            __brand: "tokenized-sql";
-            sqlChunks: ReadonlyArray<string>;
-            sqlTokens: ReadonlyArray<AnySQLToken>;
-        }>;
-        isEmpty: (sql: SQL) => boolean;
-        isIdentifier: (token: unknown) => token is SQLIdentifier;
-        isPlain: (token: unknown) => token is SQLPlain;
-        isSQLIn: (token: unknown) => token is SQLIn;
-    };
-    export var column: ((input: Omit<SQLColumnToken<string | AnyColumnTypeToken>, "sqlTokenType">) => SQLColumnToken<string | AnyColumnTypeToken>) & {
-        type: typeof SQLColumnTypeTokensFactory;
-    };
-    export { _a as in };
+  export var EMPTY: SQL;
+  export var concat: (...sqls: SQL[]) => SQL;
+  export var merge: (sqls: SQL[], separator?: string) => SQL;
+  export var format: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => ParametrizedSQL;
+  export var describe: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => string;
+  var _a: (column: string, values: unknown[], options?: {
+    mode?: SQLArrayMode;
+  }) => SQLIn;
+  export var array: (values: unknown[], options?: {
+    mode?: SQLArrayMode;
+  }) => SQLArray;
+  export var identifier: (input: string) => SQLIdentifier;
+  export var plain: (input: string) => SQLPlain;
+  export var check: {
+    isSQL: (value: unknown) => value is SQL;
+    isTokenizedSQL: (value: unknown) => value is Readonly<{
+      __brand: "tokenized-sql";
+      sqlChunks: ReadonlyArray<string>;
+      sqlTokens: ReadonlyArray<AnySQLToken>;
+    }>;
+    isEmpty: (sql: SQL) => boolean;
+    isIdentifier: (token: unknown) => token is SQLIdentifier;
+    isPlain: (token: unknown) => token is SQLPlain;
+    isSQLIn: (token: unknown) => token is SQLIn;
+  };
+  export var column: ((input: Omit<SQLColumnToken<string | AnyColumnTypeToken>, "sqlTokenType">) => SQLColumnToken<string | AnyColumnTypeToken>) & {
+    type: typeof SQLColumnTypeTokensFactory;
+  };
+  export { _a as in };
 }
 declare function RawSQL(strings: TemplateStringsArray, ...values: unknown[]): SQL;
 declare const isSQL: (value: unknown) => value is SQL;
-
+//#endregion
+//#region src/core/sql/formatters/sqlFormatter.d.ts
 type FormatContext = Partial<SQLProcessorContext> & Pick<SQLProcessorContext, 'serializer'>;
+interface SQLFormatter {
+  format: (sql: SQL | SQL[], context: FormatContext) => ParametrizedSQL;
+  describe: (sql: SQL | SQL[], context: FormatContext) => string;
+  valueMapper: SQLValueMapper;
+}
 type FormatSQLOptions = {
-    mapper?: MapSQLParamValueOptions;
-    processorsRegistry?: SQLProcessorsReadonlyRegistry;
-    serializer?: JSONSerializer;
+  mapper?: MapSQLParamValueOptions;
+  processorsRegistry?: SQLProcessorsReadonlyRegistry;
+  serializer?: JSONSerializer;
 };
 type SQLFormatterOptions = Partial<Omit<SQLFormatter, 'valueMapper'>> & {
-    valueMapper?: MapSQLParamValueOptions;
-    processorsRegistry?: SQLProcessorsReadonlyRegistry;
-};
-interface SQLFormatter {
-    format: (sql: SQL | SQL[], context: FormatContext) => ParametrizedSQL;
-    describe: (sql: SQL | SQL[], context: FormatContext) => string;
-    valueMapper: SQLValueMapper;
-}
-declare const SQLFormatter: ({ format, describe, valueMapper: valueMapperOptions, processorsRegistry, }: SQLFormatterOptions) => SQLFormatter;
+  valueMapper?: MapSQLParamValueOptions;
+  processorsRegistry?: SQLProcessorsReadonlyRegistry;
+};
+declare const SQLFormatter: ({
+  format,
+  describe,
+  valueMapper: valueMapperOptions,
+  processorsRegistry
+}: SQLFormatterOptions) => SQLFormatter;
 declare global {
-    var dumboSQLFormatters: Record<string, SQLFormatter>;
+  var dumboSQLFormatters: Record<string, SQLFormatter>;
 }
 declare const registerFormatter: (dialect: string, formatter: SQLFormatter) => void;
 declare const getFormatter: (dialect: string) => SQLFormatter;
 declare function formatSQL(sql: SQL | SQL[], formatter: SQLFormatter, serializer: JSONSerializer, context?: FormatSQLOptions): ParametrizedSQL;
 declare const describeSQL: (sql: SQL | SQL[], formatter: SQLFormatter, serializer: JSONSerializer, options?: FormatSQLOptions) => string;
-
+//#endregion
+//#region src/core/schema/sqlMigration.d.ts
 type MigrationStyle = 'None' | 'CreateOrUpdate';
 type SQLMigration = {
-    name: string;
-    sqls: SQL[];
+  name: string;
+  sqls: SQL[];
 };
 declare const sqlMigration: (name: string, sqls: SQL[]) => SQLMigration;
 type MigrationRecord = {
-    id: number;
-    name: string;
-    application: string;
-    sqlHash: string;
-    timestamp: Date;
-};
-
+  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;
+  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>;
+  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}`>;
@@ -492,831 +526,842 @@ declare const isSchemaComponentOfType: <SchemaComponentOfType extends AnySchemaC
 declare const filterSchemaComponentsOfType: <T extends AnySchemaComponent>(components: ReadonlyMap<string, AnySchemaComponent>, prefix: string) => ReadonlyMap<string, T>;
 declare const mapSchemaComponentsOfType: <T extends AnySchemaComponent>(components: ReadonlyMap<string, AnySchemaComponent>, prefix: string, keyMapper?: (component: T) => string) => ReadonlyMap<string, T>;
 declare const findSchemaComponentsOfType: <T extends AnySchemaComponent>(root: AnySchemaComponent, prefix: string) => T[];
-
+//#endregion
+//#region src/core/schema/components/columnSchemaComponent.d.ts
 type ColumnURNType = 'sc:dumbo:column';
-declare const ColumnURNType: ColumnURNType;
 type ColumnURN<ColumnName extends string = string> = `${ColumnURNType}:${ColumnName}`;
-declare const ColumnURN: <ColumnName extends string = string>({ name, }: {
-    name: 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;
+  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;
+  columnName: ColumnName;
 } & TOptions) => ColumnSchemaComponent<ColumnType, ColumnName> & (TOptions extends {
-    notNull: true;
+  notNull: true;
 } | {
-    primaryKey: true;
+  primaryKey: true;
 } ? {
-    notNull: true;
+  notNull: true;
 } : {
-    notNull?: false;
+  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;
+  indexName: string;
+  columnNames: ReadonlyArray<string>;
+  isUnique: boolean;
+  addColumn: (column: string | ColumnSchemaComponent) => void;
 }>>;
-type IndexURNType = 'sc:dumbo:index';
 declare const IndexURNType: IndexURNType;
-type IndexURN = `${IndexURNType}:${string}`;
-declare const IndexURN: ({ name }: {
-    name: string;
+declare const IndexURN: ({
+  name
+}: {
+  name: string;
 }) => IndexURN;
-declare const indexSchemaComponent: ({ indexName, columnNames, isUnique, ...migrationsOrComponents }: {
-    indexName: string;
-    columnNames: string[];
-    isUnique: boolean;
+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: true;
 } : {
-    valid: false;
-    error: Error;
+  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;
+  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 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;
-
+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]['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 & 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]['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 & string}`;
-    }[keyof Columns] : never;
-}[keyof Tables] : 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<ColName extends string = string> = `${ColName}`;
+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<ColName>;
+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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  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;
+  readonly columns: Columns;
+  readonly references: References;
+  readonly type: RelType;
 };
 type AnyRelationshipDefinition = RelationshipDefinition<any, any, any>;
-
-type Writable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
+//#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;
+  notNull: true;
 } | {
-    primaryKey: 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 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';
-declare const TableURNType: TableURNType;
 type TableURN = `${TableURNType}:${string}`;
-declare const TableURN: ({ name }: {
-    name: 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;
+  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;
+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;
+  relationships: Relationships;
 };
-
+//#endregion
+//#region src/core/schema/components/databaseSchemaSchemaComponent.d.ts
 type DatabaseSchemaURNType = 'sc:dumbo:database_schema';
-declare const DatabaseSchemaURNType: DatabaseSchemaURNType;
 type DatabaseSchemaURN<SchemaName extends string = string> = `${DatabaseSchemaURNType}:${SchemaName}`;
-declare const DatabaseSchemaURN: <SchemaName extends string = string>({ name, }: {
-    name: 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;
+  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;
+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';
-declare const DatabaseURNType: DatabaseURNType;
 type DatabaseURN = `${DatabaseURNType}:${string}`;
-declare const DatabaseURN: ({ name }: {
-    name: 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;
+  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;
+declare const databaseSchemaComponent: <Schemas extends DatabaseSchemas = DatabaseSchemas>({
+  databaseName,
+  schemas,
+  ...migrationsOrComponents
+}: {
+  databaseName: string;
+  schemas?: Schemas;
 } & SchemaComponentOptions) => DatabaseSchemaComponent<Schemas>;
-
-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>] : [];
+//#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;
+  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[];
+  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[];
+  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;
+  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;
+  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;
+  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;
+  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 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;
+  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 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: 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 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: 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 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[];
+  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[];
-    };
+  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[];
-    };
+  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;
-    };
+  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;
-    };
+  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 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>;
+  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;
+  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;
+  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;
+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 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>;
+  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>;
+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 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;
+  static readonly ErrorCode: number;
+  static readonly ErrorType: string;
+  errorCode: number;
+  errorType: string;
+  innerError: Error | undefined;
+  constructor(options?: {
     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;
+    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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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;
+  [column: string]: any;
 }
 type QueryResult<Result extends QueryResultRow = QueryResultRow> = {
-    rowCount: number | null;
-    rows: Result[];
+  rowCount: number | null;
+  rows: Result[];
 };
-
+//#endregion
+//#region src/core/execute/execute.d.ts
 declare const mapColumnToJSON: (column: string, serializer: JSONSerializer, options?: JSONDeserializeOptions) => {
-    [x: string]: (value: unknown) => unknown;
+  [x: string]: (value: unknown) => unknown;
 };
 declare const mapColumnToBigint: (column: string) => {
-    [x: string]: (value: unknown) => unknown;
+  [x: string]: (value: unknown) => unknown;
 };
 declare const mapColumnToDate: (column: string) => {
-    [x: string]: (value: unknown) => unknown;
+  [x: string]: (value: unknown) => unknown;
 };
 declare const mapSQLQueryResult: <T>(result: T, mapping: SQLQueryResultColumnMapping) => T;
 type SQLQueryResultColumnMapping = {
-    [column: string]: (value: unknown) => unknown;
+  [column: string]: (value: unknown) => unknown;
 };
 type SQLQueryOptions = {
-    timeoutMs?: number | undefined;
-    mapping?: SQLQueryResultColumnMapping;
+  timeoutMs?: number | undefined;
+  mapping?: SQLQueryResultColumnMapping;
 };
 type SQLCommandOptions = {
-    timeoutMs?: number | undefined;
-    mapping?: SQLQueryResultColumnMapping;
+  timeoutMs?: number | undefined;
+  mapping?: SQLQueryResultColumnMapping;
 };
 type BatchSQLCommandOptions = SQLCommandOptions & {
-    assertChanges?: boolean;
+  assertChanges?: boolean;
 };
 declare class BatchCommandNoChangesError extends DumboError {
-    readonly statementIndex: number;
-    constructor(statementIndex: number);
+  readonly statementIndex: number;
+  constructor(statementIndex: number);
 }
 type DbSQLExecutorOptions = {
-    serializer: JSONSerializer;
+  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;
+  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>[]>;
+  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;
+  execute: SQLExecutor;
 }
 declare const sqlExecutor: <DbClient = unknown, DbExecutor extends DbSQLExecutor = DbSQLExecutor>(sqlExecutor: DbExecutor, options: {
-    connect: () => Promise<DbClient>;
-    close?: (client: DbClient, error?: unknown) => Promise<void>;
+  connect: () => Promise<DbClient>;
+  close?: (client: DbClient, error?: unknown) => Promise<void>;
 }) => SQLExecutor;
 declare const sqlExecutorInNewConnection: <ConnectionType extends Connection>(options: {
-    driverType: ConnectionType["driverType"];
-    connection: () => Promise<ConnectionType>;
+  driverType: ConnectionType["driverType"];
+  connection: () => Promise<ConnectionType>;
 }) => SQLExecutor;
 declare const sqlExecutorInAmbientConnection: <ConnectionType extends Connection>(options: {
-    driverType: ConnectionType["driverType"];
-    connection: () => Promise<ConnectionType>;
+  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>;
+  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>;
+  connection: () => Promise<ConnectionType>;
 }) => Promise<Result>;
 declare const executeInAmbientConnection: <ConnectionType extends Connection, Result>(handle: (connection: ConnectionType) => Promise<Result>, options: {
-    connection: () => Promise<ConnectionType>;
+  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;
+  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>;
+  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: string;
+  readonly parseDatabaseName: (connectionString?: string) => string | undefined;
 } : {
-    readonly defaultDatabaseName?: never;
-    readonly parseDatabaseName?: never;
+  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>;
 } : {
-    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[];
+  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>;
+  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[];
+  register: (databaseType: DatabaseType, info: DatabaseMetadata | (() => Promise<DatabaseMetadata>)) => void;
+  tryResolve: (databaseType: DatabaseType) => Promise<DatabaseMetadata | null>;
+  tryGet: (databaseType: DatabaseType) => DatabaseMetadata | null;
+  has: (databaseType: DatabaseType) => boolean;
+  readonly databaseTypes: DatabaseType[];
 };
 declare const getDatabaseMetadata: (driverType: DatabaseDriverType) => DatabaseMetadata | null;
 declare const resolveDatabaseMetadata: (driverType: DatabaseDriverType, driverOverride?: DatabaseMetadata) => Promise<DatabaseMetadata | null>;
 declare const getDefaultDatabase: (driverType: DatabaseDriverType) => string | undefined;
 declare const getDefaultDatabaseAsync: (driverType: DatabaseDriverType) => Promise<string | undefined>;
-
+//#endregion
+//#region src/core/schema/dumboSchema/dumboSchema.d.ts
 declare const DEFAULT_DATABASE_SCHEMA_NAME = "__default_database_schema__";
 declare function dumboDatabaseSchema<const Tables extends DatabaseSchemaTables = DatabaseSchemaTables>(tables: Tables): DatabaseSchemaSchemaComponent<Tables, typeof DEFAULT_DATABASE_SCHEMA_NAME>;
 declare function dumboDatabaseSchema<const Tables extends DatabaseSchemaTables = DatabaseSchemaTables, const SchemaName extends string = string>(schemaName: SchemaName, tables: Tables, options?: SchemaComponentOptions): DatabaseSchemaSchemaComponent<Tables, SchemaName>;
 declare namespace dumboDatabaseSchema {
-    var from: (schemaName: string | undefined, tableNames: string[]) => DatabaseSchemaSchemaComponent;
-    var defaultName: string;
+  var from: (schemaName: string | undefined, tableNames: string[]) => DatabaseSchemaSchemaComponent;
+  var defaultName: string;
 }
 type ValidatedDatabaseSchemaComponent<Schemas extends DatabaseSchemas = DatabaseSchemas> = ValidateDatabaseSchemas<Schemas> extends {
-    valid: true;
+  valid: true;
 } ? DatabaseSchemaComponent<Schemas> : ValidateDatabaseSchemas<Schemas> extends {
-    valid: false;
-    error: infer E;
+  valid: false;
+  error: infer E;
 } ? {
-    valid: false;
-    error: 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;
+  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?: SQLToken | ColumnType;
-    }, "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;
-};
-
+  database: typeof dumboDatabase;
+  schema: typeof dumboDatabaseSchema;
+  table: <const Columns extends TableColumns = TableColumns, const TableName extends string = string, const Relationships extends TableRelationships<keyof Columns & string> = TableRelationships<keyof Columns & string>>(name: TableName, definition: {
+    columns?: Columns;
+    primaryKey?: TableColumnNames<TableSchemaComponent<Columns, TableName, Relationships>>[];
+    relationships?: Relationships;
+    indexes?: Record<string, IndexSchemaComponent>;
+  } & SchemaComponentOptions) => TableSchemaComponent<Columns, TableName, Relationships>;
+  column: <const ColumnType extends AnyColumnTypeToken | string = string | AnyColumnTypeToken, const TOptions extends SchemaComponentOptions & Omit<SQLColumnToken<ColumnType>, "name" | "type" | "sqlTokenType"> = Omit<ColumnSchemaComponentOptions<ColumnType>, "type">, const ColumnName extends string = string>(name: ColumnName, type: ColumnType, options?: TOptions) => ({
+    schemaComponentKey: `sc:dumbo:column:${ColumnName}`;
+    components: ReadonlyMap<string, SchemaComponent>;
+    migrations: ReadonlyArray<SQLMigration>;
+    addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
+    addMigration: (migration: SQLMigration) => void;
+  } & Readonly<{
+    columnName: ColumnName;
+  }> & {
+    sqlTokenType: "SQL_COLUMN";
+  } & Omit<{
+    name: string;
+    type: ColumnType;
+    notNull?: false;
+    unique?: boolean;
+    primaryKey: never;
+    default?: ColumnType | SQLToken;
+  }, "sqlTokenType"> & (TOptions & {
+    type: ColumnType;
+  } extends infer T ? T extends TOptions & {
+    type: ColumnType;
+  } ? T extends {
+    notNull: true;
+  } | {
+    primaryKey: true;
+  } ? {
+    notNull: true;
+  } : {
+    notNull?: false;
+  } : never : never)) | ({
+    schemaComponentKey: `sc:dumbo:column:${ColumnName}`;
+    components: ReadonlyMap<string, SchemaComponent>;
+    migrations: ReadonlyArray<SQLMigration>;
+    addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
+    addMigration: (migration: SQLMigration) => void;
+  } & Readonly<{
+    columnName: ColumnName;
+  }> & {
+    sqlTokenType: "SQL_COLUMN";
+  } & Omit<NullableSQLColumnTokenProps<ColumnType>, "sqlTokenType"> & (TOptions & {
+    type: ColumnType;
+  } extends infer T_1 ? T_1 extends TOptions & {
+    type: ColumnType;
+  } ? T_1 extends {
+    notNull: true;
+  } | {
+    primaryKey: true;
+  } ? {
+    notNull: true;
+  } : {
+    notNull?: false;
+  } : never : never));
+  index: (name: string, columnNames: string[], options?: {
+    unique?: boolean;
+  } & SchemaComponentOptions) => IndexSchemaComponent;
+};
+//#endregion
+//#region src/core/locks/databaseLock.d.ts
 type DatabaseLockOptions = {
-    lockId: number;
-    timeoutMs?: number;
+  lockId: number;
+  timeoutMs?: number;
 };
 type AcquireDatabaseLockMode = 'Permanent' | 'Session';
 type AcquireDatabaseLockOptions = DatabaseLockOptions & {
-    mode?: AcquireDatabaseLockMode;
+  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>;
+  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>;
+  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;
+  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[];
+  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;
+  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[];
+  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>;
+  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[];
-};
-
+  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;
+  databaseType: T;
+  driverName: string;
 };
 /**
  * Accepts a `databaseType` (e.g. PostgreSQL, SQLite) and a `driverName`
@@ -1337,42 +1382,44 @@ declare function getDatabaseDriverName<T extends DatabaseType>(databaseDriverTyp
  * 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;
+  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;
+  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>;
+  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;
+  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>;
+  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;
+  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;
@@ -1380,118 +1427,159 @@ type InferDbClientFromConnection<C extends AnyConnection> = C extends Connection
 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>;
+  driverType?: ConnectionType['driverType'];
+  transactionOptions?: InferTransactionOptionsFromConnection<ConnectionType>;
 };
 type ConnectionFactory<ConnectionType extends AnyConnection = AnyConnection> = (options: ConnectionOptions<ConnectionType>) => ConnectionType;
 type WithConnectionOptions = {
-    readonly?: boolean;
+  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>;
+  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>;
+  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;
+  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;
+  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;
+  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;
+  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>;
+  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;
+  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;
+  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;
+  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'];
+  driverType: ConnectionType['driverType'];
+  dbClient: InferDbClientFromConnection<ConnectionType>;
+  connectionFactory: (options: {
     dbClient: InferDbClientFromConnection<ConnectionType>;
-    connectionFactory: (options: {
-        dbClient: InferDbClientFromConnection<ConnectionType>;
-    }) => 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: () => ConnectionType;
+  connectionOptions?: never;
 } : {
-    driverType: ConnectionType['driverType'];
-    getConnection: (options: ConnectionOptions) => ConnectionType;
-    connectionOptions: ConnectionOptions;
+  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;
+  getConnection: () => ConnectionType;
 };
 declare const createConnectionPool: <ConnectionType extends AnyConnection>(pool: CreateConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
-
+//#endregion
+//#region src/core/tracing/index.d.ts
+declare const tracer: {
+  (): void;
+  info(eventName: string, attributes?: Record<string, any>): void;
+  warn(eventName: string, attributes?: Record<string, any>): void;
+  log(eventName: string, attributes?: Record<string, any>): void;
+  error(eventName: string, attributes?: Record<string, any>): void;
+};
+type LogLevel = 'DISABLED' | 'INFO' | 'LOG' | 'WARN' | 'ERROR';
+declare const LogLevel: {
+  DISABLED: LogLevel;
+  INFO: LogLevel;
+  LOG: LogLevel;
+  WARN: LogLevel;
+  ERROR: LogLevel;
+};
+type LogType = 'CONSOLE';
+type LogStyle = 'RAW' | 'PRETTY';
+declare const LogStyle: {
+  RAW: LogStyle;
+  PRETTY: LogStyle;
+};
+//#endregion
+//#region src/core/index.d.ts
 type Dumbo<DriverType extends DatabaseDriverType = DatabaseDriverType, ConnectionType extends AnyConnection = AnyConnection> = ConnectionPool<ConnectionType>;
 type DumboConnectionOptions<DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver> = ExtractDumboDatabaseDriverOptions<DatabaseDriver> extends infer Options ? Options extends unknown ? {
-    driver?: DatabaseDriver;
-    driverType?: DatabaseDriver['driverType'];
+  driver?: DatabaseDriver;
+  driverType?: DatabaseDriver['driverType'];
 } & Omit<Options, 'driver' | 'driverType' | 'connectionString'> : never : never;
 declare module './sql' {
-    namespace SQL {
-        const columnN: typeof dumboSchema.column & {
-            type: typeof SQLColumnTypeTokensFactory;
-        };
-    }
+  namespace SQL {
+    const columnN: typeof dumboSchema.column & {
+      type: typeof SQLColumnTypeTokensFactory;
+    };
+  }
 }
-
+//#endregion
+//#region src/storage/all/connections/connectionString.d.ts
 type DatabaseConnectionString<DatabaseTypeName extends DatabaseType = DatabaseType, Format extends string = string> = Format & {
-    _databaseType: DatabaseTypeName;
+  _databaseType: DatabaseTypeName;
 };
 declare const parseConnectionString: (connectionString: DatabaseConnectionString | string) => DatabaseDriverTypeParts;
-
-export { type AnyDatabaseSchemaSchemaComponent as $, type AnyConnection as A, type AnyTypeValidationError as B, type Connection as C, type DefaultSQLColumnToken as D, type TypeValidationSuccess as E, type AnyDumboDatabaseDriver as F, type ExtractDumboDatabaseDriverOptions as G, type ExtractDumboTypeFromDriver as H, IndexURN as I, JSONSerializer as J, ANSISQLIdentifierQuote as K, ANSISQLParamPlaceholder as L, type MigratorOptions as M, type AcquireDatabaseLockMode as N, type AcquireDatabaseLockOptions as O, AdminShutdownError as P, type QueryResultRow as Q, type AllColumnReferences as R, SQLColumnTypeTokens as S, TableURN as T, type AllColumnReferencesInSchema as U, type AllColumnTypes as V, type AllColumnTypesInSchema as W, type AmbientConnectionPoolOptions as X, type AnyColumnSchemaComponent as Y, type AnyColumnTypeToken as Z, type AnyDatabaseSchemaComponent as _, SQLProcessor as a, type ExtractSQLTokenType as a$, type AnyDatabaseTransaction as a0, type AnyRelationshipDefinition as a1, type AnySQLProcessor as a2, type AnySchemaComponent as a3, type AnySchemaComponentOfType as a4, type AnyTableRelationshipDefinition as a5, type AnyTableRelationshipDefinitionWithColumns as a6, type AnyTableSchemaComponent as a7, AutoIncrementSQLColumnToken as a8, BatchCommandNoChangesError as a9, type CreateSingletonConnectionOptions as aA, type CreateTransientConnectionOptions as aB, DataError as aC, type DatabaseCapabilities as aD, type DatabaseConnectionString as aE, type DatabaseDriverName as aF, type DatabaseDriverTypeParts as aG, type DatabaseLock as aH, type DatabaseLockOptions as aI, type DatabaseSchemaComponent as aJ, type DatabaseSchemaSchemaComponent as aK, type DatabaseSchemaTables as aL, DatabaseSchemaURNType as aM, type DatabaseSchemas as aN, type DatabaseSchemasWithSingle as aO, type DatabaseType as aP, DatabaseURNType as aQ, type DbSQLExecutorOptions as aR, DeadlockError as aS, DefaultMapSQLParamValueOptions as aT, DumboDatabaseDriverRegistry as aU, DumboDatabaseMetadataRegistry as aV, type DumboSchemaComponentType as aW, ExclusionViolationError as aX, type ExtractAdditionalData as aY, type ExtractColumnNames as aZ, type ExtractColumnTypeName as a_, type BatchSQLCommandOptions as aa, BigIntegerToken as ab, BigSerialToken as ac, CheckViolationError as ad, type CollectReferencesErrors as ae, type CollectRelationshipErrors as af, type ColumnName as ag, type ColumnPath as ah, type ColumnPathToReference as ai, type ColumnReference as aj, type ColumnReferenceError as ak, type ColumnReferenceExistanceError as al, type ColumnReferenceTypeMismatchError as am, type ColumnSchemaComponent as an, type ColumnSchemaComponentOptions as ao, ColumnTypeToken as ap, ColumnURNType as aq, ConcurrencyError as ar, ConnectionError as as, type ConnectionFactory as at, type ConnectionPoolFactory as au, type CreateAlwaysNewConnectionPoolOptions as av, type CreateAmbientConnectionOptions as aw, type CreateBoundedConnectionPoolOptions as ax, type CreateConnectionOptions as ay, type CreateConnectionPoolOptions as az, type SQLProcessorContext as b, ParametrizedSQLBuilder as b$, type ExtractSchemaNames as b0, type ExtractTableNames as b1, ForeignKeyViolationError as b2, type FormatContext as b3, type FormatDatabaseValidationErrors as b4, type FormatRelationshipBlock as b5, type FormatSQLOptions as b6, type FormatSchemaLevel as b7, type FormatSingleError as b8, type FormatTableLevel as b9, JSONReplacers as bA, JSONReviver as bB, type JSONReviverContext as bC, JSONRevivers as bD, type JSONSerializeOptions as bE, type JSONSerializerOptions as bF, type JSONValueType as bG, type JSONValueTypeName as bH, type JavaScriptValueType as bI, type JavaScriptValueTypeName as bJ, type JavaScriptValueTypeToNameMap as bK, type Join as bL, LockNotAvailableError as bM, type LookupColumnType as bN, MIGRATIONS_LOCK_ID as bO, type MapSQLParamValue as bP, type MapSQLParamValueOptions as bQ, type MigrationRecord as bR, type MigrationStyle as bS, NoDatabaseLock as bT, type NoError as bU, type NormalizeColumnPath as bV, type NormalizeReference as bW, NotNullViolationError as bX, type NotNullableSQLColumnTokenProps as bY, type NullableSQLColumnTokenProps as bZ, type ParametrizedSQL as b_, type FormatValidationErrors as ba, type IndentErrors as bb, type IndexSchemaComponent as bc, IndexURNType as bd, type InferColumnType as be, type InferDatabaseSchemas as bf, type InferDbClientFromConnection as bg, type InferDriverDatabaseType as bh, type InferDriverTypeFromConnection as bi, type InferSchemaTables as bj, type InferTableRow as bk, type InferTableSchemaComponentColumns as bl, type InferTableSchemaComponentTypes as bm, type InferTransactionFromConnection as bn, type InferTransactionOptionsFromConnection as bo, type InferTransactionOptionsFromTransaction as bp, type InitTransaction as bq, InsufficientResourcesError as br, IntegerToken as bs, IntegrityConstraintViolationError as bt, InvalidOperationError as bu, JSONBToken as bv, JSONCodec as bw, type JSONCodecOptions as bx, type JSONDeserializeOptions as by, JSONReplacer as bz, type DumboConnectionOptions as c, type ValidateTable as c$, type ParseReferencePath as c0, QueryCanceledError as c1, RawSQL as c2, type RelationshipColumnsMismatchError as c3, type RelationshipDefinition as c4, type RelationshipReferencesLengthMismatchError as c5, type RelationshipType as c6, type RelationshipValidationError as c7, type ReleaseDatabaseLockOptions as c8, type RunSQLMigrationsResult as c9, type SingletonConnectionPoolOptions as cA, SystemError as cB, type TableColumnName as cC, type TableColumnNames as cD, type TableColumnType as cE, type TableColumns as cF, type TableRelationships as cG, type TableRowType as cH, type TableSchemaComponent as cI, TableURNType as cJ, TimestampToken as cK, TimestamptzToken as cL, type TransactionResult as cM, TransientDatabaseError as cN, UniqueConstraintError as cO, type ValidateColumnReference as cP, type ValidateColumnTypeMatch as cQ, type ValidateColumnsMatch as cR, type ValidateDatabaseSchema as cS, type ValidateDatabaseSchemas as cT, type ValidateDatabaseSchemasWithMessages as cU, type ValidateReference as cV, type ValidateReferences as cW, type ValidateRelationship as cX, type ValidateRelationshipColumns as cY, type ValidateRelationshipLength as cZ, type ValidateSchemaTables as c_, SQL as ca, type SQLArrayMode as cb, SQLColumnToken as cc, SQLColumnTypeTokensFactory as cd, type SQLCommandOptions as ce, type SQLDefaultTokens as cf, type SQLDefaultTokensTypes as cg, type SQLExecutor as ch, type SQLFormatterOptions as ci, SQLPlain as cj, type SQLProcessorOptions as ck, type SQLProcessorsReadonlyRegistry as cl, SQLProcessorsRegistry as cm, type SQLQueryOptions as cn, type SQLQueryResultColumnMapping as co, SQLToken as cp, SQLValueMapper as cq, type SchemaColumnName as cr, type SchemaComponentOptions as cs, type SchemaComponentType as ct, type SchemaTablesWithSingle as cu, SerialToken as cv, type SerializationCodec as cw, SerializationError as cx, type Serializer as cy, type SingletonClientConnectionPoolOptions as cz, type DumboDatabaseDriver as d, runSQLMigrations as d$, type ValidateTableRelationships as d0, VarcharToken as d1, type WithConnectionFactory as d2, type WithConnectionOptions as d3, type WithDatabaseTransactionFactory as d4, type WithSQLExecutor as d5, type Writable as d6, canHandleDriverWithConnectionString as d7, columnSchemaComponent as d8, combineMigrations as d9, findSchemaComponentsOfType as dA, formatSQL as dB, fromDatabaseDriverType as dC, getDatabaseDriverName as dD, getDatabaseMetadata as dE, getDatabaseType as dF, getDefaultDatabase as dG, getDefaultDatabaseAsync as dH, getDefaultMigratorOptionsFromRegistry as dI, getFormatter as dJ, indexSchemaComponent as dK, isSQL as dL, isSchemaComponentOfType as dM, jsonSerializer as dN, mapANSISQLParamPlaceholder as dO, mapColumnToBigint as dP, mapColumnToDate as dQ, mapColumnToJSON as dR, mapSQLIdentifier as dS, mapSQLParamValue as dT, mapSQLQueryResult as dU, mapSchemaComponentsOfType as dV, parseConnectionString as dW, registerDefaultMigratorOptions as dX, registerFormatter as dY, relationship as dZ, resolveDatabaseMetadata as d_, composeJSONReplacers as da, composeJSONRevivers as db, createAlwaysNewConnectionPool as dc, createAmbientConnection as dd, createAmbientConnectionPool as de, createBoundedConnectionPool as df, createConnection as dg, createConnectionPool as dh, createSingletonClientConnectionPool as di, createSingletonConnection as dj, createSingletonConnectionPool as dk, createTransientConnection as dl, databaseSchemaComponent as dm, databaseSchemaSchemaComponent as dn, defaultDatabaseLockOptions as dp, defaultProcessorsRegistry as dq, describeSQL as dr, dumboDatabaseDriverRegistry as ds, dumboDatabaseMetadataRegistry as dt, dumboSchema as du, executeInAmbientConnection as dv, executeInNewConnection as dw, executeInNewDbClient as dx, executeInTransaction as dy, filterSchemaComponentsOfType as dz, type ConnectionOptions as e, schemaComponent as e0, sqlExecutor as e1, sqlExecutorInAmbientConnection as e2, sqlExecutorInNewConnection as e3, sqlMigration as e4, tableSchemaComponent as e5, toDatabaseDriverType as e6, transactionFactoryWithAmbientConnection as e7, transactionFactoryWithAsyncAmbientConnection as e8, transactionFactoryWithDbClient as e9, transactionFactoryWithNewConnection as ea, SQLFormatter as f, type DatabaseMetadata as g, type DatabaseTransactionOptions as h, type DatabaseTransaction as i, type ConnectionPool as j, type JSONSerializationOptions as k, type DbSQLExecutor as l, DumboError as m, SQLArray as n, SQLIn as o, SQLIdentifier as p, SQLLiteral as q, type AnySQLToken as r, DatabaseURN as s, DatabaseSchemaURN as t, ColumnURN as u, type QueryResult as v, type SchemaComponent as w, type DatabaseDriverType as x, type Dumbo as y, type SQLMigration as z };
+//#endregion
+//#region src/storage/postgresql/core/schema/postgreSQLMetadata.d.ts
+declare const postgreSQLMetadata: DatabaseMetadata<true, true, true>;
+//#endregion
+//#region src/storage/sqlite/core/schema/sqliteMetadata.d.ts
+declare const sqliteMetadata: DatabaseMetadata<false, false, false>;
+//#endregion
+//#region src/storage/all/index.d.ts
+declare function dumbo<Driver extends AnyDumboDatabaseDriver>(options: ExtractDumboDatabaseDriverOptions<Driver> & {
+  driver: Driver;
+} & JSONSerializationOptions): ExtractDumboTypeFromDriver<Driver>;
+declare function dumbo<DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<DatabaseDriver> = DumboConnectionOptions<DatabaseDriver>>(options: ConnectionOptions & {
+  driver?: never;
+}): ExtractDumboTypeFromDriver<DatabaseDriver>;
+//#endregion
+export { transactionFactoryWithAsyncAmbientConnection as $, JSONCodecOptions as $a, mapDefaultSQLColumnProcessors as $i, ValidateTable as $n, NormalizeColumnPath as $r, executeInNewConnection as $t, CreateAmbientConnectionOptions as A, SQLColumnToken as Aa, mapSchemaComponentsOfType as Ai, CollectReferencesErrors as An, InferDatabaseSchemas as Ar, DatabaseLockOptions as At, WithConnectionOptions as B, SQLArrayMode as Ba, describeSQL as Bi, SchemaTablesWithSingle as Bn, AllColumnTypesInSchema as Br, getDefaultDatabase as Bt, createConnectionPool as C, JSONValueType as Ca, ExtractAdditionalData as Ci, NotNullViolationError as Cn, InferTableSchemaComponentTypes as Cr, combineMigrations as Ct, Connection as D, JavaScriptValueTypeToNameMap as Da, filterSchemaComponentsOfType as Di, TransientDatabaseError as Dn, TableURNType as Dr, AcquireDatabaseLockMode as Dt, AnyConnection as E, JavaScriptValueTypeName as Ea, SchemaComponentType as Ei, SystemError as En, TableURN as Er, runSQLMigrations as Et, InferDriverTypeFromConnection as F, TimestamptzToken as Fa, sqlMigration as Fi, DatabaseSchemasWithSingle as Fn, TableRowType as Fr, DatabaseCapabilities as Ft, AnyDatabaseTransaction as G, SQLLiteral as Ga, SQL as Gi, ValidateDatabaseSchemas as Gn, ColumnPath as Gr, DbSQLExecutor as Gt, createConnection as H, SQLDefaultTokensTypes as Ha, getFormatter as Hi, ValidateColumnTypeMatch as Hn, AnyTableRelationshipDefinition as Hr, resolveDatabaseMetadata as Ht, InferTransactionFromConnection as I, VarcharToken as Ia, FormatContext as Ii, NoError as In, Writable as Ir, DatabaseMetadata as It, InferTransactionOptionsFromTransaction as J, ParametrizedSQL as Ja, ExpandArrayProcessor as Ji, ValidateReferences as Jn, ExtractColumnNames as Jr, SQLExecutor as Jt, DatabaseTransaction as K, SQLPlain as Ka, isSQL as Ki, ValidateDatabaseSchemasWithMessages as Kn, ColumnPathToReference as Kr, DbSQLExecutorOptions as Kt, InferTransactionOptionsFromConnection as L, AnySQLToken as La, FormatSQLOptions as Li, RelationshipColumnsMismatchError as Ln, AllColumnReferences as Lr, DumboDatabaseMetadataRegistry as Lt, CreateSingletonConnectionOptions as M, SQLColumnTypeTokensFactory as Ma, MigrationRecord as Mi, ColumnReferenceError as Mn, InferTableRow as Mr, ReleaseDatabaseLockOptions as Mt, CreateTransientConnectionOptions as N, SerialToken as Na, MigrationStyle as Ni, ColumnReferenceExistanceError as Nn, TableColumnNames as Nr, defaultDatabaseLockOptions as Nt, ConnectionFactory as O, NotNullableSQLColumnTokenProps as Oa, findSchemaComponentsOfType as Oi, UniqueConstraintError as On, tableSchemaComponent as Or, AcquireDatabaseLockOptions as Ot, InferDbClientFromConnection as P, TimestampToken as Pa, SQLMigration as Pi, ColumnReferenceTypeMismatchError as Pn, TableColumnType as Pr, dumboSchema as Pt, transactionFactoryWithAmbientConnection as Q, JSONCodec as Qa, DefaultSQLColumnProcessors as Qi, ValidateSchemaTables as Qn, LookupColumnType as Qr, executeInAmbientConnection as Qt, InitTransaction as R, ExtractSQLTokenType as Ra, SQLFormatter as Ri, RelationshipReferencesLengthMismatchError as Rn, AllColumnReferencesInSchema as Rr, dumboDatabaseMetadataRegistry as Rt, createBoundedConnectionPool as S, JSONBToken as Sa, DumboSchemaComponentType as Si, LockNotAvailableError as Sn, InferTableSchemaComponentColumns as Sr, RunSQLMigrationsResult as St, createSingletonConnectionPool as T, JavaScriptValueType as Ta, SchemaComponentOptions as Ti, SerializationError as Tn, TableSchemaComponent as Tr, registerDefaultMigratorOptions as Tt, createSingletonConnection as U, SQLIdentifier as Ua, registerFormatter as Ui, ValidateColumnsMatch as Un, AnyTableRelationshipDefinitionWithColumns as Ur, BatchCommandNoChangesError as Ut, createAmbientConnection as V, SQLDefaultTokens as Va, formatSQL as Vi, ValidateColumnReference as Vn, AnyRelationshipDefinition as Vr, getDefaultDatabaseAsync as Vt, createTransientConnection as W, SQLIn as Wa, RawSQL as Wi, ValidateDatabaseSchema as Wn, ColumnName$1 as Wr, BatchSQLCommandOptions as Wt, WithDatabaseTransactionFactory as X, SerializationCodec as Xa, FormatIdentifierProcessor as Xi, ValidateRelationshipColumns as Xn, ExtractSchemaNames as Xr, SQLQueryResultColumnMapping as Xt, TransactionResult as Y, ParametrizedSQLBuilder as Ya, ExpandSQLInProcessor as Yi, ValidateRelationship as Yn, ExtractColumnTypeName as Yr, SQLQueryOptions as Yt, executeInTransaction as Z, Serializer as Za, MapLiteralProcessor as Zi, ValidateRelationshipLength as Zn, ExtractTableNames as Zr, WithSQLExecutor as Zt, CreateConnectionPoolOptions as _, BigIntegerToken as _a, ColumnURN as _i, ExclusionViolationError as _n, DatabaseSchemaTables as _r, dumboDatabaseDriverRegistry as _t, parseConnectionString as a, SQLProcessorOptions as aa, TableColumnName as ai, sqlExecutor as an, JSONRevivers as ao, FormatTableLevel as ar, DatabaseType as at, createAlwaysNewConnectionPool as b, DefaultSQLColumnToken as ba, AnySchemaComponent as bi, IntegrityConstraintViolationError as bn, databaseSchemaSchemaComponent as br, MIGRATIONS_LOCK_ID as bt, LogLevel as c, DefaultMapSQLParamValueOptions as ca, AnyTypeValidationError as ci, QueryResult as cn, JSONSerializer as co, Join as cr, getDatabaseDriverName as ct, tracer as d, SQLValueMapper as da, IndexURN as di, CheckViolationError as dn, composeJSONRevivers as do, DatabaseSchemas as dr, AnyDumboDatabaseDriver as dt, SQLProcessorsReadonlyRegistry as ea, NormalizeReference as ei, executeInNewDbClient as en, JSONDeserializeOptions as eo, ValidateTableRelationships as er, transactionFactoryWithDbClient as et, AmbientConnectionPoolOptions as f, mapANSISQLParamPlaceholder as fa, IndexURNType as fi, ConcurrencyError as fn, jsonSerializer as fo, DatabaseURN as fr, DumboDatabaseDriver as ft, CreateBoundedConnectionPoolOptions as g, AutoIncrementSQLColumnToken as ga, ColumnSchemaComponentOptions as gi, DumboError as gn, DatabaseSchemaSchemaComponent as gr, canHandleDriverWithConnectionString as gt, CreateAlwaysNewConnectionPoolOptions as h, AnyColumnTypeToken as ha, ColumnSchemaComponent as hi, DeadlockError as hn, AnyDatabaseSchemaSchemaComponent as hr, ExtractDumboTypeFromDriver as ht, DatabaseConnectionString as i, SQLProcessorContext as ia, SchemaColumnName as ii, mapSQLQueryResult as in, JSONReviverContext as io, FormatSingleError as ir, DatabaseDriverTypeParts as it, CreateConnectionOptions as j, SQLColumnTypeTokens as ja, schemaComponent as ji, CollectRelationshipErrors as jn, InferSchemaTables as jr, NoDatabaseLock as jt, ConnectionOptions as k, NullableSQLColumnTokenProps as ka, isSchemaComponentOfType as ki, schemaComponentURN as kn, InferColumnType as kr, DatabaseLock as kt, LogStyle as l, MapSQLParamValue as la, TypeValidationSuccess as li, QueryResultRow as ln, JSONSerializerOptions as lo, AnyDatabaseSchemaComponent as lr, getDatabaseType as lt, ConnectionPoolFactory as m, mapSQLParamValue as ma, AnyColumnSchemaComponent as mi, DataError as mn, databaseSchemaComponent as mr, ExtractDumboDatabaseDriverOptions as mt, sqliteMetadata as n, AnySQLProcessor as na, RelationshipDefinition as ni, mapColumnToDate as nn, JSONReplacers as no, FormatRelationshipBlock as nr, DatabaseDriverName as nt, Dumbo as o, ANSISQLIdentifierQuote as oa, TableRelationships as oi, sqlExecutorInAmbientConnection as on, JSONSerializationOptions as oo, FormatValidationErrors as or, InferDriverDatabaseType as ot, ConnectionPool as p, mapSQLIdentifier as pa, indexSchemaComponent as pi, ConnectionError as pn, DbClientSetup as po, DatabaseURNType as pr, DumboDatabaseDriverRegistry as pt, DatabaseTransactionOptions as q, SQLToken as qa, defaultProcessorsRegistry as qi, ValidateReference as qn, ColumnReference as qr, SQLCommandOptions as qt, postgreSQLMetadata as r, SQLProcessor as ra, RelationshipType as ri, mapColumnToJSON as rn, JSONReviver as ro, FormatSchemaLevel as rr, DatabaseDriverType as rt, DumboConnectionOptions as s, ANSISQLParamPlaceholder as sa, relationship as si, sqlExecutorInNewConnection as sn, JSONSerializeOptions as so, IndentErrors as sr, fromDatabaseDriverType as st, dumbo as t, SQLProcessorsRegistry as ta, ParseReferencePath as ti, mapColumnToBigint as tn, JSONReplacer as to, FormatDatabaseValidationErrors as tr, transactionFactoryWithNewConnection as tt, LogType as u, MapSQLParamValueOptions as ua, IndexSchemaComponent as ui, AdminShutdownError as un, composeJSONReplacers as uo, DatabaseSchemaComponent as ur, toDatabaseDriverType as ut, SingletonClientConnectionPoolOptions as v, BigSerialToken as va, ColumnURNType as vi, ForeignKeyViolationError as vn, DatabaseSchemaURN as vr, SchemaComponentMigrator as vt, createSingletonClientConnectionPool as w, JSONValueTypeName as wa, SchemaComponent as wi, QueryCanceledError as wn, TableColumns as wr, getDefaultMigratorOptionsFromRegistry as wt, createAmbientConnectionPool as x, IntegerToken as xa, AnySchemaComponentOfType as xi, InvalidOperationError as xn, AnyTableSchemaComponent as xr, MigratorOptions as xt, SingletonConnectionPoolOptions as y, ColumnTypeToken as ya, columnSchemaComponent as yi, InsufficientResourcesError as yn, DatabaseSchemaURNType as yr, migrationTableSchemaComponent as yt, WithConnectionFactory as z, SQLArray as za, SQLFormatterOptions as zi, RelationshipValidationError as zn, AllColumnTypes as zr, getDatabaseMetadata as zt };
+//# sourceMappingURL=index-BDSQvDH2.d.cts.map