rake-db 2.8.48 → 2.8.49

package/dist/index.d.ts

@@ -65,7 +65,7 @@ type SilentQueries = {
     silentQuery: Adapter['query'];
     silentArrays: Adapter['arrays'];
 };
-type Migration<CT extends ColumnTypesBase = DefaultColumnTypes> = DbResult<CT> & MigrationBase<CT> & {
+type DbMigration<CT extends ColumnTypesBase = DefaultColumnTypes> = DbResult<CT> & Migration<CT> & {
     adapter: SilentQueries;
 };
 type ConstraintArg = {
@@ -79,56 +79,711 @@ type ConstraintArg = {
     check?: RawExpression;
     dropMode?: DropMode;
 };
-declare const createMigrationInterface: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<CT>) => Migration;
-declare class MigrationBase<CT extends ColumnTypesBase> {
+/**
+ * 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.
+ *
+ * @param tx - database adapter that executes inside a transaction
+ * @param up - migrate or rollback
+ * @param config - config of `rakeDb`
+ */
+declare const createMigrationInterface: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(tx: TransactionAdapter, up: boolean, config: RakeDbConfig<CT>) => DbMigration;
+declare class Migration<CT extends ColumnTypesBase> {
     adapter: TransactionAdapter;
     log?: QueryLogObject;
     up: boolean;
     options: RakeDbConfig;
     migratedAsts: RakeDbAst[];
     columnTypes: CT;
-    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, options: TableOptions, fn: ColumnsShapeCallback<CT, Shape>): Promise<CreateTableResult<Table, Shape>>;
+    /**
+     * `createTable` accepts a string for a table name, optional options, and a callback to specify columns.
+     *
+     * `dropTable` accepts the same arguments, it will drop the table when migrating and create a table when rolling back.
+     *
+     * When creating a table within a specific schema, write the table name with schema name: `'schemaName.tableName'`.
+     *
+     * Returns object `{ table: TableInterface }` that allows to insert records right after creating a table.
+     *
+     * Options are:
+     *
+     * ```ts
+     * type TableOptions = {
+     *   // used when reverting a `createTable`
+     *   dropMode?: 'CASCADE' | 'RESTRICT';
+     *
+     *   // add a database comment on the table
+     *   comment?: string;
+     *
+     *   // by default, it will throw an error when the table has no primary key
+     *   // set `noPrimaryKey` to `true` to bypass it
+     *   noPrimaryKey?: boolean;
+     *
+     *   // override rakeDb `snakeCase` option for only this table
+     *   snakeCase?: boolean;
+     * };
+     * ```
+     *
+     * Example:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db, up) => {
+     *   // call `createTable` with options
+     *   await db.createTable(
+     *     'table',
+     *     {
+     *       comment: 'Table comment',
+     *       dropMode: 'CASCADE',
+     *       noPrimaryKey: true,
+     *     },
+     *     (t) => ({
+     *       // ...
+     *     }),
+     *   );
+     *
+     *   // call without options
+     *   const { table } = await db.createTable('user', (t) => ({
+     *     id: t.identity().primaryKey(),
+     *     email: t.text().unique(),
+     *     name: t.text(),
+     *     active: t.boolean().nullable(),
+     *     ...t.timestamps(),
+     *   }));
+     *
+     *   // create records only when migrating up
+     *   if (up) {
+     *     // table is a db table interface, all query methods are available
+     *     await table.createMany([...data]);
+     *   }
+     * });
+     * ```
+     *
+     * @param tableName - name of the table to create
+     * @param fn - create table callback
+     */
     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>>;
+    /**
+     * See {@link createTable}
+     *
+     * @param tableName - name of the table to create
+     * @param options - create table options
+     * @param fn - create table callback
+     */
+    createTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, options: TableOptions, fn: ColumnsShapeCallback<CT, Shape>): 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
+     */
     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>;
+    /**
+     * Drop the table, create it on rollback. See {@link createTable}.
+     *
+     * @param tableName - name of the table to drop
+     * @param options - create table options
+     * @param fn - create table callback
+     */
+    dropTable<Table extends string, Shape extends ColumnsShape>(tableName: Table, options: TableOptions, fn: ColumnsShapeCallback<CT, Shape>): Promise<CreateTableResult<Table, Shape>>;
+    /**
+     * `changeTable` accepts a table name, optional options, and a special callback with column changes.
+     *
+     * When changing a table within a specific schema, write the table name with schema name: `'schemaName.tableName'`.
+     *
+     * Options are:
+     *
+     * ```ts
+     * type ChangeTableOptions = {
+     *   comment?:
+     *     | // add a comment to the table on migrating, remove a comment on rollback
+     *     string // change comment from first to second on migrating, from second to first on rollback
+     *     | [string, string] // remove a comment on both migrate and rollback
+     *     | null;
+     *
+     *   // override rakeDb `snakeCase` option for only this table
+     *   snakeCase?: boolean;
+     * };
+     * ```
+     *
+     * The callback of the `changeTable` is different from `createTable` in the way that it expects columns to be wrapped in change methods such as `add`, `drop`, and `change`.
+     *
+     * @param tableName - name of the table to change (ALTER)
+     * @param fn - change table callback
+     */
     changeTable(tableName: string, fn: ChangeTableCallback<CT>): Promise<void>;
+    /**
+     * See {@link changeTable}
+     *
+     * @param tableName - name of the table to change (ALTER)
+     * @param options - change table options
+     * @param fn - change table callback
+     */
+    changeTable(tableName: string, options: ChangeTableOptions, fn?: ChangeTableCallback<CT>): Promise<void>;
+    /**
+     * Rename a table:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.renameTable('oldTableName', 'newTableName');
+     * });
+     * ```
+     *
+     * @param from - rename the table from
+     * @param to - rename the table to
+     */
     renameTable(from: string, to: string): Promise<void>;
+    /**
+     * Add a column to the table on migrating, and remove it on rollback.
+     *
+     * `dropColumn` takes the same arguments, removes a column on migrate, and adds it on rollback.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.addColumn('tableName', 'columnName', (t) =>
+     *     t.integer().index().nullable(),
+     *   );
+     * });
+     * ```
+     *
+     * @param tableName - name of the table to add the column to
+     * @param columnName - name of the column to add
+     * @param fn - function returning a type of the column
+     */
     addColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes<CT>) => ColumnType): Promise<void>;
+    /**
+     * Drop the schema, create it on rollback. See {@link addIndex}.
+     *
+     * @param tableName - name of the table to add the column to
+     * @param columnName - name of the column to add
+     * @param fn - function returning a type of the column
+     */
     dropColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes<CT>) => ColumnType): Promise<void>;
+    /**
+     * Add an index to the table on migrating, and remove it on rollback.
+     *
+     * `dropIndex` takes the same arguments, removes the index on migrate, and adds it on rollback.
+     *
+     * The first argument is the table name, other arguments are the same as in [composite index](#composite-index).
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.addIndex(
+     *     'tableName',
+     *     ['column1', { column: 'column2', order: 'DESC' }],
+     *     {
+     *       name: 'indexName',
+     *     },
+     *   );
+     * });
+     * ```
+     *
+     * @param tableName - name of the table to add the index for
+     * @param columns - indexed columns
+     * @param options - index options
+     */
     addIndex(tableName: string, columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): 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
+     */
     dropIndex(tableName: string, columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): Promise<void>;
+    /**
+     * Add a foreign key to a table on migrating, and remove it on rollback.
+     *
+     * `dropForeignKey` takes the same arguments, removes the foreign key on migrate, and adds it on rollback.
+     *
+     * Arguments:
+     *
+     * - table name
+     * - column names in the table
+     * - other table name
+     * - column names in the other table
+     * - options:
+     *   - `name`: constraint name
+     *   - `match`: 'FULL', 'PARTIAL', or 'SIMPLE'
+     *   - `onUpdate` and `onDelete`: 'NO ACTION', 'RESTRICT', 'CASCADE', 'SET NULL', or 'SET DEFAULT'
+     *
+     * The first argument is the table name, other arguments are the same as in [composite foreign key](#composite-foreign-key).
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.addForeignKey(
+     *     'tableName',
+     *     ['id', 'name'],
+     *     'otherTable',
+     *     ['foreignId', 'foreignName'],
+     *     {
+     *       name: 'constraintName',
+     *       match: 'FULL',
+     *       onUpdate: 'RESTRICT',
+     *       onDelete: 'CASCADE',
+     *     },
+     *   );
+     * });
+     * ```
+     *
+     * @param tableName - table name
+     * @param columns - column names in the table
+     * @param foreignTable - other table name
+     * @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>;
+    /**
+     * Drop the schema, create it on rollback. See {@link addForeignKey}.
+     *
+     * @param tableName - table name
+     * @param columns - column names in the table
+     * @param foreignTable - other table name
+     * @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>;
+    /**
+     * Add a primary key to a table on migrate, and remove it on rollback.
+     *
+     * `dropPrimaryKey` takes the same arguments, removes the primary key on migrate, and adds it on rollback.
+     *
+     * First argument is a table name, second argument is an array of columns.
+     * The optional third argument may have a name for the primary key constraint.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.addPrimaryKey('tableName', ['id', 'name'], {
+     *     name: 'tablePkeyName',
+     *   });
+     * });
+     * ```
+     *
+     * @param tableName - name of the table
+     * @param columns - array of the columns
+     * @param options - object with a constraint name
+     */
     addPrimaryKey(tableName: string, columns: string[], options?: {
         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
+     */
     dropPrimaryKey(tableName: string, columns: string[], options?: {
         name?: string;
     }): Promise<void>;
+    /**
+     * Add or drop a check for multiple columns.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.addCheck('tableName', t.sql`column > 123`);
+     * });
+     * ```
+     *
+     * @param tableName - name of the table to add the check into
+     * @param check - raw SQL for the check
+     */
     addCheck(tableName: string, check: RawExpression): Promise<void>;
+    /**
+     * Drop the schema, create it on rollback. See {@link addConstraint}.
+     *
+     * @param tableName - name of the table to add the check into
+     * @param check - raw SQL for the check
+     */
     dropCheck(tableName: string, check: RawExpression): 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 column:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.renameColumn('tableName', 'oldColumnName', 'newColumnName');
+     * });
+     * ```
+     *
+     * @param tableName - name of the table to rename the column in
+     * @param from - rename column from
+     * @param to - rename column to
+     */
     renameColumn(tableName: string, from: string, to: string): Promise<void>;
+    /**
+     * `createSchema` creates a database schema, and removes it on rollback.
+     *
+     * `dropSchema` takes the same arguments, removes schema on migration, and adds it on rollback.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createSchema('schemaName');
+     * });
+     * ```
+     *
+     * @param schemaName - name of the schema
+     */
     createSchema(schemaName: string): Promise<void>;
+    /**
+     * Drop the schema, create it on rollback. See {@link createSchema}.
+     *
+     * @param schemaName - name of the schema
+     */
     dropSchema(schemaName: string): Promise<void>;
+    /**
+     * `createExtension` creates a database extension, and removes it on rollback.
+     *
+     * `dropExtension` takes the same arguments, removes the extension on migrate, and adds it on rollback.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createExtension('pg_trgm');
+     * });
+     * ```
+     *
+     * @param name - name of the extension
+     * @param options - extension options
+     */
     createExtension(name: string, options?: Omit<RakeDbAst.Extension, 'type' | 'action' | 'name'>): Promise<void>;
+    /**
+     * Drop the extension, create it on rollback. See {@link createExtension}.
+     *
+     * @param name - name of the extension
+     * @param options - extension options
+     */
     dropExtension(name: string, options?: Omit<RakeDbAst.Extension, 'type' | 'action' | 'name' | 'values'>): Promise<void>;
+    /**
+     * `createEnum` creates an enum on migrate, drops it on rollback.
+     *
+     * `dropEnum` does the opposite.
+     *
+     * Third argument for options is optional.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createEnum('number', ['one', 'two', 'three']);
+     *
+     *   // use `schemaName.enumName` format to specify a schema
+     *   await db.createEnum('customSchema.mood', ['sad', 'ok', 'happy'], {
+     *     // following options are used when dropping enum
+     *     dropIfExists: true,
+     *     cascade: true,
+     *   });
+     * });
+     * ```
+     *
+     * @param name - name of the enum
+     * @param values - possible enum values
+     * @param options - enum options
+     */
     createEnum(name: string, values: [string, ...string[]], options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values' | 'schema'>): Promise<void>;
+    /**
+     * Drop the enum, create it on rollback. See {@link createEnum}.
+     *
+     * @param name - name of the enum
+     * @param values - possible enum values
+     * @param options - enum options
+     */
     dropEnum(name: string, values: [string, ...string[]], options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values' | 'schema'>): Promise<void>;
+    /**
+     * Domain is a custom database type that allows to predefine a `NOT NULL` and a `CHECK` (see [postgres tutorial](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-user-defined-data-types/)).
+     *
+     * `createDomain` and `dropDomain` take a domain name as first argument, callback returning inner column type as a second, and optional object with parameters as third.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createDomain('domainName', (t) => t.integer(), {
+     *     check: db.sql`value = 42`,
+     *   });
+     *
+     *   // use `schemaName.domainName` format to specify a schema
+     *   await db.createDomain('schemaName.domainName', (t) => t.text(), {
+     *     // unlike columns, domain is nullable by default, use notNull when needed:
+     *     notNull: true,
+     *     collation: 'C',
+     *     default: db.sql`'default text'`,
+     *     check: db.sql`length(value) > 10`,
+     *
+     *     // cascade is used when dropping domain
+     *     cascade: true,
+     *   });
+     * });
+     * ```
+     *
+     * @param name - name of the domain
+     * @param fn - function returning a column type for the domain
+     * @param options - domain options
+     */
     createDomain(name: string, fn: (t: CT) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
+    /**
+     * Drop the domain, create it on rollback. See {@link dropDomain}.
+     *
+     * @param name - name of the domain
+     * @param fn - function returning a column type for the domain
+     * @param options - domain options
+     */
     dropDomain(name: string, fn: (t: CT) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
+    /**
+     * Create and drop a database collation, (see [Postgres docs](https://www.postgresql.org/docs/current/sql-createcollation.html)).
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createCollation('myCollation', {
+     *     // This is a shortcut for setting lcCollate and lcCType at once.
+     *     locale: 'en-u-kn-true',
+     *
+     *     // set `lcType` and `lcCType` only if the `locale` is not set.
+     *     // lcType: 'C',
+     *     // lcCType: 'C',
+     *
+     *     // provider can be 'icu' or 'libc'. 'libc' is a default.
+     *     provider: 'icu',
+     *
+     *     // true by default, false is only supported with 'icu' provider.
+     *     deterministic: true,
+     *
+     *     // Is intended to by used by `pg_upgrade`. Normally, it should be omitted.
+     *     version: '1.2.3',
+     *
+     *     // For `CREATE IF NOT EXISTS` when creating.
+     *     createIfNotExists: true,
+     *
+     *     // For `DROP IF EXISTS` when dropping.
+     *     dropIfExists: true,
+     *
+     *     // For `DROP ... CASCADE` when dropping.
+     *     cascase: true,
+     *   });
+     * });
+     * ```
+     *
+     * Instead of specifying the collation options, you can specify a collation to copy options from.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createCollation('myCollation', {
+     *     fromExisting: 'otherCollation',
+     *   });
+     * });
+     * ```
+     *
+     * To create a collation withing a specific database schema, prepend it to the collation name:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createCollation('schemaName.myCollation', {
+     *     // `fromExisting` also can accept a collation name with a schema.
+     *     fromExisting: 'schemaName.otherCollation',
+     *   });
+     * });
+     * ```
+     *
+     * @param name - name of the collation, can contain a name of schema separated with a dot.
+     * @param options - options to create and drop the collation.
+     */
+    createCollation(name: string, options: Omit<RakeDbAst.Collation, 'type' | 'action' | 'schema' | 'name'>): Promise<void>;
+    /**
+     * Drop the collation, create it on rollback. See {@link createCollation}.
+     *
+     * @param name - name of the collation, can contain a name of schema separated with a dot.
+     * @param options - options to create and drop the collation.
+     */
+    dropCollation(name: string, options: Omit<RakeDbAst.Collation, 'type' | 'action' | 'schema' | 'name'>): Promise<void>;
+    /**
+     * Create and drop database views.
+     *
+     * Provide SQL as a string or via `db.sql` that can accept variables.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.createView(
+     *     'simpleView',
+     *     `
+     *     SELECT a.one, b.two
+     *     FROM a
+     *     JOIN b ON b."aId" = a.id
+     *   `,
+     *   );
+     *
+     *   // view can accept db.sql with variables in such way:
+     *   const value = 'some value';
+     *   await db.createView(
+     *     'viewWithVariables',
+     *     db.sql`
+     *       SELECT * FROM a WHERE key = ${value}
+     *     `,
+     *   );
+     *
+     *   // view with options
+     *   await db.createView(
+     *     'schemaName.recursiveView',
+     *     {
+     *       // createOrReplace has effect when creating the view
+     *       createOrReplace: true,
+     *
+     *       // dropIfExists and dropMode have effect when dropping the view
+     *       dropIfExists: true,
+     *       dropMode: 'CASCADE',
+     *
+     *       // for details, check Postgres docs for CREATE VIEW,
+     *       // these options are matching CREATE VIEW options
+     *       temporary: true,
+     *       recursive: true,
+     *       columns: ['n'],
+     *       with: {
+     *         checkOption: 'LOCAL', // or 'CASCADED'
+     *         securityBarrier: true,
+     *         securityInvoker: true,
+     *       },
+     *     },
+     *     `
+     *       VALUES (1)
+     *       UNION ALL
+     *       SELECT n + 1 FROM "schemaName"."recursiveView" WHERE n < 100;
+     *     `,
+     *   );
+     * });
+     * ```
+     *
+     * @param name - name of the view
+     * @param options - view options
+     * @param sql - SQL to create the view with
+     */
     createView(name: string, options: RakeDbAst.ViewOptions, sql: string | RawExpression): Promise<void>;
+    /**
+     * See {@link createView}
+     *
+     * @param name - name of the view
+     * @param sql - SQL to create the view with
+     */
     createView(name: string, sql: string | RawExpression): Promise<void>;
+    /**
+     * Drop the view, create it on rollback. See {@link createView}.
+     *
+     * @param name - name of the view
+     * @param options - view options
+     * @param sql - SQL to create the view with
+     */
     dropView(name: string, options: RakeDbAst.ViewOptions, sql: string | RawExpression): Promise<void>;
+    /**
+     * Drop the view, create it on rollback. See {@link createView}.
+     *
+     * @param name - name of the view
+     * @param sql - SQL to create the view with
+     */
     dropView(name: string, sql: string | RawExpression): Promise<void>;
+    /**
+     * Returns boolean to know if table exists:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   if (await db.tableExists('tableName')) {
+     *     // ...do something
+     *   }
+     * });
+     * ```
+     *
+     * @param tableName - name of the table
+     */
     tableExists(tableName: string): Promise<boolean>;
+    /**
+     * Returns boolean to know if a column exists:
+     *
+     * Note that when `snakeCase` option is set to true, this method won't translate column to snake case, unlike other parts.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   if (await db.columnExists('tableName', 'columnName')) {
+     *     // ...do something
+     *   }
+     * });
+     * ```
+     *
+     * @param tableName - name of the table to check for the column in
+     * @param columnName - name of the column
+     */
     columnExists(tableName: string, columnName: string): Promise<boolean>;
+    /**
+     * Returns boolean to know if constraint exists:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   if (await db.constraintExists('constraintName')) {
+     *     // ...do something
+     *   }
+     * });
+     * ```
+     *
+     * @param constraintName - name of the constraint
+     */
     constraintExists(constraintName: string): Promise<boolean>;
 }
 
-type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameTable | RakeDbAst.Schema | RakeDbAst.Extension | RakeDbAst.Enum | RakeDbAst.Domain | RakeDbAst.Constraint | RakeDbAst.View;
+type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameTable | RakeDbAst.Schema | RakeDbAst.Extension | RakeDbAst.Enum | RakeDbAst.Domain | RakeDbAst.Collation | RakeDbAst.Constraint | RakeDbAst.View;
 declare namespace RakeDbAst {
     type Table = {
         type: 'table';
@@ -228,6 +883,22 @@ declare namespace RakeDbAst {
         check?: RawExpression;
         cascade?: boolean;
     };
+    type Collation = {
+        type: 'collation';
+        action: 'create' | 'drop';
+        schema?: string;
+        name: string;
+        locale?: string;
+        lcCollate?: string;
+        lcCType?: string;
+        provider?: string;
+        deterministic?: boolean;
+        version?: string;
+        fromExisting?: string;
+        createIfNotExists?: boolean;
+        dropIfExists?: boolean;
+        cascade?: boolean;
+    };
     type EnumOptions = {
         createIfNotExists?: boolean;
         dropIfExists?: boolean;
@@ -322,7 +993,7 @@ declare const writeMigrationFile: <CT extends Record<string, orchid_core.AnyColu
 declare const generate: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(config: RakeDbConfig<CT>, [name]: string[]) => Promise<void>;
 declare const makeFileTimeStamp: () => string;
 
-type ChangeCallback<CT extends ColumnTypesBase = ColumnTypesBase> = (db: Migration<CT>, up: boolean) => Promise<void>;
+type ChangeCallback<CT extends ColumnTypesBase = ColumnTypesBase> = (db: DbMigration<CT>, up: boolean) => Promise<void>;
 
 declare const migrateOrRollback: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(options: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>, args: string[], up: boolean) => Promise<void>;
 declare const changeCache: Record<string, ChangeCallback[] | undefined>;
@@ -485,4 +1156,4 @@ declare const saveMigratedVersion: <CT extends Record<string, orchid_core.AnyCol
 declare const removeMigratedVersion: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(db: SilentQueries, version: string, config: RakeDbConfig<CT>) => Promise<void>;
 declare const getMigratedVersionsMap: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(db: Adapter, config: RakeDbConfig<CT>) => Promise<Record<string, boolean>>;
 
-export { AppCodeUpdater, AppCodeUpdaterParams, 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 };
+export { AppCodeUpdater, AppCodeUpdaterParams, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, DbMigration, DropMode, Migration, MigrationColumnTypes, RakeDbAst, RakeDbConfig, SilentQueries, TableOptions, changeCache, createDb, createMigrationInterface, dropDb, generate, getMigratedVersionsMap, makeFileTimeStamp, migrate, migrateOrRollback, rakeDb, redo, removeMigratedVersion, resetDb, rollback, saveMigratedVersion, writeMigrationFile };