rake-db 2.5.0 → 2.7.0

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-import { ColumnsShape, Db as Db$1, ColumnType, EnumColumn, ColumnTypes, Adapter, DbResult, DefaultColumnTypes, TransactionAdapter, QueryLogObject, IndexColumnOptions, IndexOptions, ForeignKeyOptions, TextColumn, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, AdapterOptions, QueryLogOptions } from 'pqb';
-import { EmptyObject, RawExpression, ColumnTypesBase, raw, MaybeArray } from 'orchid-core';
+import * as pqb from 'pqb';
+import { ColumnsShape, Db as Db$1, ColumnType, EnumColumn, Adapter, DefaultColumnTypes, DbResult, TransactionAdapter, QueryLogObject, IndexColumnOptions, IndexOptions, ForeignKeyOptions, TextColumn, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, AdapterOptions, QueryLogOptions } from 'pqb';
+import * as orchid_core from 'orchid-core';
+import { ColumnTypesBase, EmptyObject, RawExpression, raw, MaybeArray } from 'orchid-core';
 
 type CreateTableResult<Table extends string, Shape extends ColumnsShape> = {
     table: Db$1<Table, Shape>;
@@ -29,7 +31,7 @@ declare const tableChangeMethods: {
     rename(name: string): RakeDbAst.ChangeTableItem.Rename;
     enum(this: ColumnTypesBase, name: string): EnumColumn<string, [string, ...string[]]>;
 };
-type TableChanger = MigrationColumnTypes & TableChangeMethods;
+type TableChanger<CT extends ColumnTypesBase> = MigrationColumnTypes<CT> & TableChangeMethods;
 type TableChangeData = Record<string, RakeDbAst.ChangeTableItem.Column | RakeDbAst.ChangeTableItem.Rename | Change | EmptyObject>;
 
 type DropMode = 'CASCADE' | 'RESTRICT';
@@ -40,20 +42,20 @@ type TableOptions = {
     snakeCase?: boolean;
 };
 type TextColumnCreator = () => TextColumn;
-type MigrationColumnTypes = Omit<ColumnTypes, 'text' | 'string' | 'enum'> & {
+type MigrationColumnTypes<CT extends ColumnTypesBase> = Omit<CT, 'text' | 'string' | 'enum'> & {
     text: TextColumnCreator;
     string: TextColumnCreator;
     citext: TextColumnCreator;
     enum: (name: string) => EnumColumn;
 };
-type ColumnsShapeCallback<Shape extends ColumnsShape = ColumnsShape> = (t: MigrationColumnTypes & {
+type ColumnsShapeCallback<CT extends ColumnTypesBase, Shape extends ColumnsShape = ColumnsShape> = (t: MigrationColumnTypes<CT> & {
     raw: typeof raw;
 }) => Shape;
 type ChangeTableOptions = {
     snakeCase?: boolean;
     comment?: string | [string, string] | null;
 };
-type ChangeTableCallback = (t: TableChanger) => TableChangeData;
+type ChangeTableCallback<CT extends ColumnTypesBase> = (t: TableChanger<CT>) => TableChangeData;
 type ColumnComment = {
     column: string;
     comment: string | null;
@@ -62,7 +64,7 @@ type SilentQueries = {
     silentQuery: Adapter['query'];
     silentArrays: Adapter['arrays'];
 };
-type Migration = DbResult<DefaultColumnTypes> & MigrationBase & {
+type Migration<CT extends ColumnTypesBase = DefaultColumnTypes> = DbResult<CT> & MigrationBase<CT> & {
     adapter: SilentQueries;
 };
 type ConstraintArg = {
@@ -76,22 +78,23 @@ type ConstraintArg = {
     check?: RawExpression;
     dropMode?: DropMode;
 };
-declare const createMigrationInterface: (tx: TransactionAdapter, up: boolean, options: RakeDbConfig) => Migration;
-declare class MigrationBase {
+declare const createMigrationInterface: <CT extends ColumnTypesBase>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<CT>) => Migration;
+declare class MigrationBase<CT extends ColumnTypesBase> {
     adapter: TransactionAdapter;
     log?: QueryLogObject;
     up: boolean;
     options: RakeDbConfig;
     migratedAsts: RakeDbAst[];
-    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, options: TableOptions, fn: ColumnsShapeCallback<Shape>): Promise<CreateTableResult<Table, Shape>>;
-    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, fn: ColumnsShapeCallback<Shape>): Promise<CreateTableResult<Table, Shape>>;
-    dropTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, options: TableOptions, fn: ColumnsShapeCallback<Shape>): Promise<CreateTableResult<Table, Shape>>;
-    dropTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, fn: ColumnsShapeCallback<Shape>): Promise<CreateTableResult<Table, Shape>>;
-    changeTable(tableName: string, options: ChangeTableOptions, fn?: ChangeTableCallback): Promise<void>;
-    changeTable(tableName: string, fn: ChangeTableCallback): Promise<void>;
+    columnTypes: CT;
+    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, options: TableOptions, fn: ColumnsShapeCallback<CT, Shape>): Promise<CreateTableResult<Table, Shape>>;
+    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, fn: ColumnsShapeCallback<CT, Shape>): Promise<CreateTableResult<Table, Shape>>;
+    dropTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, options: TableOptions, fn: ColumnsShapeCallback<CT, Shape>): Promise<CreateTableResult<Table, Shape>>;
+    dropTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, fn: ColumnsShapeCallback<CT, Shape>): Promise<CreateTableResult<Table, Shape>>;
+    changeTable(tableName: string, options: ChangeTableOptions, fn?: ChangeTableCallback<CT>): Promise<void>;
+    changeTable(tableName: string, fn: ChangeTableCallback<CT>): Promise<void>;
     renameTable(from: string, to: string): Promise<void>;
-    addColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes) => ColumnType): Promise<void>;
-    dropColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes) => ColumnType): Promise<void>;
+    addColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes<CT>) => ColumnType): Promise<void>;
+    dropColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes<CT>) => ColumnType): Promise<void>;
     addIndex(tableName: string, columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): Promise<void>;
     dropIndex(tableName: string, columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): Promise<void>;
     addForeignKey(tableName: string, columns: [string, ...string[]], foreignTable: string, foreignColumns: [string, ...string[]], options?: ForeignKeyOptions): Promise<void>;
@@ -113,8 +116,8 @@ declare class MigrationBase {
     dropExtension(name: string, options?: Omit<RakeDbAst.Extension, 'type' | 'action' | 'name' | 'values'>): Promise<void>;
     createEnum(name: string, values: [string, ...string[]], options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values' | 'schema'>): Promise<void>;
     dropEnum(name: string, values: [string, ...string[]], options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values' | 'schema'>): Promise<void>;
-    createDomain(name: string, fn: (t: ColumnTypes) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
-    dropDomain(name: string, fn: (t: ColumnTypes) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
+    createDomain(name: string, fn: (t: CT) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
+    dropDomain(name: string, fn: (t: CT) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
     createView(name: string, options: RakeDbAst.ViewOptions, sql: string | RawExpression): Promise<void>;
     createView(name: string, sql: string | RawExpression): Promise<void>;
     dropView(name: string, options: RakeDbAst.ViewOptions, sql: string | RawExpression): Promise<void>;
@@ -259,12 +262,22 @@ declare namespace RakeDbAst {
 }
 
 type Db = DbResult<DefaultColumnTypes>;
-type RakeDbConfig = {
+type InputRakeDbConfig<CT extends ColumnTypesBase> = Partial<Omit<RakeDbConfig<CT>, 'columnTypes'>> & ({
+    columnTypes?: CT | ((t: DefaultColumnTypes) => CT);
+} | {
+    baseTable?: new () => {
+        columnTypes: CT;
+        snakeCase?: boolean;
+    };
+});
+type RakeDbConfig<CT extends ColumnTypesBase = DefaultColumnTypes> = {
+    columnTypes: CT;
     basePath: string;
+    dbScript: string;
     migrationsPath: string;
     migrationsTable: string;
     snakeCase: boolean;
-    commands: Record<string, (options: AdapterOptions[], config: RakeDbConfig, args: string[]) => Promise<void>>;
+    commands: Record<string, (options: AdapterOptions[], config: RakeDbConfig<CT>, args: string[]) => Promise<void>>;
     import(path: string): Promise<void>;
     noPrimaryKey?: NoPrimaryKeyOption;
     appCodeUpdater?: AppCodeUpdater;
@@ -282,27 +295,144 @@ type AppCodeUpdater = (params: {
     logger: QueryLogOptions['logger'];
 }) => Promise<void>;
 
-declare const createDb: (arg: MaybeArray<AdapterOptions>, config: RakeDbConfig) => Promise<void>;
+declare const createDb: <CT extends ColumnTypesBase>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>) => Promise<void>;
 declare const dropDb: (arg: MaybeArray<AdapterOptions>) => Promise<void>;
-declare const resetDb: (arg: MaybeArray<AdapterOptions>, config: RakeDbConfig) => Promise<void>;
+declare const resetDb: <CT extends ColumnTypesBase>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>) => Promise<void>;
 
-declare const writeMigrationFile: (config: RakeDbConfig, version: string, name: string, content: string) => Promise<void>;
-declare const generate: (config: RakeDbConfig, args: string[]) => Promise<void>;
+declare const writeMigrationFile: <CT extends ColumnTypesBase>(config: RakeDbConfig<CT>, version: string, name: string, content: (importPath: string, name: string) => string) => Promise<void>;
+declare const generate: <CT extends ColumnTypesBase>(config: RakeDbConfig<CT>, [name]: string[]) => Promise<void>;
 declare const makeFileTimeStamp: () => string;
 
-type ChangeCallback = (db: Migration, up: boolean) => Promise<void>;
-declare const change: (fn: ChangeCallback) => void;
+type ChangeCallback<CT extends ColumnTypesBase = ColumnTypesBase> = (db: Migration<CT>, up: boolean) => Promise<void>;
 
-declare const migrateOrRollback: (options: MaybeArray<AdapterOptions>, config: RakeDbConfig, args: string[], up: boolean) => Promise<void>;
+declare const migrateOrRollback: <CT extends ColumnTypesBase>(options: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>, args: string[], up: boolean) => Promise<void>;
 declare const changeCache: Record<string, ChangeCallback[] | undefined>;
-declare const migrate: (options: MaybeArray<AdapterOptions>, config: RakeDbConfig, args?: string[]) => Promise<void>;
-declare const rollback: (options: MaybeArray<AdapterOptions>, config: RakeDbConfig, args?: string[]) => Promise<void>;
-declare const redo: (options: MaybeArray<AdapterOptions>, config: RakeDbConfig, args?: string[]) => Promise<void>;
+declare const migrate: <CT extends ColumnTypesBase>(options: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>, args?: string[]) => Promise<void>;
+declare const rollback: <CT extends ColumnTypesBase>(options: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>, args?: string[]) => Promise<void>;
+declare const redo: <CT extends ColumnTypesBase>(options: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>, args?: string[]) => Promise<void>;
 
-declare const rakeDb: (options: MaybeArray<AdapterOptions>, partialConfig?: Partial<RakeDbConfig>, args?: string[]) => Promise<void>;
+declare const rakeDb: <CT extends ColumnTypesBase = {
+    timestamps: <T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+        name(name: string): {
+            timestamp(): T;
+        };
+        timestamp(): T;
+    }) => {
+        createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
+        updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
+    };
+    timestampsSnakeCase: <T_1 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+        name(name: string): {
+            timestamp(): T_1;
+        };
+        timestamp(): T_1;
+    }) => {
+        createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
+        updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
+    };
+    name: typeof orchid_core.name;
+    raw: (sql: string, values?: false | Record<string, unknown> | undefined) => orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>;
+    smallint(this: ColumnTypesBase): pqb.SmallIntColumn;
+    integer(this: ColumnTypesBase): pqb.IntegerColumn;
+    bigint(this: ColumnTypesBase): pqb.BigIntColumn;
+    numeric<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined>(this: ColumnTypesBase, precision?: Precision | undefined, scale?: Scale | undefined): pqb.DecimalColumn<Precision, Scale>;
+    decimal<Precision_1 extends number | undefined = undefined, Scale_1 extends number | undefined = undefined>(this: ColumnTypesBase, precision?: Precision_1 | undefined, scale?: Scale_1 | undefined): pqb.DecimalColumn<Precision_1, Scale_1>;
+    real(this: ColumnTypesBase): pqb.RealColumn;
+    doublePrecision(this: ColumnTypesBase): pqb.DoublePrecisionColumn;
+    identity(this: ColumnTypesBase, options?: pqb.TableData.Identity | undefined): pqb.IntegerColumn;
+    smallSerial(this: ColumnTypesBase): pqb.SmallSerialColumn;
+    serial(this: ColumnTypesBase): pqb.SerialColumn;
+    bigSerial(this: ColumnTypesBase): pqb.BigSerialColumn;
+    money(this: ColumnTypesBase): pqb.MoneyColumn;
+    varchar<Limit extends number | undefined = undefined>(this: ColumnTypesBase, limit?: Limit | undefined): pqb.VarCharColumn<Limit>;
+    char<Limit_1 extends number | undefined = undefined>(this: ColumnTypesBase, limit?: Limit_1 | undefined): pqb.CharColumn<Limit_1>;
+    text: (this: ColumnTypesBase, min: number, max: number) => pqb.TextColumn;
+    string: (this: ColumnTypesBase, min: number, max: number) => pqb.TextColumn;
+    citext(this: ColumnTypesBase, min: number, max: number): pqb.CitextColumn;
+    bytea(this: ColumnTypesBase): pqb.ByteaColumn;
+    date(this: ColumnTypesBase): pqb.DateColumn;
+    timestampWithoutTimeZone<Precision_2 extends number>(this: ColumnTypesBase, precision?: Precision_2 | undefined): pqb.TimestampColumn<Precision_2>;
+    timestamp<Precision_3 extends number | undefined = undefined>(this: ColumnTypesBase, precision?: Precision_3 | undefined): pqb.TimestampTzColumn<number>;
+    time<Precision_4 extends number | undefined = undefined>(this: ColumnTypesBase, precision?: Precision_4 | undefined): pqb.TimeColumn<Precision_4>;
+    interval<Fields extends string | undefined = undefined, Precision_5 extends number | undefined = undefined>(this: ColumnTypesBase, fields?: Fields | undefined, precision?: Precision_5 | undefined): pqb.IntervalColumn<Fields, Precision_5>;
+    boolean(this: ColumnTypesBase): pqb.BooleanColumn;
+    enum<U extends string, T_2 extends [U, ...U[]]>(this: ColumnTypesBase, dataType: string, type: T_2): pqb.EnumColumn<U, T_2>;
+    point(this: ColumnTypesBase): pqb.PointColumn;
+    line(this: ColumnTypesBase): pqb.LineColumn;
+    lseg(this: ColumnTypesBase): pqb.LsegColumn;
+    box(this: ColumnTypesBase): pqb.BoxColumn;
+    path(this: ColumnTypesBase): pqb.PathColumn;
+    polygon(this: ColumnTypesBase): pqb.PolygonColumn;
+    circle(this: ColumnTypesBase): pqb.CircleColumn;
+    cidr(this: ColumnTypesBase): pqb.CidrColumn;
+    inet(this: ColumnTypesBase): pqb.InetColumn;
+    macaddr(this: ColumnTypesBase): pqb.MacAddrColumn;
+    macaddr8(this: ColumnTypesBase): pqb.MacAddr8Column;
+    bit<Length extends number>(this: ColumnTypesBase, length: Length): pqb.BitColumn<Length>;
+    bitVarying<Length_1 extends number | undefined = undefined>(this: ColumnTypesBase, length?: Length_1 | undefined): pqb.BitVaryingColumn<Length_1>;
+    tsvector(this: ColumnTypesBase): pqb.TsVectorColumn;
+    tsquery(this: ColumnTypesBase): pqb.TsQueryColumn;
+    uuid(this: ColumnTypesBase): pqb.UUIDColumn;
+    xml(this: ColumnTypesBase): pqb.XMLColumn;
+    json<Type extends orchid_core.JSONTypeAny>(this: ColumnTypesBase, schemaOrFn: Type | ((j: {
+        set: <Value extends orchid_core.JSONTypeAny>(valueType: Value) => orchid_core.JSONSet<Value>;
+        tuple: <T_3 extends [] | orchid_core.JSONTupleItems, Rest extends orchid_core.JSONTypeAny | null = null>(items: T_3, rest?: Rest) => orchid_core.JSONTuple<T_3, Rest>;
+        union: <T_4 extends [orchid_core.JSONTypeAny, orchid_core.JSONTypeAny, ...orchid_core.JSONTypeAny[]]>(types: T_4) => orchid_core.JSONUnion<T_4>;
+        any: () => orchid_core.JSONAny;
+        bigint: () => orchid_core.JSONBigInt;
+        boolean: () => orchid_core.JSONBoolean;
+        date: () => orchid_core.JSONDate;
+        nan: () => orchid_core.JSONNaN;
+        never: () => orchid_core.JSONNever;
+        null: () => orchid_core.JSONNull;
+        number: () => orchid_core.JSONNumber;
+        string: () => orchid_core.JSONString;
+        unknown: () => orchid_core.JSONUnknown;
+        array: <Type_1 extends orchid_core.JSONTypeAny>(element: Type_1) => orchid_core.JSONArray<Type_1, "many">;
+        discriminatedUnion: <Discriminator extends string, DiscriminatorValue extends orchid_core.Primitive, Types extends [orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => orchid_core.JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types>;
+        enum: <U_1 extends string, T_5 extends [U_1, ...U_1[]]>(options: T_5) => orchid_core.JSONEnum<U_1, T_5>;
+        instanceOf: <T_6 extends new (...args: any[]) => any>(cls: T_6) => orchid_core.JSONInstanceOf<T_6>;
+        intersection: <Left extends orchid_core.JSONTypeAny, Right extends orchid_core.JSONTypeAny>(left: Left, right: Right) => orchid_core.JSONIntersection<Left, Right>;
+        lazy: <T_7 extends orchid_core.JSONTypeAny>(fn: () => T_7) => orchid_core.JSONLazy<T_7>;
+        literal: <T_8 extends orchid_core.Primitive>(value: T_8) => orchid_core.JSONLiteral<T_8>;
+        map: <Key extends orchid_core.JSONTypeAny, Value_1 extends orchid_core.JSONTypeAny>(keyType: Key, valueType: Value_1) => orchid_core.JSONMap<Key, Value_1>;
+        nativeEnum: <T_9 extends orchid_core.EnumLike>(givenEnum: T_9) => orchid_core.JSONNativeEnum<T_9>;
+        nullable: <T_10 extends orchid_core.JSONTypeAny>(type: T_10) => orchid_core.JSONNullable<T_10>;
+        nullish: <T_11 extends orchid_core.JSONTypeAny>(type: T_11) => orchid_core.JSONNullish<T_11>;
+        object: <T_12 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_12) => orchid_core.JSONObject<T_12, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_16 extends object ? { [k in keyof T_16]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+            [k: string]: Catchall["type"];
+        } extends infer T_14 extends object ? { [k_2 in keyof T_14]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_15 extends object ? { [k in keyof T_15]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+            [k: string]: Catchall["type"];
+        })[k_2]; } : never>;
+        optional: <T_17 extends orchid_core.JSONTypeAny>(type: T_17) => orchid_core.JSONOptional<T_17>;
+        record: typeof orchid_core.record;
+    }) => Type)): pqb.JSONColumn<Type>;
+    jsonText(this: ColumnTypesBase): pqb.JSONTextColumn;
+    array<Item extends pqb.ColumnType<unknown, orchid_core.BaseOperators, unknown>>(this: ColumnTypesBase, item: Item): pqb.ArrayColumn<Item>;
+    type(this: ColumnTypesBase, dataType: string): pqb.CustomTypeColumn;
+    domain(this: ColumnTypesBase, dataType: string): pqb.DomainColumn;
+    primaryKey(columns: string[], options?: {
+        name?: string | undefined;
+    } | undefined): {};
+    index(columns: MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
+    unique(columns: MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
+    constraint<Table extends string | (() => pqb.ForeignKeyTable), Columns extends Table extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table>>, ...pqb.ColumnNameOfTable<ReturnType<Table>>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
+        name?: string | undefined;
+        references?: [columns: string[], fnOrTable: Table, foreignColumns: Columns, options?: pqb.ForeignKeyOptions | undefined] | undefined;
+        check?: orchid_core.RawExpression | undefined;
+        dropMode?: pqb.DropMode | undefined;
+    }): {};
+    foreignKey<Table_1 extends string | (() => pqb.ForeignKeyTable), Columns_1 extends Table_1 extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table_1>>, ...pqb.ColumnNameOfTable<ReturnType<Table_1>>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_1, foreignColumns: Columns_1, options?: (pqb.ForeignKeyOptions & {
+        name?: string | undefined;
+        dropMode?: pqb.DropMode | undefined;
+    }) | undefined): {};
+    check(check: orchid_core.RawExpression): {};
+}>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<CT>, args?: string[]) => ((fn: ChangeCallback<CT>) => void) & {
+    promise: Promise<void>;
+};
 
-declare const saveMigratedVersion: (db: SilentQueries, version: string, config: RakeDbConfig) => Promise<void>;
-declare const removeMigratedVersion: (db: SilentQueries, version: string, config: RakeDbConfig) => Promise<void>;
-declare const getMigratedVersionsMap: (db: Adapter, config: RakeDbConfig) => Promise<Record<string, boolean>>;
+declare const saveMigratedVersion: <CT extends ColumnTypesBase>(db: SilentQueries, version: string, config: RakeDbConfig<CT>) => Promise<void>;
+declare const removeMigratedVersion: <CT extends ColumnTypesBase>(db: SilentQueries, version: string, config: RakeDbConfig<CT>) => Promise<void>;
+declare const getMigratedVersionsMap: <CT extends ColumnTypesBase>(db: Adapter, config: RakeDbConfig<CT>) => Promise<Record<string, boolean>>;
 
-export { AppCodeUpdater, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, DropMode, Migration, MigrationBase, MigrationColumnTypes, RakeDbAst, RakeDbConfig, SilentQueries, TableOptions, change, changeCache, createDb, createMigrationInterface, dropDb, generate, getMigratedVersionsMap, makeFileTimeStamp, migrate, migrateOrRollback, rakeDb, redo, removeMigratedVersion, resetDb, rollback, saveMigratedVersion, writeMigrationFile };
+export { AppCodeUpdater, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, DropMode, Migration, MigrationBase, MigrationColumnTypes, RakeDbAst, RakeDbConfig, SilentQueries, TableOptions, changeCache, createDb, createMigrationInterface, dropDb, generate, getMigratedVersionsMap, makeFileTimeStamp, migrate, migrateOrRollback, rakeDb, redo, removeMigratedVersion, resetDb, rollback, saveMigratedVersion, writeMigrationFile };