rake-db 2.18.0 → 2.19.0

package/dist/index.d.ts

@@ -1,16 +1,7 @@
 import * as orchid_core from 'orchid-core';
 import { MaybeArray, RawSQLBase, ColumnDataCheckBase, RecordString, EmptyObject, ColumnSchemaConfig, RecordOptionalString, ColumnTypeBase, ForeignKeyTable, Sql, MaybePromise } from 'orchid-core';
 import * as pqb from 'pqb';
-import { QueryArraysResult, ColumnsShape, Db as Db$1, TableData, NoPrimaryKeyOption, ColumnType, ForeignKeyOptions, SingleColumnIndexOptions, EnumColumn, raw, Adapter, IndexColumnOptions, IndexOptions, DbResult, TransactionAdapter, QueryLogObject, DbDomainArg, TextColumn, AdapterOptions, DefaultColumnTypes, DefaultSchemaConfig, QueryLogOptions, SearchWeight, ColumnsByType, ArrayColumn } from 'pqb';
-
-interface TableQuery {
-    text: string;
-    values?: unknown[];
-    then?(result: QueryArraysResult): void;
-}
-interface CreateTableResult<Table extends string, Shape extends ColumnsShape> {
-    table: Db$1<Table, Shape>;
-}
+import { TableData, ColumnsShape, NoPrimaryKeyOption, ColumnType, EnumColumn, raw, Adapter, DbResult, TransactionAdapter, QueryLogObject, TableDataFn, TableDataItem, DbDomainArg, TextColumn, Db as Db$1, QueryArraysResult, AdapterOptions, DefaultColumnTypes, DefaultSchemaConfig, QueryLogOptions, SearchWeight, ColumnsByType, ArrayColumn } from 'pqb';
 
 type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameType | RakeDbAst.Schema | RakeDbAst.RenameSchema | RakeDbAst.Extension | RakeDbAst.Enum | RakeDbAst.EnumValues | RakeDbAst.RenameEnumValues | RakeDbAst.ChangeEnumValues | RakeDbAst.Domain | RakeDbAst.Collation | RakeDbAst.Constraint | RakeDbAst.RenameTableItem | RakeDbAst.View;
 declare namespace RakeDbAst {
@@ -69,11 +60,8 @@ declare namespace RakeDbAst {
         compression?: string;
         primaryKey?: boolean;
         check?: ColumnDataCheckBase;
-        foreignKeys?: ({
-            table: string;
-            columns: string[];
-        } & ForeignKeyOptions)[];
-        indexes?: Omit<SingleColumnIndexOptions, 'column' | 'expression'>[];
+        foreignKeys?: TableData.ColumnReferences[];
+        indexes?: TableData.ColumnIndex[];
         identity?: TableData.Identity;
     }
     interface RenameType {
@@ -218,7 +206,7 @@ type Change = RakeDbAst.ChangeTableItem.Change & ChangeOptions;
 type ChangeOptions = RakeDbAst.ChangeTableItem.ChangeUsing;
 type TableChangeMethods = typeof tableChangeMethods;
 declare const tableChangeMethods: {
-    name(this: RakeDbColumnTypes, name: string): any;
+    name(name: string): any;
     add: typeof add;
     drop: typeof add;
     change(from: ColumnType | Change, to: ColumnType | Change, using?: ChangeOptions): Change;
@@ -227,6 +215,19 @@ declare const tableChangeMethods: {
     nonNullable(): Change;
     comment(comment: string | null): Change;
     rename(name: string): RakeDbAst.ChangeTableItem.Rename;
+    primaryKey<Columns extends [string, ...string[]], Name extends string>(columns: Columns, name?: Name | undefined): {
+        columns: Columns;
+        name: string extends Name ? never : Name;
+    };
+    unique<Columns_1 extends [string | TableData.Index.ColumnOrExpressionOptions<string>, ...(string | TableData.Index.ColumnOrExpressionOptions<string>)[]], Name_1 extends string>(columns: Columns_1, ...args: [options?: TableData.Index.UniqueOptionsArg | undefined] | [name?: Name_1 | undefined, options?: TableData.Index.UniqueOptionsArg | undefined]): {
+        columns: Columns_1 extends (string | TableData.Index.ColumnOptionsForColumn<string>)[] ? { [I in keyof Columns_1]: "column" extends keyof Columns_1[I] ? Columns_1[I][keyof Columns_1[I] & "column"] : Columns_1[I]; } : never;
+        name: string extends Name_1 ? never : Name_1;
+    };
+    index(columns: (string | TableData.Index.ColumnOrExpressionOptions<string>)[], ...args: [options?: TableData.Index.OptionsArg | undefined] | [name?: string | undefined, options?: TableData.Index.OptionsArg | undefined]): pqb.TableDataItem;
+    searchIndex(columns: (string | TableData.Index.ColumnOrExpressionOptions<string>)[], ...args: [options?: TableData.Index.TsVectorArg | undefined] | [name?: string | undefined, options?: TableData.Index.TsVectorArg | undefined]): pqb.TableDataItem;
+    foreignKey<ForeignTable extends string | (() => orchid_core.ForeignKeyTable), ForeignColumns extends ForeignTable extends () => orchid_core.ForeignKeyTable ? [orchid_core.ColumnNameOfTable<ReturnType<ForeignTable>>, ...orchid_core.ColumnNameOfTable<ReturnType<ForeignTable>>[]] : [string, ...string[]]>(columns: [string, ...string[]], fnOrTable: ForeignTable, foreignColumns: ForeignColumns, options?: TableData.References.Options | undefined): pqb.TableDataItem;
+    check(check: RawSQLBase<orchid_core.QueryColumn<unknown, orchid_core.CoreBaseOperators>, unknown>, name?: string | undefined): pqb.TableDataItem;
+    sql: pqb.SqlFn;
     enum(name: string): EnumColumn<pqb.DefaultSchemaConfig, undefined, string, [string, ...string[]]>;
 };
 type TableChanger<CT> = MigrationColumnTypes<CT> & TableChangeMethods;
@@ -265,27 +266,7 @@ type SilentQueries = {
     silentQuery: Adapter['query'];
     silentArrays: Adapter['arrays'];
 };
-interface RakeDbColumnTypes {
-    index(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): EmptyObject;
-    foreignKey(columns: [string, ...string[]], foreignTable: string, foreignColumns: [string, ...string[]], options?: ForeignKeyOptions): EmptyObject;
-    primaryKey(columns: string[], options?: {
-        name?: string;
-    }): EmptyObject;
-    check(check: RawSQLBase): EmptyObject;
-    constraint(arg: ConstraintArg): EmptyObject;
-}
-interface ConstraintArg {
-    name?: string;
-    references?: [
-        columns: [string, ...string[]],
-        table: string,
-        foreignColumn: [string, ...string[]],
-        options: Omit<ForeignKeyOptions, 'name' | 'dropMode'>
-    ];
-    check?: RawSQLBase;
-    dropMode?: DropMode;
-}
-type DbMigration<CT extends RakeDbColumnTypes> = DbResult<CT> & Migration<CT> & {
+type DbMigration<CT> = DbResult<CT> & Migration<CT> & {
     adapter: SilentQueries;
 };
 /**
@@ -296,11 +277,11 @@ type DbMigration<CT extends RakeDbColumnTypes> = DbResult<CT> & Migration<CT> &
  * @param up - migrate or rollback
  * @param config - config of `rakeDb`
  */
-declare const createMigrationInterface: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT extends RakeDbColumnTypes>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<SchemaConfig, CT>) => DbMigration<CT>;
+declare const createMigrationInterface: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<SchemaConfig, CT>) => DbMigration<CT>;
 interface MigrationAdapter extends TransactionAdapter {
     schema: string;
 }
-declare class Migration<CT extends RakeDbColumnTypes> {
+declare class Migration<CT> {
     adapter: MigrationAdapter;
     log?: QueryLogObject;
     up: boolean;
@@ -380,31 +361,35 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      *
      * @param tableName - name of the table to create
      * @param fn - create table callback
+     * @param dataFn - callback for creating composite indexes, primary keys, foreign keys
      */
-    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, fn?: ColumnsShapeCallback<CT, Shape>): Promise<CreateTableResult<Table, Shape>>;
+    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, fn?: ColumnsShapeCallback<CT, Shape>, dataFn?: TableDataFn<Shape, MaybeArray<TableDataItem>>): Promise<CreateTableResult<Table, Shape>>;
     /**
      * See {@link createTable}
      *
      * @param tableName - name of the table to create
      * @param options - {@link TableOptions}
      * @param fn - create table callback
+     * @param dataFn - callback for creating composite indexes, primary keys, foreign keys
      */
-    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, options: TableOptions, fn?: ColumnsShapeCallback<CT, Shape>, dataFn?: TableDataFn<Shape, MaybeArray<TableDataItem>>): Promise<CreateTableResult<Table, Shape>>;
     /**
      * Drop the table, create it on rollback. See {@link createTable}.
      *
      * @param tableName - name of the table to drop
      * @param fn - create table callback
+     * @param dataFn - callback for creating composite indexes, primary keys, foreign keys
      */
-    dropTable<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, fn?: ColumnsShapeCallback<CT, Shape>, dataFn?: TableDataFn<Shape, MaybeArray<TableDataItem>>): Promise<CreateTableResult<Table, Shape>>;
     /**
      * Drop the table, create it on rollback. See {@link createTable}.
      *
      * @param tableName - name of the table to drop
      * @param options - {@link TableOptions}
      * @param fn - create table callback
+     * @param dataFn - callback for creating composite indexes, primary keys, foreign keys
      */
-    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, options: TableOptions, fn?: ColumnsShapeCallback<CT, Shape>, dataFn?: TableDataFn<Shape, MaybeArray<TableDataItem>>): Promise<CreateTableResult<Table, Shape>>;
     /**
      * `changeTable` accepts a table name, optional options, and a special callback with column changes.
      *
@@ -501,7 +486,7 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      */
     addColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes<CT>) => ColumnType): Promise<void>;
     /**
-     * Drop the schema, create it on rollback. See {@link addIndex}.
+     * Drop the schema, create it on rollback. See {@link addColumn}.
      *
      * @param tableName - name of the table to add the column to
      * @param columnName - name of the column to add
@@ -531,17 +516,17 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      *
      * @param tableName - name of the table to add the index for
      * @param columns - indexed columns
-     * @param options - index options
+     * @param args - index options, or an index name and then options
      */
-    addIndex(tableName: string, columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): Promise<void>;
+    addIndex(tableName: string, columns: (string | TableData.Index.ColumnOrExpressionOptions<string>)[], ...args: [options?: TableData.Index.OptionsArg] | [name?: string, options?: TableData.Index.OptionsArg]): Promise<void>;
     /**
      * Drop the schema, create it on rollback. See {@link addIndex}.
      *
      * @param tableName - name of the table to add the index for
      * @param columns - indexed columns
-     * @param options - index options
+     * @param args - index options, or an index name and then options
      */
-    dropIndex(tableName: string, columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): Promise<void>;
+    dropIndex(tableName: string, columns: (string | TableData.Index.ColumnOrExpressionOptions<string>)[], ...args: [options?: TableData.Index.OptionsArg] | [name?: string, options?: TableData.Index.OptionsArg]): Promise<void>;
     /**
      * Rename index:
      *
@@ -602,7 +587,7 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      * @param foreignColumns - column names in the other table
      * @param options - foreign key options
      */
-    addForeignKey(tableName: string, columns: [string, ...string[]], foreignTable: string, foreignColumns: [string, ...string[]], options?: ForeignKeyOptions): Promise<void>;
+    addForeignKey(tableName: string, columns: [string, ...string[]], foreignTable: string, foreignColumns: [string, ...string[]], options?: TableData.References.Options): Promise<void>;
     /**
      * Drop the schema, create it on rollback. See {@link addForeignKey}.
      *
@@ -612,7 +597,7 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      * @param foreignColumns - column names in the other table
      * @param options - foreign key options
      */
-    dropForeignKey(tableName: string, columns: [string, ...string[]], foreignTable: string, foreignColumns: [string, ...string[]], options?: ForeignKeyOptions): Promise<void>;
+    dropForeignKey(tableName: string, columns: [string, ...string[]], foreignTable: string, foreignColumns: [string, ...string[]], options?: TableData.References.Options): Promise<void>;
     /**
      * Add a primary key to a table on migrate, and remove it on rollback.
      *
@@ -633,21 +618,17 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      *
      * @param tableName - name of the table
      * @param columns - array of the columns
-     * @param options - object with a constraint name
+     * @param name - optionally, set a primary key constraint name
      */
-    addPrimaryKey(tableName: string, columns: string[], options?: {
-        name?: string;
-    }): Promise<void>;
+    addPrimaryKey(tableName: string, columns: [string, ...string[]], name?: string): Promise<void>;
     /**
      * Drop the schema, create it on rollback. See {@link addPrimaryKey}.
      *
      * @param tableName - name of the table
      * @param columns - array of the columns
-     * @param options - object with a constraint name
+     * @param name - optionally, set a primary key constraint name
      */
-    dropPrimaryKey(tableName: string, columns: string[], options?: {
-        name?: string;
-    }): Promise<void>;
+    dropPrimaryKey(tableName: string, columns: [string, ...string[]], name?: string): Promise<void>;
     /**
      * Add or drop a check for multiple columns.
      *
@@ -664,42 +645,14 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      */
     addCheck(tableName: string, check: RawSQLBase): Promise<void>;
     /**
-     * Drop the schema, create it on rollback. See {@link addConstraint}.
+     * Drop the schema, create it on rollback. See {@link addCheck}.
      *
      * @param tableName - name of the table to add the check into
      * @param check - raw SQL for the check
      */
     dropCheck(tableName: string, check: RawSQLBase): Promise<void>;
     /**
-     * Add or drop a constraint with check and a foreign key references.
-     *
-     * See foreign key details in [foreign key](/guide/migration-column-methods.html#composite-foreign-key).
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.addConstraint('tableName', {
-     *     name: 'constraintName',
-     *     check: db.sql`column > 123`,
-     *     references: [['id', 'name'], 'otherTable', ['otherId', 'otherName']],
-     *   });
-     * });
-     * ```
-     *
-     * @param tableName - name of the table to add the constraint to
-     * @param constraint - constraint config object
-     */
-    addConstraint(tableName: string, constraint: ConstraintArg): Promise<void>;
-    /**
-     * Drop the schema, create it on rollback. See {@link addConstraint}.
-     *
-     * @param tableName - name of the table to add the constraint to
-     * @param constraint - constraint config object
-     */
-    dropConstraint(tableName: string, constraint: ConstraintArg): Promise<void>;
-    /**
-     * Rename a table constraint, such as primary key, or check.
+     * Rename a table constraint such as a primary key or a database check.
      *
      * ```ts
      * import { change } from '../dbScript';
@@ -1231,14 +1184,23 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      */
     constraintExists(constraintName: string): Promise<boolean>;
 }
-declare const renameType: (migration: Migration<RakeDbColumnTypes>, from: string, to: string, kind: RakeDbAst.RenameType['kind']) => Promise<void>;
+declare const renameType: (migration: Migration<unknown>, from: string, to: string, kind: RakeDbAst.RenameType['kind']) => Promise<void>;
 interface AddEnumValueOptions {
     ifNotExists?: boolean;
     before?: string;
     after?: string;
 }
-declare const addOrDropEnumValues: (migration: Migration<RakeDbColumnTypes>, up: boolean, enumName: string, values: string[], options?: AddEnumValueOptions) => Promise<void>;
-declare const changeEnumValues: (migration: Migration<RakeDbColumnTypes>, enumName: string, fromValues: string[], toValues: string[]) => Promise<void>;
+declare const addOrDropEnumValues: (migration: Migration<unknown>, up: boolean, enumName: string, values: string[], options?: AddEnumValueOptions) => Promise<void>;
+declare const changeEnumValues: (migration: Migration<unknown>, enumName: string, fromValues: string[], toValues: string[]) => Promise<void>;
+
+interface TableQuery {
+    text: string;
+    values?: unknown[];
+    then?(result: QueryArraysResult): void;
+}
+interface CreateTableResult<Table extends string, Shape extends ColumnsShape> {
+    table: Db$1<Table, Shape>;
+}
 
 interface RakeDbCtx {
     migrationsPromise?: Promise<MigrationsSet>;
@@ -1406,7 +1368,7 @@ type MigrationCallback = (arg: {
     migrations: MigrationItem[];
 }) => void | Promise<void>;
 type AnyRakeDbConfig = RakeDbConfig<any, any>;
-type Db = DbResult<RakeDbColumnTypes>;
+type Db = DbResult<unknown>;
 interface RakeDbBaseTable<CT> {
     exportAs: string;
     getFilePath(): string;
@@ -1440,17 +1402,17 @@ declare const getDatabaseAndUserFromOptions: (options: AdapterOptions) => {
 
 declare const createDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
 declare const dropDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
-declare const resetDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT extends RakeDbColumnTypes>(options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
+declare const resetDb: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
 
 declare const writeMigrationFile: (config: AnyRakeDbConfig, version: string, name: string, migrationCode: string) => Promise<void>;
 declare const newMigration: (config: AnyRakeDbConfig, [name]: string[]) => Promise<void>;
 declare const makeFileVersion: (ctx: RakeDbCtx, config: AnyRakeDbConfig) => Promise<string>;
 declare const generateTimeStamp: () => string;
 
-type ChangeCallback<CT extends RakeDbColumnTypes> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
+type ChangeCallback<CT> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
 declare const clearChanges: () => void;
-declare const getCurrentChanges: () => ChangeCallback<RakeDbColumnTypes>[];
-declare const pushChange: (fn: ChangeCallback<RakeDbColumnTypes>) => number;
+declare const getCurrentChanges: () => ChangeCallback<unknown>[];
+declare const pushChange: (fn: ChangeCallback<unknown>) => number;
 
 declare const saveMigratedVersion: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(db: SilentQueries, version: string, name: string, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
 declare const deleteMigratedVersion: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(db: SilentQueries, version: string, name: string, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
@@ -1463,7 +1425,7 @@ type RakeDbAppliedVersions = {
 declare const getMigratedVersionsMap: <SchemaConfig extends ColumnSchemaConfig<orchid_core.ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, orchid_core.CoreBaseOperators, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>>, CT>(ctx: RakeDbCtx, adapter: Adapter | TransactionAdapter, config: RakeDbConfig<SchemaConfig, CT>, renameTo?: RakeDbMigrationId) => Promise<RakeDbAppliedVersions>;
 
 declare const RAKE_DB_LOCK_KEY = "8582141715823621641";
-type MigrateFn = <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(ctx: RakeDbCtx, options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args?: string[], adapters?: Adapter[], dontClose?: boolean) => Promise<Adapter[]>;
+type MigrateFn = <SchemaConfig extends ColumnSchemaConfig, CT>(ctx: RakeDbCtx, options: AdapterOptions[], config: RakeDbConfig<SchemaConfig, CT>, args?: string[], adapters?: Adapter[], dontClose?: boolean) => Promise<Adapter[]>;
 /**
  * Will run all pending yet migrations, sequentially in order,
  * will apply `change` functions top-to-bottom.
@@ -1486,8 +1448,8 @@ declare const rollback: MigrateFn;
  * Takes the same options as {@link migrate}.
  */
 declare const redo: MigrateFn;
-declare const migrateOrRollback: (trx: TransactionAdapter, config: RakeDbConfig<ColumnSchemaConfig, RakeDbColumnTypes>, set: MigrationsSet, versions: RakeDbAppliedVersions, count: number, up: boolean, redo: boolean, force?: boolean, skipLock?: boolean) => Promise<void>;
-declare const changeCache: Record<string, ChangeCallback<RakeDbColumnTypes>[] | undefined>;
+declare const migrateOrRollback: (trx: TransactionAdapter, config: RakeDbConfig<ColumnSchemaConfig, unknown>, set: MigrationsSet, versions: RakeDbAppliedVersions, count: number, up: boolean, redo: boolean, force?: boolean, skipLock?: boolean) => Promise<void>;
+declare const changeCache: Record<string, ChangeCallback<unknown>[] | undefined>;
 
 declare namespace DbStructure {
     interface Table {
@@ -1708,7 +1670,7 @@ declare const getIndexName: (table: string, columns: ({
 } | {
     expression: string;
 })[]) => string;
-declare const indexesToQuery: (up: boolean, { schema, name }: {
+declare const indexesToQuery: (up: boolean, { schema, name: tableName }: {
     schema?: string;
     name: string;
 }, indexes: TableData.Index[], language?: string) => Sql[];
@@ -1721,7 +1683,7 @@ declare const primaryKeyToSql: (primaryKey: Exclude<TableData['primaryKey'], und
 /**
  * Type of {@link rakeDb} function
  */
-type RakeDbFn = (<SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes | undefined = undefined>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<SchemaConfig, CT>, args?: string[]) => RakeDbFnReturns<CT>) & {
+type RakeDbFn = (<SchemaConfig extends ColumnSchemaConfig, CT>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<SchemaConfig, CT>, args?: string[]) => RakeDbFnReturns<CT>) & {
     /**
      * Unlike the original `rakeDb` that executes immediately,
      * `rakeDb.lazy` returns the `run` function to be later called programmatically.
@@ -1732,7 +1694,7 @@ type RakeDbFn = (<SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColu
      */
     lazy: RakeDbLazyFn;
 };
-type RakeDbFnReturns<CT extends RakeDbColumnTypes | undefined> = RakeDbChangeFn<CT extends undefined ? DefaultColumnTypes<DefaultSchemaConfig> : CT> & {
+type RakeDbFnReturns<CT> = RakeDbChangeFn<CT extends undefined ? DefaultColumnTypes<DefaultSchemaConfig> : CT> & {
     promise: Promise<RakeDbResult>;
 };
 interface RakeDbResult {
@@ -1743,7 +1705,7 @@ interface RakeDbResult {
 /**
  * Type of {@link rakeDb.lazy} function
  */
-type RakeDbLazyFn = <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbColumnTypes>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<SchemaConfig, CT>) => {
+type RakeDbLazyFn = <SchemaConfig extends ColumnSchemaConfig, CT>(options: MaybeArray<AdapterOptions>, partialConfig?: InputRakeDbConfig<SchemaConfig, CT>) => {
     change: RakeDbChangeFn<CT>;
     run(args: string[], config?: Partial<RakeDbConfig<SchemaConfig, CT>>): Promise<RakeDbResult>;
 };
@@ -1752,7 +1714,7 @@ type RakeDbLazyFn = <SchemaConfig extends ColumnSchemaConfig, CT extends RakeDbC
  * Saves the given callback to an internal queue,
  * and also returns the callback in case you want to export it from migration.
  */
-type RakeDbChangeFn<CT extends RakeDbColumnTypes> = (fn: ChangeCallback<CT>) => ChangeCallback<CT>;
+type RakeDbChangeFn<CT> = (fn: ChangeCallback<CT>) => ChangeCallback<CT>;
 /**
  * Function to configure and run `rakeDb`.
  *
@@ -1802,4 +1764,4 @@ declare const promptText: ({ message, default: def, password, min, }: {
     min?: number;
 }) => Promise<string>;
 
-export { AnyRakeDbConfig, ChangeCallback, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, CommandFn, ConstraintArg, DbMigration, DbStructure, DbStructureDomainsMap, DropMode, InputRakeDbConfig, IntrospectedStructure, Migration, MigrationAdapter, MigrationColumnTypes, ModuleExportsRecord, NoMigrationsTableError, RAKE_DB_LOCK_KEY, RakeDbAppliedVersions, RakeDbAst, RakeDbBaseTable, RakeDbChangeFn, RakeDbColumnTypes, RakeDbConfig, RakeDbCtx, RakeDbFn, RakeDbFnReturns, RakeDbLazyFn, RakeDbMigrationId, RakeDbResult, SilentQueries, StructureToAstCtx, StructureToAstTableData, TableOptions, addColumnComment, addColumnIndex, addOrDropEnumValues, astToMigration, changeCache, changeEnumValues, clearChanges, colors, columnToSql, columnTypeToSql, commentsToQuery, concatSchemaAndName, constraintToSql, createDb, createMigrationInterface, dbColumnToAst, deleteMigratedVersion, dropDb, encodeColumnDefault, exhaustive, generateTimeStamp, getColumnName, getConstraintName, getCurrentChanges, getDatabaseAndUserFromOptions, getDbStructureTableData, getDbTableColumnsChecks, getFirstWordAndRest, getForeignKeyTable, getIndexName, getMigratedVersionsMap, getSchemaAndTableFromName, getTextAfterFrom, getTextAfterTo, identityToSql, indexesToQuery, instantiateDbColumn, introspectDbSchema, joinColumns, joinWords, makeDbStructureColumnsShape, makeDomainsMap, makeFileVersion, makePopulateEnumQuery, makeStructureToAstCtx, migrate, migrateOrRollback, migrationConfigDefaults, newMigration, pluralize, primaryKeyToSql, processRakeDbConfig, promptConfirm, promptSelect, promptText, pushChange, queryLock, quoteNameFromString, quoteSchemaTable, quoteTable, quoteWithSchema, rakeDb, rakeDbAliases, rakeDbCommands, redo, referencesToSql, renameType, resetDb, rollback, saveMigratedVersion, structureToAst, tableToAst, transaction, versionToString, writeMigrationFile };
+export { AnyRakeDbConfig, ChangeCallback, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, CommandFn, DbMigration, DbStructure, DbStructureDomainsMap, DropMode, InputRakeDbConfig, IntrospectedStructure, Migration, MigrationAdapter, MigrationColumnTypes, ModuleExportsRecord, NoMigrationsTableError, RAKE_DB_LOCK_KEY, RakeDbAppliedVersions, RakeDbAst, RakeDbBaseTable, RakeDbChangeFn, RakeDbConfig, RakeDbCtx, RakeDbFn, RakeDbFnReturns, RakeDbLazyFn, RakeDbMigrationId, RakeDbResult, SilentQueries, StructureToAstCtx, StructureToAstTableData, TableOptions, addColumnComment, addColumnIndex, addOrDropEnumValues, astToMigration, changeCache, changeEnumValues, clearChanges, colors, columnToSql, columnTypeToSql, commentsToQuery, concatSchemaAndName, constraintToSql, createDb, createMigrationInterface, dbColumnToAst, deleteMigratedVersion, dropDb, encodeColumnDefault, exhaustive, generateTimeStamp, getColumnName, getConstraintName, getCurrentChanges, getDatabaseAndUserFromOptions, getDbStructureTableData, getDbTableColumnsChecks, getFirstWordAndRest, getForeignKeyTable, getIndexName, getMigratedVersionsMap, getSchemaAndTableFromName, getTextAfterFrom, getTextAfterTo, identityToSql, indexesToQuery, instantiateDbColumn, introspectDbSchema, joinColumns, joinWords, makeDbStructureColumnsShape, makeDomainsMap, makeFileVersion, makePopulateEnumQuery, makeStructureToAstCtx, migrate, migrateOrRollback, migrationConfigDefaults, newMigration, pluralize, primaryKeyToSql, processRakeDbConfig, promptConfirm, promptSelect, promptText, pushChange, queryLock, quoteNameFromString, quoteSchemaTable, quoteTable, quoteWithSchema, rakeDb, rakeDbAliases, rakeDbCommands, redo, referencesToSql, renameType, resetDb, rollback, saveMigratedVersion, structureToAst, tableToAst, transaction, versionToString, writeMigrationFile };