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

package/dist/connectionString-B1wm0TFc.d.ts

@@ -1,1271 +0,0 @@
-interface ParametrizedSQL {
-    query: string;
-    params: unknown[];
-}
-interface ParametrizedSQLBuilder {
-    addSQL: (str: string) => ParametrizedSQLBuilder;
-    addParam(value: unknown): ParametrizedSQLBuilder;
-    addParams(values: unknown[]): ParametrizedSQLBuilder;
-    build: () => ParametrizedSQL;
-}
-declare const ParametrizedSQLBuilder: ({ mapParamPlaceholder, }: {
-    mapParamPlaceholder: (index: number, value: unknown) => string;
-}) => ParametrizedSQLBuilder;
-
-type ExtractSQLTokenType<T> = T extends (...args: never[]) => infer R ? R extends SQLToken ? R : never : T extends SQLToken ? T : never;
-type AnySQLToken = SQLToken<string, any>;
-type SQLToken<TSymbol extends string = string, TProps extends Omit<Record<string, unknown>, 'sqlTokenType'> | undefined = Omit<Record<string, unknown>, 'sqlTokenType'> | undefined> = {
-    sqlTokenType: TSymbol;
-} & (TProps extends undefined ? void : Omit<TProps, 'sqlTokenType'>);
-declare const SQLToken: {
-    <SQLTokenType extends AnySQLToken, TInput = Exclude<keyof SQLTokenType, "sqlTokenType"> extends never ? void : Omit<SQLTokenType, "sqlTokenType">>(sqlTokenType: SQLTokenType["sqlTokenType"], map?: (input: TInput) => Omit<SQLTokenType, "sqlTokenType">): {
-        from: (input: TInput) => SQLTokenType;
-        check: (token: unknown) => token is SQLTokenType;
-        type: SQLTokenType["sqlTokenType"];
-    };
-    check<SQLTokenType extends AnySQLToken>(token: unknown): token is SQLTokenType;
-};
-type SQLIdentifier = SQLToken<'SQL_IDENTIFIER', {
-    value: string;
-}>;
-declare const SQLIdentifier: {
-    from: (input: string) => SQLIdentifier;
-    check: (token: unknown) => token is SQLIdentifier;
-    type: "SQL_IDENTIFIER";
-};
-type SQLPlain = SQLToken<'SQL_RAW', {
-    value: string;
-}>;
-declare const SQLPlain: {
-    from: (input: string) => SQLPlain;
-    check: (token: unknown) => token is SQLPlain;
-    type: "SQL_RAW";
-};
-type SQLLiteral = SQLToken<'SQL_LITERAL', {
-    value: unknown;
-}>;
-declare const SQLLiteral: {
-    from: (input: unknown) => SQLLiteral;
-    check: (token: unknown) => token is SQLLiteral;
-    type: "SQL_LITERAL";
-};
-type SQLArray = SQLToken<'SQL_ARRAY', {
-    value: unknown[];
-}>;
-declare const SQLArray: {
-    from: (input: unknown[]) => SQLArray;
-    check: (token: unknown) => token is SQLArray;
-    type: "SQL_ARRAY";
-};
-type SQLIn = SQLToken<'SQL_IN', {
-    column: SQLIdentifier;
-    values: SQLArray;
-}>;
-declare const SQLIn: {
-    from: (input: {
-        column: string;
-        values: unknown[];
-    }) => SQLIn;
-    check: (token: unknown) => token is SQLIn;
-    type: "SQL_IN";
-};
-type SQLDefaultTokens = SQLIdentifier | SQLPlain | SQLLiteral | SQLArray;
-type SQLDefaultTokensTypes = SQLDefaultTokens['sqlTokenType'];
-
-type JSONValueType = Record<string, unknown> | Array<unknown> | string | number | boolean | null;
-type JSONValueTypeName = 'value_type:json:object' | 'value_type:json:array' | 'value_type:json:string' | 'value_type:json:number' | 'value_type:json:boolean' | 'value_type:json:null';
-type JavaScriptValueType = Record<string, unknown> | Array<unknown> | string | number | boolean | null | undefined | Date | bigint;
-type JavaScriptValueTypeName = 'value_type:js:object' | 'value_type:js:array' | 'value_type:js:string' | 'value_type:js:number' | 'value_type:js:boolean' | 'value_type:js:null' | 'value_type:js:undefined' | 'value_type:js:date' | 'value_type:js:bigint';
-type JavaScriptValueTypeToNameMap = {
-    [K in JavaScriptValueType as K extends Record<string, unknown> ? 'value_type:js:object' : K extends Array<unknown> ? 'value_type:js:array' : K extends string ? 'value_type:js:string' : K extends number ? 'value_type:js:number' : K extends boolean ? 'value_type:js:boolean' : K extends null ? 'value_type:js:null' : K extends undefined ? 'value_type:js:undefined' : K extends Date ? 'value_type:js:date' : K extends bigint ? 'value_type:js:bigint' : never]: K;
-};
-type ColumnTypeToken<JSValueTypeName extends JavaScriptValueTypeName = JavaScriptValueTypeName, ColumnTypeName extends string = string, TProps extends Omit<Record<string, unknown>, 'sqlTokenType'> | undefined = Omit<Record<string, unknown>, 'sqlTokenType'> | undefined, ValueType = undefined> = SQLToken<`SQL_COLUMN_${ColumnTypeName}`, TProps> & {
-    __brand: ValueType extends undefined ? JavaScriptValueTypeToNameMap[JSValueTypeName] : ValueType;
-    jsTypeName: JSValueTypeName;
-};
-declare const ColumnTypeToken: <SQLTokenType extends AnyColumnTypeToken, TInput = keyof Omit<SQLTokenType, "sqlTokenType" | "__brand" | "jsTypeName"> extends never ? void : Omit<SQLTokenType, "sqlTokenType" | "__brand" | "jsTypeName">>(sqlTokenType: SQLTokenType["sqlTokenType"], jsTypeName: SQLTokenType["jsTypeName"], map?: (input: TInput) => Omit<SQLTokenType, "sqlTokenType" | "__brand" | "jsTypeName">) => {
-    from: (input: TInput) => SQLTokenType;
-    check: (token: unknown) => token is SQLTokenType;
-    type: SQLTokenType["sqlTokenType"];
-};
-type AnyColumnTypeToken = ColumnTypeToken<any, string, any>;
-type SerialToken = ColumnTypeToken<'value_type:js:number', 'SERIAL'>;
-declare const SerialToken: {
-    from: (input: void) => SerialToken;
-    check: (token: unknown) => token is SerialToken;
-    type: "SQL_COLUMN_SERIAL";
-};
-type BigSerialToken = ColumnTypeToken<'value_type:js:bigint', 'BIGSERIAL'>;
-declare const BigSerialToken: {
-    from: (input: void) => BigSerialToken;
-    check: (token: unknown) => token is BigSerialToken;
-    type: "SQL_COLUMN_BIGSERIAL";
-};
-type IntegerToken = ColumnTypeToken<'value_type:js:number', 'INTEGER'>;
-declare const IntegerToken: {
-    from: (input: void) => IntegerToken;
-    check: (token: unknown) => token is IntegerToken;
-    type: "SQL_COLUMN_INTEGER";
-};
-type BigIntegerToken = ColumnTypeToken<'value_type:js:bigint', 'BIGINT'>;
-declare const BigIntegerToken: {
-    from: (input: void) => BigIntegerToken;
-    check: (token: unknown) => token is BigIntegerToken;
-    type: "SQL_COLUMN_BIGINT";
-};
-type JSONBToken<ValueType extends Record<string, unknown> = Record<string, unknown>> = ColumnTypeToken<'value_type:js:object', 'JSONB', undefined, ValueType>;
-declare const JSONBToken: {
-    type: string;
-    from: <ValueType extends Record<string, unknown> = Record<string, unknown>>() => JSONBToken<ValueType>;
-    check: <ValueType extends Record<string, unknown> = Record<string, unknown>>(token: unknown) => token is JSONBToken<ValueType>;
-};
-type TimestampToken = ColumnTypeToken<'value_type:js:date', 'TIMESTAMP'>;
-declare const TimestampToken: {
-    from: (input: void) => TimestampToken;
-    check: (token: unknown) => token is TimestampToken;
-    type: "SQL_COLUMN_TIMESTAMP";
-};
-type TimestamptzToken = ColumnTypeToken<'value_type:js:date', 'TIMESTAMPTZ'>;
-declare const TimestamptzToken: {
-    from: (input: void) => TimestamptzToken;
-    check: (token: unknown) => token is TimestamptzToken;
-    type: "SQL_COLUMN_TIMESTAMPTZ";
-};
-type VarcharToken = ColumnTypeToken<'value_type:js:string', 'VARCHAR', {
-    length: number | 'max';
-}>;
-declare const VarcharToken: {
-    from: (input: number | "max") => VarcharToken;
-    check: (token: unknown) => token is VarcharToken;
-    type: "SQL_COLUMN_VARCHAR";
-};
-type NotNullableSQLColumnTokenProps<ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string> = {
-    name: string;
-    type: ColumnType;
-    notNull: true;
-    unique?: boolean;
-    primaryKey?: boolean;
-    default?: ColumnType | SQLToken;
-} | {
-    name: string;
-    type: ColumnType;
-    notNull?: false;
-    unique?: boolean;
-    primaryKey: never;
-    default?: ColumnType | SQLToken;
-};
-type NullableSQLColumnTokenProps<ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string> = {
-    name: string;
-    type: ColumnType;
-    notNull?: false;
-    unique?: boolean;
-    primaryKey?: false;
-    default?: ColumnType | SQLToken;
-};
-type AutoIncrementSQLColumnToken = ColumnTypeToken<'value_type:js:bigint', 'AUTO_INCREMENT', {
-    primaryKey: boolean;
-    bigint?: boolean;
-}, bigint>;
-declare const AutoIncrementSQLColumnToken: {
-    from: (input: Omit<AutoIncrementSQLColumnToken, "sqlTokenType" | "__brand" | "jsTypeName">) => AutoIncrementSQLColumnToken;
-    check: (token: unknown) => token is AutoIncrementSQLColumnToken;
-    type: "SQL_COLUMN_AUTO_INCREMENT";
-};
-declare const SQLColumnTypeTokens: {
-    AutoIncrement: {
-        from: (input: Omit<AutoIncrementSQLColumnToken, "sqlTokenType" | "__brand" | "jsTypeName">) => AutoIncrementSQLColumnToken;
-        check: (token: unknown) => token is AutoIncrementSQLColumnToken;
-        type: "SQL_COLUMN_AUTO_INCREMENT";
-    };
-    BigInteger: {
-        from: (input: void) => BigIntegerToken;
-        check: (token: unknown) => token is BigIntegerToken;
-        type: "SQL_COLUMN_BIGINT";
-    };
-    BigSerial: {
-        from: (input: void) => BigSerialToken;
-        check: (token: unknown) => token is BigSerialToken;
-        type: "SQL_COLUMN_BIGSERIAL";
-    };
-    Integer: {
-        from: (input: void) => IntegerToken;
-        check: (token: unknown) => token is IntegerToken;
-        type: "SQL_COLUMN_INTEGER";
-    };
-    JSONB: {
-        type: string;
-        from: <ValueType extends Record<string, unknown> = Record<string, unknown>>() => JSONBToken<ValueType>;
-        check: <ValueType extends Record<string, unknown> = Record<string, unknown>>(token: unknown) => token is JSONBToken<ValueType>;
-    };
-    Serial: {
-        from: (input: void) => SerialToken;
-        check: (token: unknown) => token is SerialToken;
-        type: "SQL_COLUMN_SERIAL";
-    };
-    Timestamp: {
-        from: (input: void) => TimestampToken;
-        check: (token: unknown) => token is TimestampToken;
-        type: "SQL_COLUMN_TIMESTAMP";
-    };
-    Timestamptz: {
-        from: (input: void) => TimestamptzToken;
-        check: (token: unknown) => token is TimestamptzToken;
-        type: "SQL_COLUMN_TIMESTAMPTZ";
-    };
-    Varchar: {
-        from: (input: number | "max") => VarcharToken;
-        check: (token: unknown) => token is VarcharToken;
-        type: "SQL_COLUMN_VARCHAR";
-    };
-};
-type SQLColumnTypeTokens = {
-    AutoIncrement: AutoIncrementSQLColumnToken;
-    BigInteger: BigIntegerToken;
-    BigSerial: BigSerialToken;
-    Integer: IntegerToken;
-    JSONB: JSONBToken;
-    Serial: SerialToken;
-    Timestamp: TimestampToken;
-    Timestamptz: TimestamptzToken;
-    Varchar: VarcharToken;
-};
-declare const SQLColumnTypeTokensFactory: {
-    AutoIncrement: (input: Omit<AutoIncrementSQLColumnToken, "sqlTokenType" | "__brand" | "jsTypeName">) => AutoIncrementSQLColumnToken;
-    BigInteger: BigIntegerToken;
-    BigSerial: BigSerialToken;
-    Integer: IntegerToken;
-    JSONB: <ValueType extends Record<string, unknown> = Record<string, unknown>>() => JSONBToken<ValueType>;
-    Serial: SerialToken;
-    Timestamp: TimestampToken;
-    Timestamptz: TimestamptzToken;
-    Varchar: (input: number | "max") => VarcharToken;
-};
-type DefaultSQLColumnToken = AutoIncrementSQLColumnToken | SerialToken | BigSerialToken | IntegerToken | JSONBToken | BigIntegerToken | TimestampToken | TimestamptzToken | VarcharToken;
-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";
-};
-
-type MapSQLParamValue = (value: unknown, options?: MapSQLParamValueOptions) => unknown;
-interface MapSQLParamValueOptions {
-    mapBoolean?: (value: boolean) => unknown;
-    mapArray?: (array: unknown[], mapValue: MapSQLParamValue) => unknown[];
-    mapDate?: (value: Date) => unknown;
-    mapObject?: (value: object) => unknown;
-    mapBigInt?: (value: bigint) => unknown;
-    mapValue?: MapSQLParamValue;
-    mapPlaceholder?: (index: number, value: unknown) => string;
-    mapIdentifier?: (value: string) => string;
-}
-declare const ANSISQLParamPlaceholder = "?";
-declare const ANSISQLIdentifierQuote = "\"";
-declare const mapANSISQLParamPlaceholder: () => string;
-declare const mapSQLIdentifier: (value: string, options?: {
-    reservedWords: {
-        [key: string]: boolean;
-    };
-    quote?: string;
-}) => string;
-declare const DefaultMapSQLParamValueOptions: {
-    mapPlaceholder: () => string;
-    mapIdentifier: (value: string, options?: {
-        reservedWords: {
-            [key: string]: boolean;
-        };
-        quote?: string;
-    }) => string;
-};
-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, options?: MapSQLParamValueOptions): unknown;
-
-type SQLProcessorContext = {
-    mapper: SQLValueMapper;
-    builder: ParametrizedSQLBuilder;
-    processorsRegistry: SQLProcessorsReadonlyRegistry;
-};
-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;
-};
-declare const SQLProcessor: <Token extends AnySQLToken = AnySQLToken>(options: SQLProcessorOptions<Token>) => SQLProcessor<Token>;
-
-interface SQLProcessorsReadonlyRegistry {
-    get<Token extends AnySQLToken = AnySQLToken>(tokenType: Token['sqlTokenType']): SQLProcessor<Token> | null;
-    all(): ReadonlyMap<string, AnySQLProcessor>;
-}
-interface SQLProcessorsRegistry extends SQLProcessorsReadonlyRegistry {
-    register(...processor: AnySQLProcessor[]): SQLProcessorsRegistry;
-    register(processor: Record<string, AnySQLProcessor>): SQLProcessorsRegistry;
-}
-declare const SQLProcessorsRegistry: (options?: {
-    from: SQLProcessorsRegistry;
-}) => SQLProcessorsRegistry;
-
-declare global {
-    var defaultProcessorsRegistry: ReturnType<typeof SQLProcessorsRegistry>;
-}
-declare const defaultProcessorsRegistry: SQLProcessorsRegistry;
-
-type SQL = string & {
-    __brand: 'sql';
-};
-declare function SQL(strings: TemplateStringsArray, ...values: unknown[]): SQL;
-declare namespace SQL {
-    export var EMPTY: SQL;
-    export var concat: (...sqls: SQL[]) => SQL;
-    export var merge: (sqls: SQL[], separator?: string) => SQL;
-    export var format: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => ParametrizedSQL;
-    export var describe: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => string;
-    var _a: (column: string, values: unknown[]) => SQLIn;
-    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 const isSQL: (value: unknown) => value is SQL;
-
-type FormatSQLOptions = {
-    mapper?: MapSQLParamValueOptions;
-    processorsRegistry?: SQLProcessorsReadonlyRegistry;
-};
-type SQLFormatterOptions = Partial<Omit<SQLFormatter, 'valueMapper'>> & {
-    valueMapper?: MapSQLParamValueOptions;
-    processorsRegistry?: SQLProcessorsReadonlyRegistry;
-};
-interface SQLFormatter {
-    format: (sql: SQL | SQL[], context?: SQLProcessorContext) => ParametrizedSQL;
-    describe: (sql: SQL | SQL[], context?: SQLProcessorContext) => string;
-    valueMapper: SQLValueMapper;
-}
-declare const SQLFormatter: ({ format, describe, valueMapper: valueMapperOptions, processorsRegistry, }: SQLFormatterOptions) => SQLFormatter;
-declare global {
-    var dumboSQLFormatters: Record<string, SQLFormatter>;
-}
-declare const registerFormatter: (dialect: string, formatter: SQLFormatter) => void;
-declare const getFormatter: (dialect: string) => SQLFormatter;
-declare function formatSQL(sql: SQL | SQL[], formatter: SQLFormatter, context?: FormatSQLOptions): ParametrizedSQL;
-declare const describeSQL: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => string;
-
-type MigrationStyle = 'None' | 'CreateOrUpdate';
-type SQLMigration = {
-    name: string;
-    sqls: SQL[];
-};
-declare const sqlMigration: (name: string, sqls: SQL[]) => SQLMigration;
-type MigrationRecord = {
-    id: number;
-    name: string;
-    application: string;
-    sqlHash: string;
-    timestamp: Date;
-};
-
-type SchemaComponent<ComponentKey extends string = string, AdditionalData extends Exclude<Record<string, unknown>, 'schemaComponentKey' | 'components' | 'migrations' | 'addComponent' | 'addMigration'> | undefined = undefined> = {
-    schemaComponentKey: ComponentKey;
-    components: ReadonlyMap<string, SchemaComponent>;
-    migrations: ReadonlyArray<SQLMigration>;
-    addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
-    addMigration: (migration: SQLMigration) => void;
-} & Exclude<AdditionalData extends undefined ? {} : AdditionalData, 'schemaComponentKey' | 'components' | 'migrations' | 'addComponent' | 'addMigration'>;
-type ExtractAdditionalData<T> = T extends SchemaComponent<infer _ComponentType, infer Data> ? Data : never;
-type AnySchemaComponent = SchemaComponent<string, Record<string, any>>;
-type AnySchemaComponentOfType<ComponentType extends string = string> = SchemaComponent<ComponentType, any>;
-type SchemaComponentOptions<AdditionalOptions extends Record<string, unknown> = Record<string, unknown>> = {
-    migrations?: ReadonlyArray<SQLMigration>;
-    components?: ReadonlyArray<SchemaComponent>;
-} & Omit<AdditionalOptions, 'migrations' | 'components'>;
-type SchemaComponentType<Kind extends string = string> = `sc:${Kind}`;
-type DumboSchemaComponentType<Kind extends string = string> = SchemaComponentType<`dumbo:${Kind}`>;
-declare const schemaComponent: <const ComponentKey extends string = string>(key: ComponentKey, options: SchemaComponentOptions) => SchemaComponent<ComponentKey>;
-declare const isSchemaComponentOfType: <SchemaComponentOfType extends AnySchemaComponent = AnySchemaComponent>(component: AnySchemaComponent, prefix: string) => component is SchemaComponentOfType;
-declare const filterSchemaComponentsOfType: <T extends AnySchemaComponent>(components: ReadonlyMap<string, AnySchemaComponent>, prefix: string) => ReadonlyMap<string, T>;
-declare const mapSchemaComponentsOfType: <T extends AnySchemaComponent>(components: ReadonlyMap<string, AnySchemaComponent>, prefix: string, keyMapper?: (component: T) => string) => ReadonlyMap<string, T>;
-declare const findSchemaComponentsOfType: <T extends AnySchemaComponent>(root: AnySchemaComponent, prefix: string) => T[];
-
-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;
-}) => ColumnURN<ColumnName>;
-type ColumnSchemaComponent<ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string, ColumnName extends string = string> = SchemaComponent<ColumnURN<ColumnName>, Readonly<{
-    columnName: ColumnName;
-}>> & SQLColumnToken<ColumnType>;
-type AnyColumnSchemaComponent = ColumnSchemaComponent<any>;
-type ColumnSchemaComponentOptions<ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string> = Omit<SQLColumnToken<ColumnType>, 'name' | 'sqlTokenType'> & SchemaComponentOptions;
-declare const columnSchemaComponent: <const ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string, const TOptions extends ColumnSchemaComponentOptions<ColumnType> = ColumnSchemaComponentOptions<ColumnType>, const ColumnName extends string = string>(params: {
-    columnName: ColumnName;
-} & TOptions) => ColumnSchemaComponent<ColumnType, ColumnName> & (TOptions extends {
-    notNull: true;
-} | {
-    primaryKey: true;
-} ? {
-    notNull: true;
-} : {
-    notNull?: false;
-});
-
-type IndexSchemaComponent = SchemaComponent<IndexURN, Readonly<{
-    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;
-}) => IndexURN;
-declare const indexSchemaComponent: ({ indexName, columnNames, isUnique, ...migrationsOrComponents }: {
-    indexName: string;
-    columnNames: string[];
-    isUnique: boolean;
-} & SchemaComponentOptions) => IndexSchemaComponent;
-
-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;
-
-type KeysOfString<T extends Record<string, unknown>> = Extract<keyof T, string>;
-
-type TypeValidationResult<Valid extends boolean = boolean, Error = never> = Valid extends true ? {
-    valid: true;
-} : {
-    valid: false;
-    error: Error;
-};
-type TypeValidationError<Error> = TypeValidationResult<false, Error>;
-type TypeValidationSuccess = TypeValidationResult<true>;
-type AnyTypeValidationError = TypeValidationError<any>;
-type AnyTypeValidationResult = TypeValidationResult<boolean, any>;
-type AnyTypeValidationFailed<Results = AnyTypeValidationResult[]> = Results extends readonly [infer First, ...infer Rest] ? First extends {
-    valid: false;
-} ? true : Rest extends AnyTypeValidationResult[] ? AnyTypeValidationFailed<Rest> : false : false;
-type UnwrapTypeValidationErrors<Results extends readonly AnyTypeValidationResult[]> = Results extends readonly [infer First, ...infer Rest] ? First extends TypeValidationResult<false, infer E> ? Rest extends readonly AnyTypeValidationResult[] ? [E, ...UnwrapTypeValidationErrors<Rest>] : [E] : Rest extends readonly AnyTypeValidationResult[] ? UnwrapTypeValidationErrors<Rest> : [] : [];
-type FailOnFirstTypeValidationError<Validations extends readonly AnyTypeValidationResult[]> = Validations extends readonly [infer First, ...infer Rest] ? First extends AnyTypeValidationError ? First : Rest extends readonly AnyTypeValidationResult[] ? FailOnFirstTypeValidationError<Rest> : First : null;
-
-type GetTupleLength<T extends readonly unknown[]> = T['length'];
-type NotEmptyTuple<T extends readonly unknown[]> = GetTupleLength<T> extends 0 ? never : T;
-type HaveTuplesTheSameLength<T extends readonly unknown[], U extends readonly unknown[]> = GetTupleLength<T> extends GetTupleLength<U> ? true : false;
-type IsEmptyTuple<T extends readonly unknown[]> = T extends [] ? true : false;
-type IsNotEmptyTuple<T extends readonly unknown[]> = IsEmptyTuple<T> extends true ? false : true;
-type FilterNotExistingInUnion<Tuple extends readonly string[], Union extends string> = Tuple extends readonly [infer First, ...infer Rest] ? First extends Union ? [
-    ...FilterNotExistingInUnion<Rest extends readonly string[] ? Rest : [], Union>
-] : [
-    First,
-    ...FilterNotExistingInUnion<Rest extends readonly string[] ? Rest : [], Union>
-] : [];
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
-type UnionToTuple<T, L = LastOfUnion<T>> = [T] extends [never] ? [] : [...UnionToTuple<Exclude<T, L>>, L];
-type ZipTuplesCollectErrors<TupleA extends readonly unknown[], TupleB extends readonly unknown[], ValidateMap, Accumulated extends AnyTypeValidationError[] = []> = [TupleA, TupleB] extends [
-    readonly [infer FirstA, ...infer RestA],
-    readonly [infer FirstB, ...infer RestB]
-] ? FirstA extends keyof ValidateMap ? FirstB extends keyof ValidateMap[FirstA] ? ValidateMap[FirstA][FirstB] extends infer Result extends AnyTypeValidationError ? ZipTuplesCollectErrors<RestA, RestB, ValidateMap, [
-    ...Accumulated,
-    Result
-]> : ZipTuplesCollectErrors<RestA, RestB, ValidateMap, Accumulated> : ZipTuplesCollectErrors<RestA, RestB, ValidateMap, Accumulated> : ZipTuplesCollectErrors<RestA, RestB, ValidateMap, Accumulated> : Accumulated;
-type MapRecordCollectErrors<Record extends object, ValidateMap, Accumulated extends AnyTypeValidationError[] = [], Keys extends readonly unknown[] = UnionToTuple<keyof Record>> = Keys extends readonly [infer K, ...infer Rest] ? K extends keyof ValidateMap ? ValidateMap[K] extends infer Result extends AnyTypeValidationError ? MapRecordCollectErrors<Record, ValidateMap, [
-    ...Accumulated,
-    Result
-], Rest> : MapRecordCollectErrors<Record, ValidateMap, Accumulated, Rest> : MapRecordCollectErrors<Record, ValidateMap, Accumulated, Rest> : Accumulated;
-
-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 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 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 ColumnReference<SchemaName extends string = string, TableName extends string = string, ColumnName extends string = string> = {
-    schemaName: SchemaName;
-    tableName: TableName;
-    columnName: ColumnName;
-};
-type ColumnPathToReference<Reference extends ColumnPath = ColumnPath, CurrentSchema extends string = string, CurrentTable extends string = string> = NormalizeReference<Reference, CurrentSchema, CurrentTable> extends `${infer S}.${infer T}.${infer C}` ? {
-    schemaName: S;
-    tableName: T;
-    columnName: C;
-} : never;
-type ParseReferencePath<Path extends string> = Path extends `${infer Schema}.${infer Table}.${infer Column}` ? {
-    schema: Schema;
-    table: Table;
-    column: Column;
-} : never;
-type LookupColumnType<AllTypes, Path extends string> = ParseReferencePath<Path> extends {
-    schema: infer S;
-    table: infer T;
-    column: infer C;
-} ? S extends keyof AllTypes ? T extends keyof AllTypes[S] ? C extends keyof AllTypes[S][T] ? AllTypes[S][T][C] extends {
-    columnTypeName: infer TypeName;
-} ? TypeName : never : never : never : never : never;
-type RelationshipType = 'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many';
-type RelationshipDefinition<Columns extends string = string, Reference extends string = string, RelType extends RelationshipType = RelationshipType> = {
-    readonly columns: NotEmptyTuple<readonly Columns[]>;
-    readonly references: NotEmptyTuple<readonly Reference[]>;
-    readonly type: RelType;
-};
-type AnyTableRelationshipDefinition = RelationshipDefinition<any, any, any>;
-type AnyTableRelationshipDefinitionWithColumns<Columns extends string = string> = RelationshipDefinition<Columns, any, any>;
-type TableRelationships<Columns extends string = string> = Record<string, AnyTableRelationshipDefinitionWithColumns<Columns>>;
-declare const relationship: <const Columns extends readonly string[], const References extends readonly string[], const RelType extends RelationshipType = RelationshipType>(columns: Columns, references: References, type: RelType) => {
-    readonly columns: Columns;
-    readonly references: References;
-    readonly type: RelType;
-};
-type AnyRelationshipDefinition = RelationshipDefinition<any, any, any>;
-
-type Writable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-type InferColumnType<ColumnType> = ColumnType extends ColumnTypeToken<infer _JSType, infer _ColumnTypeName, infer _TProps, infer ValueType> ? ValueType : ColumnType;
-type TableColumnType<T extends AnyColumnSchemaComponent> = T extends ColumnSchemaComponent<infer ColumnType> ? T extends {
-    notNull: true;
-} | {
-    primaryKey: true;
-} ? InferColumnType<ColumnType> : InferColumnType<ColumnType> | null : unknown;
-type TableColumnNames<T extends AnyTableSchemaComponent> = Exclude<keyof T['columns'], keyof ReadonlyMap<string, AnyColumnSchemaComponent>>;
-type InferTableRow<Columns extends TableColumns> = Writable<{
-    [K in keyof Columns]: TableColumnType<Columns[K]>;
-}>;
-type TableRowType<T extends AnyTableSchemaComponent> = T extends TableSchemaComponent<infer Columns> ? InferTableRow<Columns> : never;
-type InferSchemaTables<T extends AnyDatabaseSchemaSchemaComponent> = T extends DatabaseSchemaSchemaComponent<infer Tables> ? Tables : never;
-type InferDatabaseSchemas<T extends AnyDatabaseSchemaComponent> = T extends DatabaseSchemaComponent<infer Schemas> ? Schemas : never;
-
-type TableURNType = 'sc:dumbo:table';
-declare const TableURNType: TableURNType;
-type TableURN = `${TableURNType}:${string}`;
-declare const TableURN: ({ name }: {
-    name: string;
-}) => TableURN;
-type TableColumns = Record<string, AnyColumnSchemaComponent>;
-type TableSchemaComponent<Columns extends TableColumns = TableColumns, TableName extends string = string, Relationships extends TableRelationships<keyof Columns & string> = {} & TableRelationships<keyof Columns & string>> = SchemaComponent<TableURN, Readonly<{
-    tableName: TableName;
-    columns: ReadonlyMap<string, AnyColumnSchemaComponent> & Columns;
-    primaryKey: TableColumnNames<TableSchemaComponent<Columns, TableName, Relationships>>[];
-    relationships: Relationships;
-    indexes: ReadonlyMap<string, IndexSchemaComponent>;
-    addColumn: (column: AnyColumnSchemaComponent) => AnyColumnSchemaComponent;
-    addIndex: (index: IndexSchemaComponent) => IndexSchemaComponent;
-}>>;
-type InferTableSchemaComponentTypes<T extends AnyTableSchemaComponent> = T extends TableSchemaComponent<infer Columns, infer TableName, infer Relationships> ? [Columns, TableName, Relationships] : never;
-type InferTableSchemaComponentColumns<T extends AnyTableSchemaComponent> = InferTableSchemaComponentTypes<T>[0];
-type AnyTableSchemaComponent = TableSchemaComponent<any, any, any>;
-declare const tableSchemaComponent: <const Columns extends TableColumns = TableColumns, const TableName extends string = string, const Relationships extends TableRelationships<keyof Columns & string> = {}>({ tableName, columns, primaryKey, relationships, ...migrationsOrComponents }: {
-    tableName: TableName;
-    columns?: Columns;
-    primaryKey?: TableColumnNames<TableSchemaComponent<Columns, TableName, Relationships>>[];
-    relationships?: Relationships;
-} & SchemaComponentOptions) => TableSchemaComponent<Columns, TableName, Relationships> & {
-    relationships: Relationships;
-};
-
-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;
-}) => DatabaseSchemaURN<SchemaName>;
-type DatabaseSchemaTables<Tables extends AnyTableSchemaComponent = AnyTableSchemaComponent> = Record<string, Tables>;
-type DatabaseSchemaSchemaComponent<Tables extends DatabaseSchemaTables = DatabaseSchemaTables, SchemaName extends string = string> = SchemaComponent<DatabaseSchemaURN<SchemaName>, Readonly<{
-    schemaName: SchemaName;
-    tables: ReadonlyMap<string, TableSchemaComponent> & Tables;
-    addTable: (table: string | TableSchemaComponent) => TableSchemaComponent;
-}>>;
-type AnyDatabaseSchemaSchemaComponent = DatabaseSchemaSchemaComponent<any, any>;
-declare const databaseSchemaSchemaComponent: <const Tables extends DatabaseSchemaTables = DatabaseSchemaTables, const SchemaName extends string = string>({ schemaName, tables, ...migrationsOrComponents }: {
-    schemaName: SchemaName;
-    tables?: Tables;
-} & SchemaComponentOptions) => DatabaseSchemaSchemaComponent<Tables, SchemaName>;
-
-type DatabaseURNType = 'sc:dumbo:database';
-declare const DatabaseURNType: DatabaseURNType;
-type DatabaseURN = `${DatabaseURNType}:${string}`;
-declare const DatabaseURN: ({ name }: {
-    name: string;
-}) => DatabaseURN;
-type DatabaseSchemas<Schemas extends AnyDatabaseSchemaSchemaComponent = AnyDatabaseSchemaSchemaComponent> = Record<string, Schemas>;
-type DatabaseSchemaComponent<Schemas extends DatabaseSchemas = DatabaseSchemas> = SchemaComponent<DatabaseURN, Readonly<{
-    databaseName: string;
-    schemas: ReadonlyMap<string, DatabaseSchemaSchemaComponent> & Schemas;
-    addSchema: (schema: string | DatabaseSchemaSchemaComponent) => DatabaseSchemaSchemaComponent;
-}>>;
-type AnyDatabaseSchemaComponent = DatabaseSchemaComponent<any>;
-declare const databaseSchemaComponent: <Schemas extends DatabaseSchemas = DatabaseSchemas>({ databaseName, schemas, ...migrationsOrComponents }: {
-    databaseName: string;
-    schemas?: Schemas;
-} & SchemaComponentOptions) => DatabaseSchemaComponent<Schemas>;
-
-type Join<T extends readonly string[], Sep extends string> = T extends readonly [
-    infer First extends string,
-    ...infer Rest extends readonly string[]
-] ? Rest extends readonly [] ? First : `${First}${Sep}${Join<Rest, Sep>}` : '';
-type IndentErrors<Messages extends readonly string[]> = Messages extends readonly [
-    infer First extends string,
-    ...infer Rest extends readonly string[]
-] ? [`  - ${First}`, ...IndentErrors<Rest>] : [];
-type ExtractSchemaFromReference<T extends string> = T extends `${infer Schema}.${string}.${string}` ? Schema : never;
-type ExtractTableFromReference<T extends string> = T extends `${string}.${infer Table}.${string}` ? Table : never;
-type ExtractColumnFromReference<T extends string> = T extends `${string}.${string}.${infer Column}` ? Column : never;
-type TupleLength<T extends readonly unknown[]> = T extends {
-    length: infer L;
-} ? L : never;
-type FormatSingleError<E> = E extends {
-    errorCode: 'reference_columns_mismatch';
-    invalidColumns: infer InvalidCols extends readonly string[];
-    availableColumns: infer AvailableCols extends readonly string[];
-} ? `Invalid columns: ${Join<InvalidCols, ', '>}. Available columns: ${Join<AvailableCols, ', '>}` : E extends {
-    errorCode: 'reference_length_mismatch';
-    columns: infer Cols extends readonly string[];
-    references: infer Refs extends readonly string[];
-} ? `Column count mismatch: ${TupleLength<Cols>} columns ([${Join<Cols, ', '>}]) but ${TupleLength<Refs>} references ([${Join<Refs, ', '>}])` : E extends {
-    errorCode: 'missing_schema';
-    reference: infer Ref extends string;
-} ? `Schema "${ExtractSchemaFromReference<Ref>}" does not exist (${Ref})` : E extends {
-    errorCode: 'missing_table';
-    reference: infer Ref extends string;
-} ? `Table "${ExtractTableFromReference<Ref>}" does not exist in schema "${ExtractSchemaFromReference<Ref>}" (${Ref})` : E extends {
-    errorCode: 'missing_column';
-    reference: infer Ref extends string;
-} ? `Column "${ExtractColumnFromReference<Ref>}" does not exist in table "${ExtractSchemaFromReference<Ref>}.${ExtractTableFromReference<Ref>}" (${Ref})` : E extends {
-    errorCode: 'type_mismatch';
-    reference: infer Ref extends string;
-    referenceType: infer RefType extends string;
-    columnTypeName: infer ColType extends string;
-} ? `Type mismatch: column type "${ColType}" does not match referenced column type "${RefType}" (${Ref})` : never;
-type FormatErrorMessages<Errors extends readonly unknown[]> = Errors extends readonly [
-    infer First,
-    ...infer Rest extends readonly unknown[]
-] ? [FormatSingleError<First>, ...FormatErrorMessages<Rest>] : [];
-type FormatRelationshipBlock<E> = E extends {
-    relationship: infer RelName extends string;
-    errors: infer Errors extends readonly unknown[];
-} ? Join<[
-    `Relationship "${RelName}":`,
-    ...IndentErrors<FormatErrorMessages<Errors>>
-], '\n'> : never;
-type IndentLine<Line extends string> = `  ${Line}`;
-type IndentRelationshipBlock<Block extends string> = Block extends `${infer FirstLine}\n${infer Rest}` ? `${IndentLine<FirstLine>}\n${IndentRelationshipBlock<Rest>}` : IndentLine<Block>;
-type FormatRelationshipBlocks<RelErrors extends readonly unknown[]> = RelErrors extends readonly [
-    infer First,
-    ...infer Rest extends readonly unknown[]
-] ? Rest extends readonly [] ? IndentRelationshipBlock<FormatRelationshipBlock<First>> : `${IndentRelationshipBlock<FormatRelationshipBlock<First>>}\n${FormatRelationshipBlocks<Rest>}` : '';
-type FormatTableLevel<E> = E extends {
-    table: infer TableName extends string;
-    errors: infer RelErrors extends readonly unknown[];
-} ? `Table "${TableName}":\n${FormatRelationshipBlocks<RelErrors>}` : never;
-type IndentTableBlock<Block extends string> = Block extends `${infer FirstLine}\n${infer Rest}` ? `  ${FirstLine}\n${IndentTableBlock<Rest>}` : `  ${Block}`;
-type FormatTableBlocks<TableErrors extends readonly unknown[]> = TableErrors extends readonly [
-    infer First,
-    ...infer Rest extends readonly unknown[]
-] ? Rest extends readonly [] ? IndentTableBlock<FormatTableLevel<First>> : `${IndentTableBlock<FormatTableLevel<First>>}\n${FormatTableBlocks<Rest>}` : '';
-type FormatSchemaLevel<E> = E extends {
-    schema: infer SchemaName extends string;
-    errors: infer TableErrors extends readonly unknown[];
-} ? `Schema "${SchemaName}":\n${FormatTableBlocks<TableErrors>}` : never;
-type FormatSchemaBlocks<SchemaErrors extends readonly unknown[]> = SchemaErrors extends readonly [
-    infer First,
-    ...infer Rest extends readonly unknown[]
-] ? Rest extends readonly [] ? FormatSchemaLevel<First> : `${FormatSchemaLevel<First>}\n${FormatSchemaBlocks<Rest>}` : '';
-type FormatDatabaseValidationErrors<Errors extends readonly unknown[]> = FormatSchemaBlocks<Errors>;
-type FormatValidationErrors<Result> = Result extends {
-    valid: false;
-    error: infer Errors extends readonly unknown[];
-} ? `Relationship validation errors:\n\n${FormatDatabaseValidationErrors<Errors>}` : never;
-
-type RelationshipColumnsMismatchError<ColumnPath extends SchemaColumnName = SchemaColumnName> = {
-    valid: false;
-    error: {
-        errorCode: 'reference_columns_mismatch';
-        invalidColumns: ColumnPath[];
-        availableColumns: ColumnPath[];
-    };
-};
-type RelationshipReferencesLengthMismatchError<ColumnPath extends SchemaColumnName = SchemaColumnName> = {
-    valid: false;
-    error: {
-        errorCode: 'reference_length_mismatch';
-        columns: ColumnPath[];
-        references: ColumnPath[];
-    };
-};
-type ColumnReferenceExistanceError<ErrorCode extends 'missing_schema' | 'missing_table' | 'missing_column' = 'missing_schema' | 'missing_table' | 'missing_column', ColumnPath extends SchemaColumnName = SchemaColumnName> = {
-    valid: false;
-    error: {
-        errorCode: ErrorCode;
-        reference: ColumnPath;
-    };
-};
-type ColumnReferenceTypeMismatchError<Reference extends SchemaColumnName = SchemaColumnName, ReferenceTypeName extends string = string, ColumnTypeName extends string = string> = {
-    valid: false;
-    error: {
-        errorCode: 'type_mismatch';
-        reference: Reference;
-        referenceType: ReferenceTypeName;
-        columnTypeName: ColumnTypeName;
-    };
-};
-type NoError = TypeValidationSuccess;
-type ColumnReferenceError = ColumnReferenceExistanceError | ColumnReferenceTypeMismatchError;
-type RelationshipValidationError = RelationshipColumnsMismatchError | RelationshipReferencesLengthMismatchError | ColumnReferenceError;
-type ValidateRelationshipLength<Rel extends AnyTableRelationshipDefinition> = IF<ALL<[
-    HaveTuplesTheSameLength<Rel['columns'], Rel['references']>,
-    IsNotEmptyTuple<Rel['columns']>,
-    IsNotEmptyTuple<Rel['references']>
-]>, TypeValidationSuccess, TypeValidationResult<false, {
-    errorCode: 'reference_length_mismatch';
-    columns: Rel['columns'];
-    references: Rel['references'];
-}>>;
-type ValidateRelationshipColumns<Relationship extends AnyTableRelationshipDefinition, ValidColumns extends TableColumns> = FilterNotExistingInUnion<Relationship['columns'], KeysOfString<ValidColumns>> extends infer InvalidColumns extends NotEmptyTuple<string[]> ? IF<AND<IsEmptyTuple<InvalidColumns>, IsNotEmptyTuple<Relationship['columns']>>, TypeValidationSuccess, TypeValidationResult<false, {
-    errorCode: 'reference_columns_mismatch';
-    invalidColumns: InvalidColumns;
-    availableColumns: KeysOfString<ValidColumns>;
-}>> : TypeValidationSuccess;
-type ValidateColumnReference<ColReference extends SchemaColumnName, Schemas extends DatabaseSchemas> = ColReference extends SchemaColumnName<infer SchemaName, infer TableName, infer ColumnName> ? SchemaName extends keyof Schemas ? TableName extends keyof Schemas[SchemaName]['tables'] ? Schemas[SchemaName]['tables'][TableName] extends TableSchemaComponent<infer Columns, infer _TableName, infer _Relationships> ? ColumnName extends keyof Columns ? Columns[ColumnName] : ColumnReferenceExistanceError<'missing_column', `${SchemaName}.${TableName}.${ColumnName}`> : never : ColumnReferenceExistanceError<'missing_table', `${SchemaName}.${TableName}.${ColumnName}`> : ColumnReferenceExistanceError<'missing_schema', `${SchemaName}.${TableName}.${ColumnName}`> : never;
-type ValidateColumnTypeMatch<RefColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string, ColumnType extends AnyColumnTypeToken | string = AnyColumnTypeToken | string, Reference extends SchemaColumnName = SchemaColumnName> = ColumnType extends ColumnTypeToken<infer _JsType, infer ColumnTypeName, infer _TProps> ? RefColumnType extends ColumnTypeToken<infer _JsType, infer RefColumnTypeName, infer _TProps> ? RefColumnTypeName extends ColumnTypeName ? TypeValidationSuccess : ColumnReferenceTypeMismatchError<Reference, RefColumnTypeName, ColumnTypeName> : RefColumnType extends ColumnTypeName ? TypeValidationSuccess : ColumnReferenceTypeMismatchError<Reference, Extract<RefColumnType, string>, ColumnTypeName> : RefColumnType extends ColumnTypeToken<infer _JsType, infer RefColumnTypeName, infer _TProps> ? RefColumnTypeName extends ColumnType ? TypeValidationSuccess : ColumnReferenceTypeMismatchError<Reference, RefColumnTypeName, Extract<ColumnType, string>> : RefColumnType extends ColumnType ? TypeValidationSuccess : ColumnReferenceTypeMismatchError<Reference, Extract<RefColumnType, string>, Extract<ColumnType, string>>;
-type ValidateColumnsMatch<ReferenceColumn extends AnyColumnSchemaComponent, Column extends AnyColumnSchemaComponent, references extends SchemaColumnName = SchemaColumnName> = Column extends ColumnSchemaComponent<infer ColumnType> ? ReferenceColumn extends ColumnSchemaComponent<infer RefColumnType> ? ValidateColumnTypeMatch<RefColumnType, ColumnType, references> : never : never;
-type ValidateReference<RefPath extends SchemaColumnName = SchemaColumnName, ColPath extends SchemaColumnName = SchemaColumnName, Schemas extends DatabaseSchemas = DatabaseSchemas> = ColPath extends SchemaColumnName<infer SchemaName, infer TableName, infer Column> ? ValidateColumnReference<RefPath, Schemas> extends infer RefColumn ? RefColumn extends AnyColumnSchemaComponent ? ValidateColumnsMatch<RefColumn, Schemas[SchemaName]['tables'][TableName]['columns'][Column], RefPath> : RefColumn extends {
-    valid: false;
-    error: infer E;
-} ? TypeValidationError<E> : never : never : never;
-type ValidateReferences<RefPath extends SchemaColumnName = SchemaColumnName, ColPath extends SchemaColumnName = SchemaColumnName, Schemas extends DatabaseSchemas = DatabaseSchemas> = ColPath extends SchemaColumnName<infer SchemaName, infer TableName, infer Column> ? ValidateColumnReference<RefPath, Schemas> extends infer RefColumn ? RefColumn extends AnyColumnSchemaComponent ? ValidateColumnsMatch<RefColumn, Schemas[SchemaName]['tables'][TableName]['columns'][Column], RefPath> : RefColumn extends {
-    valid: false;
-    error: infer E;
-} ? TypeValidationError<E> : never : never : never;
-type CollectReferencesErrors<Columns extends readonly SchemaColumnName[], References extends readonly SchemaColumnName[], _CurrentSchema extends string, _CurrentTable extends string, Schemas extends DatabaseSchemas = DatabaseSchemas, Errors extends AnyTypeValidationError[] = []> = ZipTuplesCollectErrors<References, Columns, {
-    [R in References[number]]: {
-        [C in Columns[number]]: ValidateReference<R, C, Schemas>;
-    };
-}, Errors>;
-type SchemaTablesWithSingle<Table extends AnyTableSchemaComponent> = Table extends TableSchemaComponent<infer _Columns, infer TableName, infer _FKs> ? DatabaseSchemaSchemaComponent<{
-    [K in TableName]: Table;
-}> : never;
-type DatabaseSchemasWithSingle<Schema extends AnyDatabaseSchemaSchemaComponent> = Schema extends DatabaseSchemaSchemaComponent<infer _Tables, infer _SchemaName> ? {
-    [K in _SchemaName]: Schema;
-} : never;
-type ValidateRelationship<Columns extends TableColumns, Relationship extends AnyTableRelationshipDefinitionWithColumns<Extract<keyof Columns, string>>, RelationshipName extends string, CurrentTableName extends string, Table extends AnyTableSchemaComponent = AnyTableSchemaComponent, Schema extends AnyDatabaseSchemaSchemaComponent = SchemaTablesWithSingle<Table>, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>> = FailOnFirstTypeValidationError<[
-    ValidateRelationshipLength<Relationship>,
-    ValidateRelationshipColumns<Relationship, Columns>,
-    CollectReferencesErrors<NormalizeColumnPath<Relationship['columns'], Schema['schemaName'], CurrentTableName>, NormalizeColumnPath<Relationship['references'], Schema['schemaName'], CurrentTableName>, Schema['schemaName'], CurrentTableName, Schemas> extends infer Results extends readonly AnyTypeValidationError[] ? IF<AnyTypeValidationFailed<Results>, TypeValidationError<UnwrapTypeValidationErrors<Results>>, TypeValidationSuccess> : TypeValidationSuccess
-]> extends infer Error extends AnyTypeValidationError ? TypeValidationError<{
-    relationship: RelationshipName;
-    errors: Error extends TypeValidationError<infer E> ? E extends readonly unknown[] ? E : [E] : never;
-}> : TypeValidationSuccess;
-type CollectRelationshipErrors<Columns extends TableColumns = TableColumns, Relationships extends TableRelationships<keyof Columns & string> = {} & TableRelationships<keyof Columns & string>, Table extends AnyTableSchemaComponent = AnyTableSchemaComponent, Schema extends AnyDatabaseSchemaSchemaComponent = SchemaTablesWithSingle<Table>, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>, Errors extends AnyTypeValidationError[] = []> = MapRecordCollectErrors<Relationships, {
-    [R in keyof Relationships]: ValidateRelationship<Columns, Relationships[R] extends AnyTableRelationshipDefinitionWithColumns<Extract<keyof Columns, string>> ? Relationships[R] : never, Extract<R, string>, Table['tableName'], Table, Schema, Schemas>;
-}, Errors>;
-type ValidateTableRelationships<Table extends AnyTableSchemaComponent, Schema extends AnyDatabaseSchemaSchemaComponent = SchemaTablesWithSingle<Table>, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>> = Table extends TableSchemaComponent<infer Columns, infer TableName, infer Relationships> ? keyof Relationships extends Extract<keyof Relationships, string> ? CollectRelationshipErrors<Columns, Relationships, Table, Schema, Schemas> extends infer Results ? AnyTypeValidationFailed<Results> extends true ? TypeValidationError<{
-    table: TableName;
-    errors: UnwrapTypeValidationErrors<Results extends readonly AnyTypeValidationError[] ? Results : never>;
-}> : Results : TypeValidationSuccess : TypeValidationSuccess : TypeValidationSuccess;
-type ValidateTable<Table extends AnyTableSchemaComponent, Schema extends AnyDatabaseSchemaSchemaComponent = SchemaTablesWithSingle<Table>, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>> = ValidateTableRelationships<Table, Schema, Schemas>;
-type ValidateSchemaTables<Tables extends Record<string, AnyTableSchemaComponent>, SchemaName extends string, Schema extends AnyDatabaseSchemaSchemaComponent, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>> = MapRecordCollectErrors<Tables, {
-    [TableName in keyof Tables]: ValidateTable<Tables[TableName], Schema, Schemas>;
-}> extends infer Results ? AnyTypeValidationFailed<Results> extends true ? TypeValidationError<{
-    schema: SchemaName;
-    errors: UnwrapTypeValidationErrors<Results extends readonly AnyTypeValidationError[] ? Results : never>;
-}> : TypeValidationSuccess : TypeValidationSuccess;
-type ValidateDatabaseSchema<Schema extends AnyDatabaseSchemaSchemaComponent, Schemas extends DatabaseSchemas = DatabaseSchemasWithSingle<Schema>> = Schema extends DatabaseSchemaSchemaComponent<infer Tables, infer SchemaName> ? ValidateSchemaTables<Tables, SchemaName, Schema, Schemas> : TypeValidationSuccess;
-type ValidateDatabaseSchemas<Schemas extends DatabaseSchemas> = MapRecordCollectErrors<Schemas, {
-    [SchemaName in keyof Schemas]: ValidateDatabaseSchema<Schemas[SchemaName], Schemas>;
-}> extends infer Results ? AnyTypeValidationFailed<Results> extends true ? TypeValidationError<UnwrapTypeValidationErrors<Results extends readonly AnyTypeValidationError[] ? Results : never>> : TypeValidationSuccess : TypeValidationSuccess;
-type ValidateDatabaseSchemasWithMessages<Schemas extends DatabaseSchemas> = FormatValidationErrors<ValidateDatabaseSchemas<Schemas>>;
-
-declare const DEFAULT_DATABASE_SCHEMA_NAME = "__default_database_schema__";
-declare function dumboDatabaseSchema<const Tables extends DatabaseSchemaTables = DatabaseSchemaTables>(tables: Tables): DatabaseSchemaSchemaComponent<Tables, typeof DEFAULT_DATABASE_SCHEMA_NAME>;
-declare function dumboDatabaseSchema<const Tables extends DatabaseSchemaTables = DatabaseSchemaTables, const SchemaName extends string = string>(schemaName: SchemaName, tables: Tables, options?: SchemaComponentOptions): DatabaseSchemaSchemaComponent<Tables, SchemaName>;
-declare namespace dumboDatabaseSchema {
-    var from: (schemaName: string | undefined, tableNames: string[]) => DatabaseSchemaSchemaComponent;
-    var defaultName: string;
-}
-type ValidatedDatabaseSchemaComponent<Schemas extends DatabaseSchemas = DatabaseSchemas> = ValidateDatabaseSchemas<Schemas> extends {
-    valid: true;
-} ? DatabaseSchemaComponent<Schemas> : ValidateDatabaseSchemas<Schemas> extends {
-    valid: false;
-    error: infer E;
-} ? {
-    valid: false;
-    error: E;
-} : DatabaseSchemaComponent<Schemas>;
-declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(schemas: Schemas): ValidatedDatabaseSchemaComponent<Schemas>;
-declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(schema: DatabaseSchemaSchemaComponent): ValidatedDatabaseSchemaComponent<Schemas>;
-declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string, schemas: Schemas, options?: SchemaComponentOptions): ValidatedDatabaseSchemaComponent<Schemas>;
-declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string, schema: AnyDatabaseSchemaSchemaComponent, options?: SchemaComponentOptions): ValidatedDatabaseSchemaComponent<Schemas>;
-declare namespace dumboDatabase {
-    var from: <Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string | undefined, schemaNames: string[]) => ValidatedDatabaseSchemaComponent<Schemas>;
-    var defaultName: string;
-}
-declare const dumboSchema: {
-    database: typeof dumboDatabase;
-    schema: typeof dumboDatabaseSchema;
-    table: <const Columns extends TableColumns = TableColumns, const TableName extends string = string, const Relationships extends TableRelationships<keyof Columns & string> = TableRelationships<keyof Columns & string>>(name: TableName, definition: {
-        columns?: Columns;
-        primaryKey?: TableColumnNames<TableSchemaComponent<Columns, TableName, Relationships>>[];
-        relationships?: Relationships;
-        indexes?: Record<string, IndexSchemaComponent>;
-    } & SchemaComponentOptions) => TableSchemaComponent<Columns, TableName, Relationships>;
-    column: <const ColumnType extends AnyColumnTypeToken | string = string | AnyColumnTypeToken, const TOptions extends SchemaComponentOptions & Omit<SQLColumnToken<ColumnType>, "name" | "type" | "sqlTokenType"> = Omit<ColumnSchemaComponentOptions<ColumnType>, "type">, const ColumnName extends string = string>(name: ColumnName, type: ColumnType, options?: TOptions) => ({
-        schemaComponentKey: `sc:dumbo:column:${ColumnName}`;
-        components: ReadonlyMap<string, SchemaComponent>;
-        migrations: ReadonlyArray<SQLMigration>;
-        addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
-        addMigration: (migration: SQLMigration) => void;
-    } & Readonly<{
-        columnName: ColumnName;
-    }> & {
-        sqlTokenType: "SQL_COLUMN";
-    } & Omit<{
-        name: string;
-        type: ColumnType;
-        notNull?: false;
-        unique?: boolean;
-        primaryKey: never;
-        default?: 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;
-};
-
-type DatabaseLockOptions = {
-    lockId: number;
-    timeoutMs?: number;
-};
-type AcquireDatabaseLockMode = 'Permanent' | 'Session';
-type AcquireDatabaseLockOptions = DatabaseLockOptions & {
-    mode?: AcquireDatabaseLockMode;
-};
-type ReleaseDatabaseLockOptions = DatabaseLockOptions;
-declare const defaultDatabaseLockOptions: Required<Omit<DatabaseLockOptions, 'lockId'>>;
-type DatabaseLock = {
-    acquire(execute: SQLExecutor, options: AcquireDatabaseLockOptions): Promise<void>;
-    tryAcquire(execute: SQLExecutor, options: AcquireDatabaseLockOptions): Promise<boolean>;
-    release(execute: SQLExecutor, options: ReleaseDatabaseLockOptions): Promise<boolean>;
-    withAcquire: <Result = unknown>(execute: SQLExecutor, handle: () => Promise<Result>, options: AcquireDatabaseLockOptions) => Promise<Result>;
-};
-declare const NoDatabaseLock: DatabaseLock;
-
-declare const MIGRATIONS_LOCK_ID = 999956789;
-declare global {
-    var defaultMigratorOptions: Record<DatabaseType, MigratorOptions>;
-}
-declare const registerDefaultMigratorOptions: (databaseType: DatabaseType, options: MigratorOptions) => void;
-declare const getDefaultMigratorOptionsFromRegistry: (databaseType: DatabaseType) => MigratorOptions;
-type MigratorOptions = {
-    schema?: {
-        migrationTable?: SchemaComponent;
-    };
-    lock?: {
-        databaseLock?: DatabaseLock;
-        options?: Omit<DatabaseLockOptions, 'lockId'> & Partial<Pick<DatabaseLockOptions, 'lockId'>>;
-    };
-    dryRun?: boolean | undefined;
-};
-declare const runSQLMigrations: (pool: Dumbo, migrations: ReadonlyArray<SQLMigration>, partialOptions?: Partial<MigratorOptions>) => Promise<void>;
-declare const combineMigrations: (...migration: Pick<SQLMigration, "sqls">[]) => SQL[];
-
-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;
-    getDatabaseNameOrDefault(connectionString: string): string;
-    createPool(options: DumboConnectionOptions<this>): DumboType;
-    canHandle(options: DumboConnectionOptions<this>): boolean;
-}
-type AnyDumboDatabaseDriver = DumboDatabaseDriver<AnyConnection, any>;
-type ExtractDumboDatabaseDriverOptions<DatabaseDriver> = DatabaseDriver extends DumboDatabaseDriver<any, infer O, any> ? O : never;
-type ExtractDumboTypeFromDriver<DatabaseDriver> = DatabaseDriver extends DumboDatabaseDriver<any, any, infer D> ? D : never;
-declare const canHandleDriverWithConnectionString: <DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<DatabaseDriver> = DumboConnectionOptions<DatabaseDriver>>(driver: DatabaseDriver["driverType"], tryParseConnectionString: (connectionString: string) => string | null) => (options: ConnectionOptions) => boolean;
-declare const DumboDatabaseDriverRegistry: () => {
-    register: <Driver extends AnyDumboDatabaseDriver>(driverType: Driver["driverType"], plugin: Driver | (() => Promise<Driver>)) => void;
-    tryResolve: <Driver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<Driver> = DumboConnectionOptions<Driver>>(options: ConnectionOptions) => Promise<Driver | null>;
-    tryGet: <Driver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<Driver> = DumboConnectionOptions<Driver>>(options: ConnectionOptions) => Driver | null;
-    has: (driverType: DatabaseDriverType) => boolean;
-    readonly databaseDriverTypes: DatabaseDriverType[];
-};
-declare global {
-    var dumboDatabaseDriverRegistry: ReturnType<typeof DumboDatabaseDriverRegistry>;
-}
-declare const dumboDatabaseDriverRegistry: {
-    register: <Driver extends AnyDumboDatabaseDriver>(driverType: Driver["driverType"], plugin: Driver | (() => Promise<Driver>)) => void;
-    tryResolve: <Driver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<Driver> = DumboConnectionOptions<Driver>>(options: ConnectionOptions) => Promise<Driver | null>;
-    tryGet: <Driver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, ConnectionOptions extends DumboConnectionOptions<Driver> = DumboConnectionOptions<Driver>>(options: ConnectionOptions) => Driver | null;
-    has: (driverType: DatabaseDriverType) => boolean;
-    readonly databaseDriverTypes: DatabaseDriverType[];
-};
-
-type DatabaseType = string;
-type DatabaseDriverName = string;
-type DatabaseDriverType<DatabaseTypeName extends DatabaseType = DatabaseType, DriverName extends DatabaseDriverName = DatabaseDriverName> = `${DatabaseTypeName}:${DriverName}`;
-type InferDriverDatabaseType<T extends string> = T extends `${infer DatabaseType}:${string}` ? DatabaseType : never;
-type DatabaseDriverTypeParts<T extends DatabaseType = DatabaseType> = {
-    databaseType: T;
-    driverName: string;
-};
-/**
- * Accepts a `databaseType` (e.g. PostgreSQL, SQLite) and a `driverName`
- * (the library name, e.g. pg, sqlite3) and combines them to a singular
- * `databaseDriverType` which can be used in database handling.
- */
-declare function toDatabaseDriverType<T extends DatabaseType>(databaseType: T, driverName: string): DatabaseDriverType<T>;
-/**
- * Accepts a fully formatted `driverType` and returns the broken down
- * `databaseType` and `driverName`.
- */
-declare function fromDatabaseDriverType<T extends DatabaseType>(databaseDriverType: DatabaseDriverType<T>): DatabaseDriverTypeParts<T>;
-/**
- * Accepts a fully formatted `databaseDriverType` and returns the `driverName`.
- */
-declare function getDatabaseDriverName<T extends DatabaseType>(databaseDriverType: DatabaseDriverType<T>): DatabaseDriverName;
-/**
- * Accepts a fully formatted `databaseDriverType` and returns the `databaseType`.
- */
-declare function getDatabaseType<T extends DatabaseType>(databaseDriverType: DatabaseDriverType<T>): DatabaseType;
-
-interface QueryResultRow {
-    [column: string]: any;
-}
-type QueryResult<Result extends QueryResultRow = QueryResultRow> = {
-    rowCount: number | null;
-    rows: Result[];
-};
-
-type JSONSerializerOptions = {
-    disableBigIntSerialization?: boolean;
-};
-type JSONSerializeOptions = {
-    replacer?: JSONReplacer;
-} & JSONSerializerOptions;
-type JSONDeserializeOptions = {
-    reviver?: JSONReviver;
-} & JSONSerializerOptions;
-type JSONObjectCodecOptions<SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions> = {
-    serializer?: JSONSerializer<SerializeOptions, DeserializeOptions>;
-} | {
-    serializerOptions?: JSONSerializerOptions;
-};
-declare const composeJSONReplacers: (...replacers: JSONReplacer[]) => JSONReplacer;
-declare const composeJSONRevivers: (...revivers: JSONReviver[]) => JSONReviver;
-type JSONReplacer = (this: any, key: string, value: any) => any;
-declare const JSONReplacer: (opts?: JSONSerializeOptions) => JSONReplacer | undefined;
-type JSONReviver = (this: any, key: string, value: any) => any;
-declare const JSONReviver: (opts?: JSONDeserializeOptions) => JSONReviver | undefined;
-declare const JSONReplacers: {
-    bigInt: JSONReplacer;
-};
-declare const JSONRevivers: {
-    bigInt: JSONReviver;
-};
-declare const jsonSerializer: (options?: JSONSerializerOptions) => JSONSerializer;
-interface JSONSerializer<SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions> extends Serializer<string, SerializeOptions, DeserializeOptions> {
-    serialize<T>(object: T, options?: SerializeOptions): string;
-    deserialize<T>(payload: string, options?: DeserializeOptions): T;
-}
-declare const JSONSerializer: JSONSerializer<JSONSerializeOptions, JSONDeserializeOptions>;
-declare const RawJSONSerializer: JSONSerializer<JSONSerializeOptions, JSONDeserializeOptions>;
-interface JSONObjectCodec<T, SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions> extends ObjectCodec<T, string> {
-    encode(object: T, options?: SerializeOptions): string;
-    decode(payload: string, options?: DeserializeOptions): T;
-}
-declare const JSONObjectCodec: <T, SerializeOptions = JSONSerializeOptions, DeserializeOptions = JSONDeserializeOptions>(options: JSONObjectCodecOptions<SerializeOptions, DeserializeOptions>) => JSONObjectCodec<T, SerializeOptions, DeserializeOptions>;
-
-interface Serializer<Payload, SerializeOptions = never, DeserializeOptions = SerializeOptions> {
-    serialize<T>(object: T, options?: SerializeOptions): Payload;
-    deserialize<T>(payload: Payload, options?: DeserializeOptions): T;
-}
-interface ObjectCodec<T, Payload> {
-    encode(object: T): Payload;
-    decode(payload: Payload): T;
-}
-
-declare const mapColumnToJSON: (column: string, options?: JSONDeserializeOptions) => {
-    [x: string]: (value: unknown) => unknown;
-};
-declare const mapColumnToBigint: (column: string) => {
-    [x: string]: (value: unknown) => unknown;
-};
-declare const mapSQLQueryResult: <T>(result: T, mapping: SQLQueryResultColumnMapping) => T;
-type SQLQueryResultColumnMapping = {
-    [column: string]: (value: unknown) => unknown;
-};
-type SQLQueryOptions = {
-    timeoutMs?: number;
-    mapping?: SQLQueryResultColumnMapping;
-};
-type SQLCommandOptions = {
-    timeoutMs?: number;
-    mapping?: SQLQueryResultColumnMapping;
-};
-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?: SQLCommandOptions): 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?: SQLCommandOptions): Promise<QueryResult<Result>[]>;
-}
-interface WithSQLExecutor {
-    execute: SQLExecutor;
-}
-declare const sqlExecutor: <DbClient = unknown, DbExecutor extends DbSQLExecutor = DbSQLExecutor>(sqlExecutor: DbExecutor, options: {
-    connect: () => Promise<DbClient>;
-    close?: (client: DbClient, error?: unknown) => Promise<void>;
-}) => SQLExecutor;
-declare const sqlExecutorInNewConnection: <ConnectionType extends Connection>(options: {
-    driverType: ConnectionType["driverType"];
-    connection: () => Promise<ConnectionType>;
-}) => SQLExecutor;
-declare const sqlExecutorInAmbientConnection: <ConnectionType extends Connection>(options: {
-    driverType: ConnectionType["driverType"];
-    connection: () => Promise<ConnectionType>;
-}) => SQLExecutor;
-declare const executeInNewDbClient: <DbClient = unknown, Result = unknown>(handle: (client: DbClient) => Promise<Result>, options: {
-    connect: () => Promise<DbClient>;
-    close?: (client: DbClient, error?: unknown) => Promise<void>;
-}) => Promise<Result>;
-declare const executeInNewConnection: <ConnectionType extends Connection, Result>(handle: (connection: ConnectionType) => Promise<Result>, options: {
-    connection: () => Promise<ConnectionType>;
-}) => Promise<Result>;
-declare const executeInAmbientConnection: <ConnectionType extends Connection, Result>(handle: (connection: ConnectionType) => Promise<Result>, options: {
-    connection: () => Promise<ConnectionType>;
-}) => Promise<Result>;
-
-interface DatabaseTransaction<ConnectionType extends AnyConnection = AnyConnection> extends WithSQLExecutor {
-    driverType: ConnectionType['driverType'];
-    connection: ConnectionType;
-    begin: () => Promise<void>;
-    commit: () => Promise<void>;
-    rollback: (error?: unknown) => Promise<void>;
-}
-type AnyDatabaseTransaction = DatabaseTransaction<any>;
-type DatabaseTransactionOptions = {
-    allowNestedTransactions?: boolean;
-};
-interface WithDatabaseTransactionFactory<ConnectionType extends AnyConnection = AnyConnection, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> {
-    transaction: (options?: TransactionOptionsType) => TransactionType;
-    withTransaction: <Result = never>(handle: (transaction: TransactionType) => Promise<TransactionResult<Result> | Result>, options?: TransactionOptionsType) => Promise<Result>;
-}
-type TransactionResult<Result> = {
-    success: boolean;
-    result: Result;
-};
-declare const executeInTransaction: <DatabaseTransactionType extends AnyDatabaseTransaction = AnyDatabaseTransaction, Result = void>(transaction: DatabaseTransactionType, handle: (transaction: DatabaseTransactionType) => Promise<TransactionResult<Result> | Result>) => Promise<Result>;
-declare const transactionFactoryWithDbClient: <ConnectionType extends AnyConnection = AnyConnection, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions>(connect: () => Promise<InferDbClientFromConnection<ConnectionType>>, initTransaction: (client: Promise<InferDbClientFromConnection<ConnectionType>>, options?: TransactionOptionsType & {
-    close: (client: InferDbClientFromConnection<ConnectionType>, error?: unknown) => Promise<void>;
-}) => TransactionType) => WithDatabaseTransactionFactory<ConnectionType, TransactionType, TransactionOptionsType>;
-declare const transactionFactoryWithNewConnection: <ConnectionType extends AnyConnection = AnyConnection, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions>(connect: () => ConnectionType) => WithDatabaseTransactionFactory<ConnectionType, TransactionType, TransactionOptionsType>;
-declare const transactionFactoryWithAmbientConnection: <ConnectionType extends AnyConnection = AnyConnection>(connect: () => ConnectionType) => WithDatabaseTransactionFactory<ConnectionType>;
-
-interface Connection<Self extends AnyConnection = AnyConnection, DriverType extends DatabaseDriverType = DatabaseDriverType, DbClient = unknown, TransactionType extends DatabaseTransaction<Self> = DatabaseTransaction<Self>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> extends WithSQLExecutor, WithDatabaseTransactionFactory<Self, TransactionType, TransactionOptionsType> {
-    driverType: DriverType;
-    open: () => Promise<DbClient>;
-    close: () => Promise<void>;
-}
-type AnyConnection = Connection<AnyConnection, DatabaseDriverType, unknown, AnyDatabaseTransaction, DatabaseTransactionOptions>;
-type InferDriverTypeFromConnection<C extends AnyConnection> = C extends Connection<any, infer DT, any, any, any> ? DT : never;
-type InferDbClientFromConnection<C extends AnyConnection> = C extends Connection<any, any, infer DC, any, any> ? DC : never;
-type InferTransactionFromConnection<C extends AnyConnection> = C extends Connection<any, any, any, infer DT, any> ? DT : never;
-type InferTransactionOptionsFromConnection<C extends AnyConnection> = C extends Connection<any, any, any, any, infer TO> ? TO : never;
-type ConnectionOptions<ConnectionType extends AnyConnection = AnyConnection> = {
-    driverType?: ConnectionType['driverType'];
-    transactionOptions?: InferTransactionOptionsFromConnection<ConnectionType>;
-};
-type ConnectionFactory<ConnectionType extends AnyConnection = AnyConnection> = (options: ConnectionOptions<ConnectionType>) => ConnectionType;
-interface WithConnectionFactory<ConnectionType extends AnyConnection = AnyConnection> {
-    connection: () => Promise<ConnectionType>;
-    withConnection: <Result = unknown>(handle: (connection: ConnectionType) => Promise<Result>) => Promise<Result>;
-}
-type InitTransaction<ConnectionType extends AnyConnection = AnyConnection, TreansactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> = (connection: () => ConnectionType) => (client: Promise<InferDbClientFromConnection<ConnectionType>>, options?: TransactionOptionsType & {
-    close: (client: InferDbClientFromConnection<ConnectionType>, error?: unknown) => Promise<void>;
-}) => TreansactionType;
-type CreateConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> = {
-    driverType: InferDriverTypeFromConnection<ConnectionType>;
-    connect: () => Promise<InferDbClientFromConnection<ConnectionType>>;
-    close: (client: InferDbClientFromConnection<ConnectionType>) => Promise<void>;
-    initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
-};
-type CreateAmbientConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> = {
-    driverType: InferDriverTypeFromConnection<ConnectionType>;
-    client: InferDbClientFromConnection<ConnectionType>;
-    initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
-};
-declare const createAmbientConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>>(options: CreateAmbientConnectionOptions<ConnectionType, Executor, TransactionType>) => ConnectionType;
-type CreateSingletonConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> = {
-    driverType: InferDriverTypeFromConnection<ConnectionType>;
-    connect: () => Promise<InferDbClientFromConnection<ConnectionType>>;
-    close: (client: InferDbClientFromConnection<ConnectionType>) => Promise<void>;
-    initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
-};
-declare const createSingletonConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>>(options: CreateSingletonConnectionOptions<ConnectionType, Executor, TransactionType>) => ConnectionType;
-type CreateTransientConnectionOptions<ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> = {
-    driverType: InferDriverTypeFromConnection<ConnectionType>;
-    open: () => Promise<InferDbClientFromConnection<ConnectionType>>;
-    close: () => Promise<void>;
-    initTransaction: InitTransaction<ConnectionType, TransactionType, TransactionOptionsType>;
-    executor: () => Executor;
-};
-declare const createTransientConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>>(options: CreateTransientConnectionOptions<ConnectionType, Executor, TransactionType>) => ConnectionType;
-declare const createConnection: <ConnectionType extends AnyConnection = AnyConnection, Executor extends DbSQLExecutor = DbSQLExecutor, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>>(options: CreateConnectionOptions<ConnectionType, Executor, TransactionType>) => ConnectionType;
-
-interface ConnectionPool<ConnectionType extends AnyConnection = AnyConnection, TransactionType extends DatabaseTransaction<ConnectionType> = DatabaseTransaction<ConnectionType>, TransactionOptionsType extends DatabaseTransactionOptions = DatabaseTransactionOptions> extends WithSQLExecutor, WithConnectionFactory<ConnectionType>, WithDatabaseTransactionFactory<ConnectionType, TransactionType, TransactionOptionsType> {
-    driverType: ConnectionType['driverType'];
-    close: () => Promise<void>;
-}
-type ConnectionPoolFactory<ConnectionPoolType extends ConnectionPool = ConnectionPool, ConnectionPoolOptions = unknown> = (options: ConnectionPoolOptions) => ConnectionPoolType;
-declare const createAmbientConnectionPool: <ConnectionType extends AnyConnection>(options: {
-    driverType: ConnectionType["driverType"];
-    connection: ConnectionType;
-}) => ConnectionPool<ConnectionType>;
-type CreateSingletonConnectionPoolOptions<ConnectionType extends AnyConnection> = {
-    driverType: ConnectionType['driverType'];
-    getConnection: () => ConnectionType;
-    connectionOptions?: never;
-};
-declare const createSingletonConnectionPool: <ConnectionType extends AnyConnection>(options: CreateSingletonConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
-type CreateSingletonClientPoolOptions<ConnectionType extends AnyConnection> = {
-    driverType: ConnectionType['driverType'];
-    dbClient: InferDbClientFromConnection<ConnectionType>;
-    connectionFactory: (options: {
-        dbClient: InferDbClientFromConnection<ConnectionType>;
-    }) => ConnectionType;
-};
-declare const createSingletonClientPool: <ConnectionType extends AnyConnection>(options: CreateSingletonClientPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
-type CreateAlwaysNewConnectionPoolOptions<ConnectionType extends AnyConnection, ConnectionOptions extends Record<string, unknown> | undefined = undefined> = ConnectionOptions extends undefined ? {
-    driverType: ConnectionType['driverType'];
-    getConnection: () => ConnectionType;
-    connectionOptions?: never;
-} : {
-    driverType: ConnectionType['driverType'];
-    getConnection: (options: ConnectionOptions) => ConnectionType;
-    connectionOptions: ConnectionOptions;
-};
-declare const createAlwaysNewConnectionPool: <ConnectionType extends AnyConnection, ConnectionOptions extends Record<string, unknown> | undefined = undefined>(options: CreateAlwaysNewConnectionPoolOptions<ConnectionType, ConnectionOptions>) => ConnectionPool<ConnectionType>;
-type CreateConnectionPoolOptions<ConnectionType extends AnyConnection> = Pick<ConnectionPool<ConnectionType>, 'driverType'> & Partial<ConnectionPool<ConnectionType>> & {
-    getConnection: () => ConnectionType;
-};
-declare const createConnectionPool: <ConnectionType extends AnyConnection>(pool: CreateConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
-
-type Dumbo<DriverType extends DatabaseDriverType = DatabaseDriverType, ConnectionType extends AnyConnection = AnyConnection> = ConnectionPool<ConnectionType>;
-type DumboConnectionOptions<DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver> = ExtractDumboDatabaseDriverOptions<DatabaseDriver> extends infer Options ? Options extends unknown ? {
-    driver?: DatabaseDriver;
-    driverType?: DatabaseDriver['driverType'];
-} & Omit<Options, 'driver' | 'driverType' | 'connectionString'> : never : never;
-declare module './sql' {
-    namespace SQL {
-        const columnN: typeof dumboSchema.column & {
-            type: typeof SQLColumnTypeTokensFactory;
-        };
-    }
-}
-
-type DatabaseConnectionString<DatabaseTypeName extends DatabaseType = DatabaseType, Format extends string = string> = Format & {
-    _databaseType: DatabaseTypeName;
-};
-declare const parseConnectionString: (connectionString: DatabaseConnectionString | string) => DatabaseDriverTypeParts;
-
-export { type CreateAlwaysNewConnectionPoolOptions as $, type AnySQLToken as A, type ConnectionOptions as B, type Connection as C, type DatabaseTransaction as D, type ExtractDumboTypeFromDriver as E, type ConnectionFactory as F, type InitTransaction as G, type CreateConnectionOptions as H, IndexURN as I, type CreateAmbientConnectionOptions as J, createAmbientConnection as K, type CreateSingletonConnectionOptions as L, type MigratorOptions as M, createSingletonConnection as N, type CreateTransientConnectionOptions as O, createTransientConnection as P, type QueryResultRow as Q, createConnection as R, SQLFormatter as S, TableURN as T, type ConnectionPoolFactory as U, createAmbientConnectionPool as V, type WithConnectionFactory as W, type CreateSingletonConnectionPoolOptions as X, createSingletonConnectionPool as Y, type CreateSingletonClientPoolOptions as Z, createSingletonClientPool as _, type DatabaseTransactionOptions as a, type ExtractColumnNames as a$, createAlwaysNewConnectionPool as a0, type CreateConnectionPoolOptions as a1, createConnectionPool as a2, type AnyDatabaseTransaction as a3, type WithDatabaseTransactionFactory as a4, type TransactionResult as a5, executeInTransaction as a6, transactionFactoryWithDbClient as a7, transactionFactoryWithNewConnection as a8, transactionFactoryWithAmbientConnection as a9, type DatabaseLockOptions as aA, type AcquireDatabaseLockMode as aB, type AcquireDatabaseLockOptions as aC, type ReleaseDatabaseLockOptions as aD, defaultDatabaseLockOptions as aE, type DatabaseLock as aF, NoDatabaseLock as aG, ColumnURNType as aH, type ColumnSchemaComponent as aI, type AnyColumnSchemaComponent as aJ, type ColumnSchemaComponentOptions as aK, columnSchemaComponent as aL, DatabaseURNType as aM, type DatabaseSchemas as aN, type DatabaseSchemaComponent as aO, type AnyDatabaseSchemaComponent as aP, databaseSchemaComponent as aQ, DatabaseSchemaURNType as aR, type DatabaseSchemaTables as aS, type DatabaseSchemaSchemaComponent as aT, type AnyDatabaseSchemaSchemaComponent as aU, databaseSchemaSchemaComponent as aV, IndexURNType as aW, type IndexSchemaComponent as aX, indexSchemaComponent as aY, type ExtractSchemaNames as aZ, type ExtractTableNames as a_, type DatabaseType as aa, type DatabaseDriverName as ab, type InferDriverDatabaseType as ac, type DatabaseDriverTypeParts as ad, toDatabaseDriverType as ae, fromDatabaseDriverType as af, getDatabaseDriverName as ag, getDatabaseType as ah, type ExtractDumboDatabaseDriverOptions as ai, canHandleDriverWithConnectionString as aj, DumboDatabaseDriverRegistry as ak, dumboDatabaseDriverRegistry as al, mapColumnToJSON as am, mapColumnToBigint as an, mapSQLQueryResult as ao, type SQLQueryResultColumnMapping as ap, type SQLQueryOptions as aq, type SQLCommandOptions as ar, type SQLExecutor as as, type WithSQLExecutor as at, sqlExecutor as au, sqlExecutorInNewConnection as av, sqlExecutorInAmbientConnection as aw, executeInNewDbClient as ax, executeInNewConnection as ay, executeInAmbientConnection as az, type ConnectionPool as b, type InferColumnType as b$, type ExtractColumnTypeName as b0, type AllColumnTypes as b1, type AllColumnReferences as b2, type AllColumnTypesInSchema as b3, type AllColumnReferencesInSchema as b4, type NormalizeReference as b5, type NormalizeColumnPath as b6, type ColumnName as b7, type TableColumnName as b8, type SchemaColumnName as b9, type CollectReferencesErrors as bA, type SchemaTablesWithSingle as bB, type DatabaseSchemasWithSingle as bC, type ValidateRelationship as bD, type CollectRelationshipErrors as bE, type ValidateTableRelationships as bF, type ValidateTable as bG, type ValidateSchemaTables as bH, type ValidateDatabaseSchema as bI, type ValidateDatabaseSchemas as bJ, type ValidateDatabaseSchemasWithMessages as bK, type Join as bL, type IndentErrors as bM, type FormatSingleError as bN, type FormatRelationshipBlock as bO, type FormatTableLevel as bP, type FormatSchemaLevel as bQ, type FormatDatabaseValidationErrors as bR, type FormatValidationErrors as bS, TableURNType as bT, type TableColumns as bU, type TableSchemaComponent as bV, type InferTableSchemaComponentTypes as bW, type InferTableSchemaComponentColumns as bX, type AnyTableSchemaComponent as bY, tableSchemaComponent as bZ, type Writable as b_, type ColumnPath as ba, type ColumnReference as bb, type ColumnPathToReference as bc, type ParseReferencePath as bd, type LookupColumnType as be, type RelationshipType as bf, type RelationshipDefinition as bg, type AnyTableRelationshipDefinition as bh, type AnyTableRelationshipDefinitionWithColumns as bi, type TableRelationships as bj, relationship as bk, type AnyRelationshipDefinition as bl, type RelationshipColumnsMismatchError as bm, type RelationshipReferencesLengthMismatchError as bn, type ColumnReferenceExistanceError as bo, type ColumnReferenceTypeMismatchError as bp, type NoError as bq, type ColumnReferenceError as br, type RelationshipValidationError as bs, type ValidateRelationshipLength as bt, type ValidateRelationshipColumns as bu, type ValidateColumnReference as bv, type ValidateColumnTypeMatch as bw, type ValidateColumnsMatch as bx, type ValidateReference as by, type ValidateReferences as bz, type DbSQLExecutor as c, ColumnTypeToken as c$, type TableColumnType as c0, type TableColumnNames as c1, type InferTableRow as c2, type TableRowType as c3, type InferSchemaTables as c4, type InferDatabaseSchemas as c5, dumboSchema as c6, MIGRATIONS_LOCK_ID as c7, registerDefaultMigratorOptions as c8, getDefaultMigratorOptionsFromRegistry as c9, RawJSONSerializer as cA, JSONObjectCodec as cB, type JSONObjectCodecOptions as cC, type JSONSerializerOptions as cD, type JSONSerializeOptions as cE, type JSONDeserializeOptions as cF, type FormatSQLOptions as cG, type SQLFormatterOptions as cH, registerFormatter as cI, getFormatter as cJ, formatSQL as cK, describeSQL as cL, type ParametrizedSQL as cM, ParametrizedSQLBuilder as cN, defaultProcessorsRegistry as cO, type SQLProcessorContext as cP, type AnySQLProcessor as cQ, type SQLProcessorOptions as cR, type SQLProcessorsReadonlyRegistry as cS, SQLProcessorsRegistry as cT, SQL as cU, isSQL as cV, type JSONValueType as cW, type JSONValueTypeName as cX, type JavaScriptValueType as cY, type JavaScriptValueTypeName as cZ, type JavaScriptValueTypeToNameMap as c_, runSQLMigrations as ca, combineMigrations as cb, type ExtractAdditionalData as cc, type AnySchemaComponent as cd, type AnySchemaComponentOfType as ce, type SchemaComponentOptions as cf, type SchemaComponentType as cg, type DumboSchemaComponentType as ch, schemaComponent as ci, isSchemaComponentOfType as cj, filterSchemaComponentsOfType as ck, mapSchemaComponentsOfType as cl, findSchemaComponentsOfType as cm, type MigrationStyle as cn, sqlMigration as co, type MigrationRecord as cp, type Serializer as cq, type ObjectCodec as cr, composeJSONReplacers as cs, composeJSONRevivers as ct, JSONReplacer as cu, JSONReplacers as cv, JSONReviver as cw, JSONRevivers as cx, JSONSerializer as cy, jsonSerializer as cz, type DumboDatabaseDriver as d, type AnyColumnTypeToken as d0, SerialToken as d1, BigSerialToken as d2, IntegerToken as d3, BigIntegerToken as d4, JSONBToken as d5, TimestampToken as d6, TimestamptzToken as d7, VarcharToken as d8, type NotNullableSQLColumnTokenProps as d9, type NullableSQLColumnTokenProps as da, SQLColumnToken as db, AutoIncrementSQLColumnToken as dc, SQLColumnTypeTokens as dd, SQLColumnTypeTokensFactory as de, type DefaultSQLColumnToken as df, SQLToken as dg, type ExtractSQLTokenType as dh, SQLPlain as di, type SQLDefaultTokens as dj, type SQLDefaultTokensTypes as dk, SQLValueMapper as dl, type MapSQLParamValue as dm, type MapSQLParamValueOptions as dn, ANSISQLParamPlaceholder as dp, ANSISQLIdentifierQuote as dq, mapANSISQLParamPlaceholder as dr, mapSQLIdentifier as ds, DefaultMapSQLParamValueOptions as dt, mapSQLParamValue as du, type DatabaseConnectionString as dv, parseConnectionString as dw, type Dumbo as e, type DumboConnectionOptions as f, SQLProcessor as g, SQLArray as h, SQLIn as i, SQLIdentifier as j, SQLLiteral as k, DatabaseURN as l, DatabaseSchemaURN as m, ColumnURN as n, type SchemaComponent as o, type SQLMigration as p, type DatabaseDriverType as q, type QueryResult as r, type AnyTypeValidationError as s, type TypeValidationSuccess as t, type AnyDumboDatabaseDriver as u, type AnyConnection as v, type InferDriverTypeFromConnection as w, type InferDbClientFromConnection as x, type InferTransactionFromConnection as y, type InferTransactionOptionsFromConnection as z };