rake-db 2.30.9 → 2.31.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import * as pqb from 'pqb';
-import { SearchWeight, RecordOptionalString, DefaultPrivileges, AdapterBase, TableData, ColumnsShape, NoPrimaryKeyOption, MaybeArray, Column, RawSqlBase, RecordString, EnumColumn, EmptyObject, DbResult, DefaultColumnTypes, DefaultSchemaConfig, QueryLogObject, TableDataFn, TableDataItem, DbDomainArg, ColumnSchemaConfig, raw, Db, QuerySchema, MaybePromise, QueryLogOptions, QueryLogger, ColumnsByType, DbStructureDomainsMap } from 'pqb';
+import * as pqb_internal from 'pqb/internal';
+import { SearchWeight, RecordOptionalString, DefaultPrivileges, AdapterBase, TableData, ColumnsShape, NoPrimaryKeyOption, MaybeArray, Column, RawSqlBase, RecordString, EmptyObject, EnumColumn, DbResult, QueryLogObject, ColumnSchemaConfig, raw, TableDataFn, TableDataItem, DbDomainArg, DefaultColumnTypes, DefaultSchemaConfig, Db, QuerySchema, QueryLogger, QueryLogOptions, MaybePromise, ColumnsByType, DbStructureDomainsMap } from 'pqb/internal';
 
 declare namespace DbStructure {
     interface TableNameAndSchemaName {
@@ -429,7 +429,7 @@ declare namespace RakeDbAst {
         grant?: DefaultPrivilegeObjectConfig;
         revoke?: DefaultPrivilegeObjectConfig;
     }
-    export {  };
+    export {};
 }
 
 declare function add(item: Column, options?: {
@@ -486,23 +486,23 @@ declare const tableChangeMethods: {
         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, options?: TableData.Index.UniqueOptionsArg<Name_1> | undefined): {
+    unique<Columns extends [string | TableData.Index.ColumnOrExpressionOptions<string>, ...(string | TableData.Index.ColumnOrExpressionOptions<string>)[]], Name extends string>(columns: Columns, options?: TableData.Index.UniqueOptionsArg<Name> | undefined): {
         tableDataItem: true;
-        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;
+        columns: Columns extends (string | TableData.Index.ColumnOptionsForColumn<string>)[] ? { [I in keyof Columns]: "column" extends keyof Columns[I] ? Columns[I][keyof Columns[I] & "column"] : Columns[I]; } : never;
+        name: string extends Name ? never : Name;
     };
-    index(columns: (string | TableData.Index.ColumnOrExpressionOptions<string>)[], options?: TableData.Index.OptionsArg | undefined): pqb.NonUniqDataItem;
-    searchIndex(columns: (string | TableData.Index.ColumnOrExpressionOptions<string>)[], options?: TableData.Index.TsVectorArg | undefined): pqb.NonUniqDataItem;
-    exclude(columns: TableData.Exclude.ColumnOrExpressionOptions<string>[], options?: TableData.Exclude.Options | undefined): pqb.NonUniqDataItem;
+    index(columns: (string | TableData.Index.ColumnOrExpressionOptions<string>)[], options?: TableData.Index.OptionsArg): pqb_internal.NonUniqDataItem;
+    searchIndex(columns: (string | TableData.Index.ColumnOrExpressionOptions<string>)[], options?: TableData.Index.TsVectorArg): pqb_internal.NonUniqDataItem;
+    exclude(columns: TableData.Exclude.ColumnOrExpressionOptions<string>[], options?: TableData.Exclude.Options): pqb_internal.NonUniqDataItem;
     foreignKey<Shape>(columns: [string, ...string[]], fnOrTable: () => new () => {
         columns: {
             shape: Shape;
         };
-    }, foreignColumns: [keyof Shape, ...(keyof Shape)[]], options?: TableData.References.Options | undefined): pqb.NonUniqDataItem;
-    foreignKey(columns: [string, ...string[]], fnOrTable: string, foreignColumns: [string, ...string[]], options?: TableData.References.Options | undefined): pqb.NonUniqDataItem;
-    check(check: RawSqlBase, name?: string | undefined): pqb.NonUniqDataItem;
-    sql: pqb.SqlFn;
-    enum(name: string): EnumColumn<pqb.DefaultSchemaConfig, undefined, [string, ...string[]]>;
+    }, foreignColumns: [keyof Shape, ...(keyof Shape)[]], options?: TableData.References.Options): pqb_internal.NonUniqDataItem;
+    foreignKey(columns: [string, ...string[]], fnOrTable: string, foreignColumns: [string, ...string[]], options?: TableData.References.Options): pqb_internal.NonUniqDataItem;
+    check(check: RawSqlBase, name?: string): pqb_internal.NonUniqDataItem;
+    sql: pqb_internal.SqlFn;
+    enum(name: string): EnumColumn<pqb_internal.DefaultSchemaConfig, undefined, [string, ...string[]]>;
 };
 type TableChanger<CT> = MigrationColumnTypes<CT> & TableChangeMethods;
 type TableChangeData = Record<string, RakeDbAst.ChangeTableItem.Column | RakeDbAst.ChangeTableItem.Rename | Change | SpecialChange | Column.Pick.Data>;
@@ -558,15 +558,22 @@ interface SilentQueries extends AdapterBase {
 type DbMigration<CT> = DbResult<CT> & Migration<CT> & {
     adapter: SilentQueries;
 };
+interface MigrationInterfaceResult {
+    adapter: SilentQueries;
+    getDb(columnTypes: unknown): DbMigration<DefaultColumnTypes<DefaultSchemaConfig>>;
+}
 /**
  * Creates a new `db` instance that is an instance of `pqb` with mixed in migration methods from the `Migration` class.
  * It overrides `query` and `array` db adapter methods to intercept SQL for the logging.
  *
+ * A concrete `db` instance depends on column types, column types may vary between `change` calls,
+ * therefore it returns a function that accepts column types, caches db instance per given column types, and return the result.
+ *
  * @param tx - database adapter that executes inside a transaction
  * @param up - migrate or rollback
  * @param config - config of `rakeDb`
  */
-declare const createMigrationInterface: (tx: AdapterBase, up: boolean, config: Pick<RakeDbConfig, 'log' | 'logger' | 'columnTypes'>) => DbMigration<DefaultColumnTypes<DefaultSchemaConfig>>;
+declare const createMigrationInterface: (tx: AdapterBase, up: boolean, config: Pick<RakeDbConfig, "log" | "logger">) => MigrationInterfaceResult;
 type MigrationAdapter = AdapterBase;
 declare class Migration<CT = unknown> {
     adapter: MigrationAdapter;
@@ -1498,6 +1505,131 @@ declare const concatSchemaAndName: ({ schema, name, }: {
     name: string;
 }, excludeCurrentSchema?: string) => string;
 
+interface RakeDbChangeFnConfig {
+    columnTypes: unknown;
+}
+/**
+ * Function to use in migrations to wrap database changes
+ * Saves the given callback to an internal queue,
+ * and also returns the callback in case you want to export it from migration.
+ */
+interface MigrationChangeFn<ColumnTypes> {
+    (fn: ChangeCallback$1<ColumnTypes>): MigrationChange;
+}
+declare const createMigrationChangeFn: <ColumnTypes = DefaultColumnTypes<DefaultSchemaConfig>>(config: {
+    columnTypes?: ColumnTypes;
+}) => MigrationChangeFn<ColumnTypes>;
+interface MigrationChange {
+    fn: ChangeCallback$1<unknown>;
+    config: RakeDbChangeFnConfig;
+}
+type ChangeCallback$1<ColumnTypes> = (db: DbMigration<ColumnTypes>, up: boolean) => Promise<void>;
+
+interface OrmParam {
+    $getAdapter(): AdapterBase;
+}
+type DbParam = OrmParam | AdapterBase;
+
+declare const saveMigratedVersion: (db: SilentQueries, version: string, name: string, config: Pick<RakeDbConfig, "migrationsTable">) => Promise<void>;
+declare const createMigrationsSchemaAndTable: (db: DbParam, config: {
+    migrationsTable: string;
+    logger?: QueryLogger;
+}) => Promise<void>;
+
+interface MigrateFnParams {
+    ctx?: RakeDbCtx;
+    count?: number;
+    force?: boolean;
+}
+interface MigrateConfigBase extends QueryLogOptions {
+    migrationId?: RakeDbMigrationId;
+    renameMigrations?: RakeDbRenameMigrationsInput;
+    migrationsTable?: string;
+    transaction?: 'single' | 'per-migration';
+    transactionSearchPath?: SearchPath;
+    forceDefaultExports?: boolean;
+    beforeChange?: ChangeCallback;
+    afterChange?: ChangeCallback;
+    afterChangeCommit?: ChangeCommitCallback;
+    beforeMigrate?: MigrationCallback;
+    afterMigrate?: MigrationCallback;
+    beforeRollback?: MigrationCallback;
+    afterRollback?: MigrationCallback;
+}
+interface MigrateConfigFileBased extends MigrateConfigBase {
+    basePath?: string;
+    migrationsPath: string;
+    import(path: string): Promise<unknown>;
+}
+interface MigrateConfigMigrationsProvided extends MigrateConfigBase {
+    migrations: ModuleExportsRecord;
+}
+/**
+ * Minimal configuration required by public migration functions
+ * (`migrate`, `rollback`, `redo`) and the functions they invoke.
+ *
+ * Pass `log: true` to enable logging to console,
+ * `log: false` to disable it, or leave `log` undefined to preserve the existing `logger`.
+ *
+ * All properties of {@link RakeDbConfig} that are unrelated to running migrations
+ * (e.g. `commands`, `recurrentPath`, `schemaConfig`) are intentionally excluded.
+ */
+type MigrateConfig = MigrateConfigFileBased | MigrateConfigMigrationsProvided;
+interface MigrateFn {
+    (db: DbParam, config: MigrateConfig, params?: MigrateFnParams): Promise<void>;
+}
+/**
+ * Will run all pending yet migrations, sequentially in order,
+ * will apply `change` functions top-to-bottom.
+ *
+ * Supports `log?: boolean` option in config for programmatic use:
+ * - `log: true` - enables logging to console
+ * - `log: false` - disables logging
+ * - `log: undefined` - preserves existing logger (for custom loggers)
+ *
+ * @param db - database adapter or transaction
+ * @param config - specifies how to load migrations, callbacks, and logger
+ * @param params - optional migration parameters (ctx, count, force)
+ */
+declare const migrate: MigrateFn;
+declare const migrateAndClose: MigrateFn;
+interface RunMigrationConfig extends QueryLogOptions {
+    transactionSearchPath?: SearchPath;
+}
+declare function runMigration(db: DbParam, migration: () => MaybePromise<unknown>): Promise<void>;
+declare function runMigration(db: DbParam, config: RunMigrationConfig, migration: () => MaybePromise<unknown>): Promise<void>;
+/**
+ * Will roll back one latest applied migration,
+ * will apply `change` functions bottom-to-top.
+ *
+ * Supports `log?: boolean` option in config for programmatic use:
+ * - `log: true` - enables logging to console
+ * - `log: false` - disables logging
+ * - `log: undefined` - preserves existing logger (for custom loggers)
+ *
+ * Takes the same options as {@link migrate}.
+ *
+ * @param db - database adapter or transaction
+ * @param config - specifies how to load migrations, callbacks, and logger
+ * @param params - optional rollback parameters (ctx, count, force)
+ */
+declare const rollback: MigrateFn;
+/**
+ * Calls {@link rollback} and then {@link migrate}.
+ *
+ * Supports `log?: boolean` option in config for programmatic use:
+ * - `log: true` - enables logging to console
+ * - `log: false` - disables logging
+ * - `log: undefined` - preserves existing logger (for custom loggers)
+ *
+ * Takes the same options as {@link migrate}.
+ *
+ * @param db - database adapter or transaction
+ * @param config - specifies how to load migrations, callbacks, and logger
+ * @param params - optional redo parameters (ctx, count, force)
+ */
+declare const redo: MigrateFn;
+
 interface MigrationItemHasLoad {
     path?: string;
     /**
@@ -1547,7 +1679,7 @@ interface RakeDbCliConfigInputBase<SchemaConfig extends ColumnSchemaConfig, CT =
      * @param arg.redo - whether it's migrating down and then up for `redo` command
      * @param arg.migrations - array of executed (up or down) migrations
      */
-    beforeChange?: ChangeCallback$1;
+    beforeChange?: ChangeCallback;
     /**
      * Is called once per db after migrating or rolling back a set of migrations.
      * Runs inside the same transaction as migrations,
@@ -1558,7 +1690,7 @@ interface RakeDbCliConfigInputBase<SchemaConfig extends ColumnSchemaConfig, CT =
      * @param arg.redo - whether it's migrating down and then up for `redo` command
      * @param arg.migrations - array of executed (up or down) migrations
      */
-    afterChange?: ChangeCallback$1;
+    afterChange?: ChangeCallback;
     /**
      * Is called once per db after migrating or rolling back a set of migrations.
      * Runs **after** committing migrations transaction.
@@ -1624,8 +1756,8 @@ interface RakeDbConfig<ColumnTypes = unknown> extends QueryLogOptions {
     migrationsTable: string;
     recurrentPath?: string;
     columnTypes: ColumnTypes;
-    beforeChange?: ChangeCallback$1;
-    afterChange?: ChangeCallback$1;
+    beforeChange?: ChangeCallback;
+    afterChange?: ChangeCallback;
     beforeMigrate?: MigrationCallback;
     afterMigrate?: MigrationCallback;
     beforeRollback?: MigrationCallback;
@@ -1648,18 +1780,18 @@ interface RakeDbConfig<ColumnTypes = unknown> extends QueryLogOptions {
     baseTable?: RakeDbBaseTable<unknown>;
     commands: RakeDbCommands;
 }
-declare const migrationConfigDefaults: {
+declare const rakeDbConfigDefaults: {
     schemaConfig: DefaultSchemaConfig;
-    migrationsPath: string;
-    migrationId: {
-        serial: number;
-    };
-    migrationsTable: string;
     snakeCase: boolean;
     commands: {};
     log: boolean;
     logger: Console;
     import(): never;
+    migrationId: {
+        serial: number;
+    };
+    migrationsTable: string;
+    transaction: string;
 };
 interface RakeDbCommandFn {
     (adapters: AdapterBase[], config: RakeDbConfig, args: string[]): MaybePromise<unknown>;
@@ -1673,7 +1805,7 @@ interface RakeDbCommand {
 interface RakeDbCommands {
     [K: string]: RakeDbCommand;
 }
-interface ChangeCallback$1 {
+interface ChangeCallback {
     (arg: {
         db: DbResult<unknown>;
         up: boolean;
@@ -1721,34 +1853,20 @@ interface RakeDbRenameMigrationsInput {
     to: RakeDbMigrationId;
     map: RakeDbRenameMigrationsMap;
 }
-declare const incrementIntermediateCaller: () => void;
-declare const makeRakeDbConfig: <ColumnTypes>(config: RakeDbCliConfigInput<ColumnSchemaConfig, ColumnTypes>, args?: string[]) => RakeDbConfig<ColumnTypes>;
-
-/**
- * Function to use in migrations to wrap database changes
- * Saves the given callback to an internal queue,
- * and also returns the callback in case you want to export it from migration.
- */
-interface RakeDbChangeFn<CT> {
-    (fn: ChangeCallback<CT>): MigrationChange;
-}
-interface MigrationChange {
-    fn: ChangeCallback<unknown>;
-    config: RakeDbConfig;
-}
-type ChangeCallback<CT> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
 
 interface RakeDbCliResult<ColumnTypes, Options> {
-    change: RakeDbChangeFn<ColumnTypes>;
+    change: MigrationChangeFn<ColumnTypes>;
     run(options: Options, args?: string[]): Promise<void>;
 }
 interface RakeDbFn<Options> {
     <SchemaConfig extends ColumnSchemaConfig, ColumnTypes = DefaultColumnTypes<DefaultSchemaConfig>>(config: RakeDbCliConfigInput<SchemaConfig, ColumnTypes> | RakeDbConfig<ColumnTypes>, args?: string[]): RakeDbCliResult<ColumnTypes, Options>;
-    run<SchemaConfig extends ColumnSchemaConfig, ColumnTypes = DefaultColumnTypes<DefaultSchemaConfig>>(options: Options, config: RakeDbCliConfigInput<SchemaConfig, ColumnTypes> | RakeDbConfig<ColumnTypes>, args?: string[]): RakeDbChangeFn<ColumnTypes>;
+    run<SchemaConfig extends ColumnSchemaConfig, ColumnTypes = DefaultColumnTypes<DefaultSchemaConfig>>(options: Options, config: RakeDbCliConfigInput<SchemaConfig, ColumnTypes> | RakeDbConfig<ColumnTypes>, args?: string[]): MigrationChangeFn<ColumnTypes>;
 }
 declare const rakeDbCliWithAdapter: RakeDbFn<MaybeArray<AdapterBase>>;
 declare const setRakeDbCliRunFn: <T>(rakeDbCli: RakeDbFn<T>) => void;
+
 declare const rakeDbCommands: RakeDbCommands;
+declare const incrementIntermediateCaller: () => void;
 
 declare const encodeColumnDefault: (def: unknown, values: unknown[], column?: Column.Pick.Data) => string | null;
 declare const getConstraintName: (table: string, constraint: {
@@ -1781,51 +1899,6 @@ declare const promptSelect: ({ message, options, active, inactive, }: {
     inactive?: (s: string) => string;
 }) => Promise<number>;
 
-interface OrmParam {
-    $getAdapter(): AdapterBase;
-}
-type DbParam = OrmParam | AdapterBase;
-
-declare const saveMigratedVersion: (db: SilentQueries, version: string, name: string, config: Pick<RakeDbConfig, 'migrationsTable'>) => Promise<void>;
-declare const createMigrationsSchemaAndTable: (db: DbParam, config: {
-    migrationsTable: string;
-    logger?: QueryLogger;
-}) => Promise<void>;
-
-interface MigrateFnParams {
-    ctx?: RakeDbCtx;
-    count?: number;
-    force?: boolean;
-}
-interface MigrateFn {
-    (db: DbParam, config: RakeDbConfig, params?: MigrateFnParams): Promise<void>;
-}
-/**
- * Will run all pending yet migrations, sequentially in order,
- * will apply `change` functions top-to-bottom.
- *
- * @param options - options to construct db adapter with
- * @param config - specifies how to load migrations, callbacks, and logger
- * @param args - pass none or `all` to run all migrations, pass int for how many to migrate
- */
-declare const migrate: MigrateFn;
-declare const migrateAndClose: MigrateFn;
-declare function runMigration(db: DbParam, migration: () => MaybePromise<unknown>): Promise<void>;
-declare function runMigration(db: DbParam, config: Pick<RakeDbConfig, 'transactionSearchPath'>, migration: () => MaybePromise<unknown>): Promise<void>;
-/**
- * Will roll back one latest applied migration,
- * will apply `change` functions bottom-to-top.
- *
- * Takes the same options as {@link migrate}.
- */
-declare const rollback: MigrateFn;
-/**
- * Calls {@link rollback} and then {@link migrate}.
- *
- * Takes the same options as {@link migrate}.
- */
-declare const redo: MigrateFn;
-
 declare const astToMigration: (currentSchema: string, config: RakeDbConfig, asts: RakeDbAst[]) => string | undefined;
 
 interface StructureToAstCtx {
@@ -1842,11 +1915,11 @@ interface StructureToAstTableData {
     constraints: DbStructure.Constraint[];
     roles?: DbStructure.Role[];
 }
-declare const makeStructureToAstCtx: (config: Pick<RakeDbConfig, 'snakeCase' | 'schemaConfig'>, currentSchema: string) => StructureToAstCtx;
-declare const structureToAst: (ctx: StructureToAstCtx, adapter: AdapterBase, config: Pick<RakeDbConfig, 'migrationsTable'>) => Promise<RakeDbAst[]>;
+declare const makeStructureToAstCtx: (config: Pick<RakeDbConfig, "snakeCase" | "schemaConfig">, currentSchema: string) => StructureToAstCtx;
+declare const structureToAst: (ctx: StructureToAstCtx, adapter: AdapterBase, config: Pick<RakeDbConfig, "migrationsTable">) => Promise<RakeDbAst[]>;
 declare const makeDomainsMap: (ctx: StructureToAstCtx, data: IntrospectedStructure) => DbStructureDomainsMap;
-declare const instantiateDbColumn: (ctx: StructureToAstCtx, data: IntrospectedStructure, domains: DbStructureDomainsMap, dbColumn: DbStructure.Column) => Column<pqb.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any>;
-declare const tableToAst: (ctx: StructureToAstCtx, data: IntrospectedStructure, table: DbStructure.Table, action: 'create' | 'drop', domains: DbStructureDomainsMap) => RakeDbAst.Table;
+declare const instantiateDbColumn: (ctx: StructureToAstCtx, data: IntrospectedStructure, domains: DbStructureDomainsMap, dbColumn: DbStructure.Column) => Column<pqb_internal.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any>;
+declare const tableToAst: (ctx: StructureToAstCtx, data: IntrospectedStructure, table: DbStructure.Table, action: "create" | "drop", domains: DbStructureDomainsMap) => RakeDbAst.Table;
 declare const getDbStructureTableData: (data: IntrospectedStructure, { name, schemaName }: DbStructure.Table) => StructureToAstTableData;
 interface ColumnChecks {
     [K: string]: string[];
@@ -1912,7 +1985,7 @@ declare const dropDatabase: (db: DbParam, { database }: {
  * const result: 'done' | 'already' = await createSchema(db, '"schema"');
  * ```
  */
-declare const createSchema: (db: DbParam, sql: string) => Promise<'done' | 'already'>;
+declare const createSchema: (db: DbParam, sql: string) => Promise<"done" | "already">;
 /**
  * `dropSchema` uses a savepoint when it is called in a transaction to not break it if the schema does not exist.
  *
@@ -1924,7 +1997,7 @@ declare const createSchema: (db: DbParam, sql: string) => Promise<'done' | 'alre
  * const result: 'done' | 'already' = await dropSchema(db, '"schema"');
  * ```
  */
-declare const dropSchema: (db: DbParam, sql: string) => Promise<'done' | 'already'>;
+declare const dropSchema: (db: DbParam, sql: string) => Promise<"done" | "already">;
 /**
  * `createTable` uses a savepoint when it is called in a transaction to not break it if the table already exists.
  *
@@ -1936,7 +2009,7 @@ declare const dropSchema: (db: DbParam, sql: string) => Promise<'done' | 'alread
  * const result: 'done' | 'already' = await createTable(db, '"table"');
  * ```
  */
-declare const createTable: (db: DbParam, sql: string) => Promise<'done' | 'already'>;
+declare const createTable: (db: DbParam, sql: string) => Promise<"done" | "already">;
 /**
  * `dropTable` uses a savepoint when it is called in a transaction to not break it if the table does not exist.
  *
@@ -1948,9 +2021,10 @@ declare const createTable: (db: DbParam, sql: string) => Promise<'done' | 'alrea
  * const result: 'done' | 'already' = await dropTable(db, '"table"');
  * ```
  */
-declare const dropTable: (db: DbParam, sql: string) => Promise<'done' | 'already'>;
+declare const dropTable: (db: DbParam, sql: string) => Promise<"done" | "already">;
 
 declare class RakeDbError extends Error {
 }
 
-export { type ChangeCallback, type DbMigration, DbStructure, type IntrospectedStructure, RakeDbAst, type RakeDbChangeFn, type RakeDbCliConfigInput, type RakeDbConfig, RakeDbError, type RakeDbFn, type SilentQueries, type StructureToAstCtx, type StructureToAstTableData, astToMigration, concatSchemaAndName, createDatabase, createMigrationInterface, createMigrationsSchemaAndTable, createSchema, createTable, dbColumnToAst, dropDatabase, dropSchema, dropTable, encodeColumnDefault, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getDbVersion, getExcludeName, getIndexName, getMigrationsSchemaAndTable, getSchemaAndTableFromName, incrementIntermediateCaller, instantiateDbColumn, introspectDbSchema, makeDomainsMap, makeFileVersion, makeRakeDbConfig, makeStructureToAstCtx, migrate, migrateAndClose, migrationConfigDefaults, promptSelect, rakeDbCliWithAdapter, rakeDbCommands, redo, rollback, runMigration, saveMigratedVersion, setRakeDbCliRunFn, structureToAst, tableToAst, writeMigrationFile };
+export { DbStructure, RakeDbAst, RakeDbError, astToMigration, concatSchemaAndName, createDatabase, createMigrationChangeFn, createMigrationInterface, createMigrationsSchemaAndTable, createSchema, createTable, dbColumnToAst, dropDatabase, dropSchema, dropTable, encodeColumnDefault, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getDbVersion, getExcludeName, getIndexName, getMigrationsSchemaAndTable, getSchemaAndTableFromName, incrementIntermediateCaller, instantiateDbColumn, introspectDbSchema, makeDomainsMap, makeFileVersion, makeStructureToAstCtx, migrate, migrateAndClose, promptSelect, rakeDbCliWithAdapter, rakeDbCommands, rakeDbConfigDefaults, redo, rollback, runMigration, saveMigratedVersion, setRakeDbCliRunFn, structureToAst, tableToAst, writeMigrationFile };
+export type { ChangeCallback$1 as ChangeCallback, DbMigration, IntrospectedStructure, MigrateConfig, MigrateFn, MigrationChangeFn, RakeDbChangeFnConfig, RakeDbCliConfigInput, RakeDbCliResult, RakeDbConfig, RakeDbFn, SilentQueries, StructureToAstCtx, StructureToAstTableData };