rake-db 2.32.2 → 2.33.1

package/dist/index.d.ts

@@ -1,567 +1,522 @@
-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, QueryLogger, QueryLogOptions, MaybePromise, ColumnsByType, DbStructureDomainsMap } from 'pqb/internal';
-import { Db, QuerySchema } from 'pqb';
-
+import { Adapter, Column as Column$1, ColumnSchemaConfig, ColumnsByType, ColumnsShape, DbDomainArg, DbResult, DbStructureDomainsMap, DefaultColumnTypes, DefaultPrivileges, DefaultSchemaConfig, EmptyObject, EnumColumn, MaybeArray, MaybePromise, NoPrimaryKeyOption, QueryLogObject, QueryLogOptions, QueryLogger, QuerySchema, RawSqlBase, RecordOptionalString, RecordString, SearchWeight, TableData, TableDataFn, TableDataItem, TableDataMethods, raw } from "pqb/internal";
+import { Db } from "pqb";
 declare namespace DbStructure {
-    interface TableNameAndSchemaName {
-        schemaName: string;
-        tableName: string;
-    }
-    interface Table {
-        schemaName: string;
-        name: string;
-        comment?: string;
-        columns: Column[];
-    }
-    interface View {
-        schemaName: string;
-        name: string;
-        deps: RakeDbAst.View['deps'];
-        isRecursive: boolean;
-        with?: string[];
-        columns: Column[];
-        sql: string;
-    }
-    interface Procedure {
-        schemaName: string;
-        name: string;
-        returnSet: boolean;
-        returnType: string;
-        kind: string;
-        isTrigger: boolean;
-        types: string[];
-        argTypes: string[];
-        argModes: ('i' | 'o')[];
-        argNames?: string[];
-    }
-    interface Column extends TableNameAndSchemaName {
-        name: string;
-        typeSchema: string;
-        type: string;
-        arrayDims: number;
-        maxChars?: number;
-        numericPrecision?: number;
-        numericScale?: number;
-        dateTimePrecision?: number;
-        default?: string;
-        isNullable: boolean;
-        collate?: string;
-        compression?: 'pglz' | 'lz4';
-        comment?: string;
-        identity?: {
-            always: boolean;
-            start: number;
-            increment: number;
-            min?: number;
-            max?: number;
-            cache: number;
-            cycle: boolean;
-        };
-        extension?: string;
-        typmod: number;
-    }
-    interface Index extends TableNameAndSchemaName {
-        name: string;
-        using: string;
-        unique: boolean;
-        columns: (({
-            column: string;
-        } | {
-            expression: string;
-        }) & {
-            collate?: string;
-            opclass?: string;
-            order?: string;
-            weight?: SearchWeight;
-        })[];
-        include?: string[];
-        nullsNotDistinct?: boolean;
-        with?: string;
-        tablespace?: string;
-        where?: string;
-        tsVector?: boolean;
-        language?: string;
-        languageColumn?: string;
-    }
-    interface Exclude extends Index {
-        exclude: string[];
-    }
-    type ForeignKeyMatch = 'f' | 'p' | 's';
-    type ForeignKeyAction = 'a' | 'r' | 'c' | 'n' | 'd';
-    interface Constraint extends TableNameAndSchemaName {
-        name: string;
-        primaryKey?: string[];
-        references?: References;
-        check?: Check;
-    }
-    interface References {
-        foreignSchema: string;
-        foreignTable: string;
-        columns: string[];
-        foreignColumns: string[];
-        match: ForeignKeyMatch;
-        onUpdate: ForeignKeyAction;
-        onDelete: ForeignKeyAction;
-    }
-    interface Check {
-        columns?: string[];
-        expression: string;
-    }
-    interface Trigger extends TableNameAndSchemaName {
-        triggerSchema: string;
-        name: string;
-        events: string[];
-        activation: string;
-        condition?: string;
-        definition: string;
-    }
-    interface Extension {
-        schemaName: string;
-        name: string;
-        version?: string;
-    }
-    interface Enum {
-        schemaName: string;
-        name: string;
-        values: [string, ...string[]];
-    }
-    interface Domain {
-        schemaName: string;
-        name: string;
-        type: string;
-        typeSchema: string;
-        arrayDims: number;
-        isNullable: boolean;
-        maxChars?: number;
-        numericPrecision?: number;
-        numericScale?: number;
-        dateTimePrecision?: number;
-        collate?: string;
-        default?: string;
-        checks?: string[];
-    }
-    interface Collation {
-        schemaName: string;
-        name: string;
-        provider: string;
-        deterministic: boolean;
-        lcCollate?: string;
-        lcCType?: string;
-        locale?: string;
-        version?: string;
-    }
-    interface Role {
-        name: string;
-        super: boolean;
-        inherit: boolean;
-        createRole: boolean;
-        createDb: boolean;
-        canLogin: boolean;
-        replication: boolean;
-        connLimit: number;
-        validUntil?: Date;
-        bypassRls: boolean;
-        config?: RecordOptionalString;
-    }
-    interface DefaultPrivilegeConfig {
-        privilege: string;
-        isGrantable: boolean;
-    }
-    interface DefaultPrivilegeObjectConfig {
-        object: DefaultPrivileges.ObjectType;
-        privilegeConfigs: DefaultPrivilegeConfig[];
-    }
-    interface DefaultPrivilege {
-        owner?: string;
-        grantee: string;
-        schema?: string;
-        objectConfigs: DefaultPrivilegeObjectConfig[];
-    }
+  interface TableNameAndSchemaName {
+    schemaName: string;
+    tableName: string;
+  }
+  interface Table {
+    schemaName: string;
+    name: string;
+    comment?: string;
+    columns: Column[];
+  }
+  interface View {
+    schemaName: string;
+    name: string;
+    deps: RakeDbAst.View['deps'];
+    isRecursive: boolean;
+    with?: string[];
+    columns: Column[];
+    sql: string;
+  }
+  interface Procedure {
+    schemaName: string;
+    name: string;
+    returnSet: boolean;
+    returnType: string;
+    kind: string;
+    isTrigger: boolean;
+    types: string[];
+    argTypes: string[];
+    argModes: ('i' | 'o')[];
+    argNames?: string[];
+  }
+  interface Column extends TableNameAndSchemaName {
+    name: string;
+    typeSchema: string;
+    type: string;
+    arrayDims: number;
+    maxChars?: number;
+    numericPrecision?: number;
+    numericScale?: number;
+    dateTimePrecision?: number;
+    default?: string;
+    isNullable: boolean;
+    collate?: string;
+    compression?: 'pglz' | 'lz4';
+    comment?: string;
+    identity?: {
+      always: boolean;
+      start: number;
+      increment: number;
+      min?: number;
+      max?: number;
+      cache: number;
+      cycle: boolean;
+    };
+    extension?: string;
+    typmod: number;
+  }
+  interface Index extends TableNameAndSchemaName {
+    name: string;
+    using: string;
+    unique: boolean;
+    columns: (({
+      column: string;
+    } | {
+      expression: string;
+    }) & {
+      collate?: string;
+      opclass?: string;
+      order?: string;
+      weight?: SearchWeight;
+    })[];
+    include?: string[];
+    nullsNotDistinct?: boolean;
+    with?: string;
+    tablespace?: string;
+    where?: string;
+    tsVector?: boolean;
+    language?: string;
+    languageColumn?: string;
+  }
+  interface Exclude extends Index {
+    exclude: string[];
+  }
+  type ForeignKeyMatch = 'f' | 'p' | 's';
+  type ForeignKeyAction = 'a' | 'r' | 'c' | 'n' | 'd';
+  interface Constraint extends TableNameAndSchemaName {
+    name: string;
+    primaryKey?: string[];
+    references?: References;
+    check?: Check;
+  }
+  interface References {
+    foreignSchema: string;
+    foreignTable: string;
+    columns: string[];
+    foreignColumns: string[];
+    match: ForeignKeyMatch;
+    onUpdate: ForeignKeyAction;
+    onDelete: ForeignKeyAction;
+  }
+  interface Check {
+    columns?: string[];
+    expression: string;
+  }
+  interface Trigger extends TableNameAndSchemaName {
+    triggerSchema: string;
+    name: string;
+    events: string[];
+    activation: string;
+    condition?: string;
+    definition: string;
+  }
+  interface Extension {
+    schemaName: string;
+    name: string;
+    version?: string;
+  }
+  interface Enum {
+    schemaName: string;
+    name: string;
+    values: [string, ...string[]];
+  }
+  interface Domain {
+    schemaName: string;
+    name: string;
+    type: string;
+    typeSchema: string;
+    arrayDims: number;
+    isNullable: boolean;
+    maxChars?: number;
+    numericPrecision?: number;
+    numericScale?: number;
+    dateTimePrecision?: number;
+    collate?: string;
+    default?: string;
+    checks?: string[];
+  }
+  interface Collation {
+    schemaName: string;
+    name: string;
+    provider: string;
+    deterministic: boolean;
+    lcCollate?: string;
+    lcCType?: string;
+    locale?: string;
+    version?: string;
+  }
+  interface Role {
+    name: string;
+    super: boolean;
+    inherit: boolean;
+    createRole: boolean;
+    createDb: boolean;
+    canLogin: boolean;
+    replication: boolean;
+    connLimit: number;
+    validUntil?: Date;
+    bypassRls: boolean;
+    config?: RecordOptionalString;
+  }
+  interface DefaultPrivilegeConfig {
+    privilege: string;
+    isGrantable: boolean;
+  }
+  interface DefaultPrivilegeObjectConfig {
+    object: DefaultPrivileges.ObjectType;
+    privilegeConfigs: DefaultPrivilegeConfig[];
+  }
+  interface DefaultPrivilege {
+    owner?: string;
+    grantee: string;
+    schema?: string;
+    objectConfigs: DefaultPrivilegeObjectConfig[];
+  }
 }
 interface IntrospectedStructure {
-    version: number;
-    schemas: string[];
-    tables: DbStructure.Table[];
-    views: DbStructure.View[];
-    indexes: DbStructure.Index[];
-    excludes: DbStructure.Exclude[];
-    constraints: DbStructure.Constraint[];
-    triggers: DbStructure.Trigger[];
-    extensions: DbStructure.Extension[];
-    enums: DbStructure.Enum[];
-    domains: DbStructure.Domain[];
-    collations: DbStructure.Collation[];
-    roles?: DbStructure.Role[];
-    defaultPrivileges?: DbStructure.DefaultPrivilege[];
-    managedRolesSql?: string;
+  version: number;
+  schemas: string[];
+  tables: DbStructure.Table[];
+  views: DbStructure.View[];
+  indexes: DbStructure.Index[];
+  excludes: DbStructure.Exclude[];
+  constraints: DbStructure.Constraint[];
+  triggers: DbStructure.Trigger[];
+  extensions: DbStructure.Extension[];
+  enums: DbStructure.Enum[];
+  domains: DbStructure.Domain[];
+  collations: DbStructure.Collation[];
+  roles?: DbStructure.Role[];
+  defaultPrivileges?: DbStructure.DefaultPrivilege[];
+  managedRolesSql?: string;
 }
 interface IntrospectDbStructureParams {
-    roles?: {
-        whereSql?: string;
-    };
-    loadDefaultPrivileges?: boolean;
+  roles?: {
+    whereSql?: string;
+  };
+  loadDefaultPrivileges?: boolean;
 }
-declare function getDbVersion(db: AdapterBase): Promise<number>;
-declare function introspectDbSchema(db: AdapterBase, params?: IntrospectDbStructureParams): Promise<IntrospectedStructure>;
-
+declare function getDbVersion(db: Adapter): Promise<number>;
+declare function introspectDbSchema(db: Adapter, params?: IntrospectDbStructureParams): Promise<IntrospectedStructure>;
 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 | RakeDbAst.Role | RakeDbAst.RenameRole | RakeDbAst.ChangeRole | RakeDbAst.DefaultPrivilege;
 declare namespace RakeDbAst {
-    export interface Table extends TableData {
-        type: 'table';
-        action: 'create' | 'drop';
-        schema?: string;
-        name: string;
-        shape: ColumnsShape;
-        noPrimaryKey: NoPrimaryKeyOption;
-        createIfNotExists?: boolean;
-        dropIfExists?: boolean;
-        dropMode?: DropMode;
-        comment?: string;
-    }
-    export interface ChangeTable {
-        type: 'changeTable';
-        schema?: string;
-        name: string;
-        comment?: string | [string, string] | null;
-        shape: ChangeTableShape;
-        add: TableData;
-        drop: TableData;
-    }
-    export type ChangeTableShape = Record<string, MaybeArray<ChangeTableItem>>;
-    export type ChangeTableItem = ChangeTableItem.Column | ChangeTableItem.Change | ChangeTableItem.Rename;
-    export namespace ChangeTableItem {
-        interface Column {
-            type: 'add' | 'drop';
-            item: Column;
-            dropMode?: DropMode;
-        }
-        interface Change {
-            type: 'change';
-            name?: string;
-            from: ColumnChange;
-            to: ColumnChange;
-            using?: ChangeUsing;
-        }
-        interface ChangeUsing {
-            usingUp?: RawSqlBase;
-            usingDown?: RawSqlBase;
-        }
-        interface Rename {
-            type: 'rename';
-            name: string;
-        }
-    }
-    export interface ColumnChange {
-        column?: Column;
-        type?: string;
-        collate?: string;
-        default?: unknown | RawSqlBase;
-        nullable?: boolean;
-        comment?: string | null;
-        compression?: string;
-        primaryKey?: boolean;
-        checks?: Column.Data.Check[];
-        foreignKeys?: TableData.ColumnReferences[];
-        indexes?: TableData.ColumnIndex[];
-        excludes?: TableData.ColumnExclude[];
-        identity?: TableData.Identity;
-    }
-    export interface RenameType {
-        type: 'renameType';
-        kind: 'TABLE' | 'TYPE' | 'DOMAIN';
-        fromSchema?: string;
-        from: string;
-        toSchema?: string;
-        to: string;
-    }
-    export interface Schema {
-        type: 'schema';
-        action: 'create' | 'drop';
-        name: string;
-    }
-    export interface RenameSchema {
-        type: 'renameSchema';
-        from: string;
-        to: string;
-    }
-    export interface ExtensionArg {
-        version?: string;
-        cascade?: boolean;
-        createIfNotExists?: boolean;
-        dropIfExists?: boolean;
-    }
-    export interface Extension extends ExtensionArg {
-        type: 'extension';
-        action: 'create' | 'drop';
-        schema?: string;
-        name: string;
-    }
-    export interface Enum {
-        type: 'enum';
-        action: 'create' | 'drop';
-        schema?: string;
-        name: string;
-        values: [string, ...string[]];
-        cascade?: boolean;
-        dropIfExists?: boolean;
-    }
-    export interface EnumValues {
-        type: 'enumValues';
-        action: 'add' | 'drop';
-        schema?: string;
-        name: string;
-        values: string[];
-        place?: 'before' | 'after';
-        relativeTo?: string;
-        ifNotExists?: boolean;
-    }
-    export interface RenameEnumValues {
-        type: 'renameEnumValues';
-        schema?: string;
-        name: string;
-        values: RecordString;
-    }
-    export interface ChangeEnumValues {
-        type: 'changeEnumValues';
-        schema?: string;
-        name: string;
-        fromValues: string[];
-        toValues: string[];
-    }
-    export interface Domain {
-        type: 'domain';
-        action: 'create' | 'drop';
-        schema?: string;
-        name: string;
-        baseType: Column;
-    }
-    export interface 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;
-    }
-    export interface EnumOptions {
-        createIfNotExists?: boolean;
-        dropIfExists?: boolean;
-    }
-    export interface Constraint extends TableData.Constraint {
-        type: 'constraint';
-        action: 'create' | 'drop';
-        tableSchema?: string;
-        tableName: string;
-    }
-    export interface RenameTableItem {
-        type: 'renameTableItem';
-        kind: 'INDEX' | 'CONSTRAINT';
-        tableSchema?: string;
-        tableName: string;
-        from: string;
-        to: string;
-    }
-    export interface View {
-        type: 'view';
-        action: 'create' | 'drop';
-        schema?: string;
-        name: string;
-        shape: ColumnsShape;
-        sql: RawSqlBase;
-        options: ViewOptions;
-        deps: {
-            schemaName: string;
-            name: string;
-        }[];
-    }
-    export interface ViewOptions {
-        createOrReplace?: boolean;
-        dropIfExists?: boolean;
-        dropMode?: DropMode;
-        temporary?: boolean;
-        recursive?: boolean;
-        columns?: string[];
-        with?: {
-            checkOption?: 'LOCAL' | 'CASCADED';
-            securityBarrier?: boolean;
-            securityInvoker?: boolean;
-        };
-    }
-    export interface Role extends DbStructure.Role {
-        type: 'role';
-        action: 'create' | 'drop';
-    }
-    export interface RenameRole {
-        type: 'renameRole';
-        from: string;
-        to: string;
-    }
-    export interface ChangeRole {
-        type: 'changeRole';
-        name: string;
-        from: Partial<DbStructure.Role>;
-        to: Partial<DbStructure.Role>;
+  export interface Table extends TableData {
+    type: 'table';
+    action: 'create' | 'drop';
+    schema?: string;
+    name: string;
+    shape: ColumnsShape;
+    noPrimaryKey: NoPrimaryKeyOption;
+    createIfNotExists?: boolean;
+    dropIfExists?: boolean;
+    dropMode?: DropMode;
+    comment?: string;
+  }
+  export interface ChangeTable {
+    type: 'changeTable';
+    schema?: string;
+    name: string;
+    comment?: string | [string, string] | null;
+    shape: ChangeTableShape;
+    add: TableData;
+    drop: TableData;
+  }
+  export type ChangeTableShape = Record<string, MaybeArray<ChangeTableItem>>;
+  export type ChangeTableItem = ChangeTableItem.Column | ChangeTableItem.Change | ChangeTableItem.Rename;
+  export namespace ChangeTableItem {
+    interface Column {
+      type: 'add' | 'drop';
+      item: Column$1;
+      dropMode?: DropMode;
     }
-    interface DefaultPrivilegeSetting {
-        privileges?: string[];
-        grantablePrivileges?: string[];
+    interface Change {
+      type: 'change';
+      name?: string;
+      from: ColumnChange;
+      to: ColumnChange;
+      using?: ChangeUsing;
     }
-    export interface DefaultPrivilegeObjectConfig {
-        tables?: DefaultPrivilegeSetting;
-        sequences?: DefaultPrivilegeSetting;
-        functions?: DefaultPrivilegeSetting;
-        types?: DefaultPrivilegeSetting;
-        schemas?: DefaultPrivilegeSetting;
-        largeObjects?: DefaultPrivilegeSetting;
+    interface ChangeUsing {
+      usingUp?: RawSqlBase;
+      usingDown?: RawSqlBase;
     }
-    export interface DefaultPrivilege {
-        type: 'defaultPrivilege';
-        owner?: string;
-        grantee: string;
-        schema?: string;
-        grant?: DefaultPrivilegeObjectConfig;
-        revoke?: DefaultPrivilegeObjectConfig;
+    interface Rename {
+      type: 'rename';
+      name: string;
     }
-    export {};
-}
-
-declare function add(item: Column, options?: {
+  }
+  export interface ColumnChange {
+    column?: Column$1;
+    type?: string;
+    collate?: string;
+    default?: unknown | RawSqlBase;
+    nullable?: boolean;
+    comment?: string | null;
+    compression?: string;
+    primaryKey?: boolean;
+    checks?: Column$1.Data.Check[];
+    foreignKeys?: TableData.ColumnReferences[];
+    indexes?: TableData.ColumnIndex[];
+    excludes?: TableData.ColumnExclude[];
+    identity?: TableData.Identity;
+  }
+  export interface RenameType {
+    type: 'renameType';
+    kind: 'TABLE' | 'TYPE' | 'DOMAIN';
+    fromSchema?: string;
+    from: string;
+    toSchema?: string;
+    to: string;
+  }
+  export interface Schema {
+    type: 'schema';
+    action: 'create' | 'drop';
+    name: string;
+  }
+  export interface RenameSchema {
+    type: 'renameSchema';
+    from: string;
+    to: string;
+  }
+  export interface ExtensionArg {
+    version?: string;
+    cascade?: boolean;
+    createIfNotExists?: boolean;
+    dropIfExists?: boolean;
+  }
+  export interface Extension extends ExtensionArg {
+    type: 'extension';
+    action: 'create' | 'drop';
+    schema?: string;
+    name: string;
+  }
+  export interface Enum {
+    type: 'enum';
+    action: 'create' | 'drop';
+    schema?: string;
+    name: string;
+    values: [string, ...string[]];
+    cascade?: boolean;
+    dropIfExists?: boolean;
+  }
+  export interface EnumValues {
+    type: 'enumValues';
+    action: 'add' | 'drop';
+    schema?: string;
+    name: string;
+    values: string[];
+    place?: 'before' | 'after';
+    relativeTo?: string;
+    ifNotExists?: boolean;
+  }
+  export interface RenameEnumValues {
+    type: 'renameEnumValues';
+    schema?: string;
+    name: string;
+    values: RecordString;
+  }
+  export interface ChangeEnumValues {
+    type: 'changeEnumValues';
+    schema?: string;
+    name: string;
+    fromValues: string[];
+    toValues: string[];
+  }
+  export interface Domain {
+    type: 'domain';
+    action: 'create' | 'drop';
+    schema?: string;
+    name: string;
+    baseType: Column$1;
+  }
+  export interface 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;
+  }
+  export interface EnumOptions {
+    createIfNotExists?: boolean;
+    dropIfExists?: boolean;
+  }
+  export interface Constraint extends TableData.Constraint {
+    type: 'constraint';
+    action: 'create' | 'drop';
+    tableSchema?: string;
+    tableName: string;
+  }
+  export interface RenameTableItem {
+    type: 'renameTableItem';
+    kind: 'INDEX' | 'CONSTRAINT';
+    tableSchema?: string;
+    tableName: string;
+    from: string;
+    to: string;
+  }
+  export interface View {
+    type: 'view';
+    action: 'create' | 'drop';
+    schema?: string;
+    name: string;
+    shape: ColumnsShape;
+    sql: RawSqlBase;
+    options: ViewOptions;
+    deps: {
+      schemaName: string;
+      name: string;
+    }[];
+  }
+  export interface ViewOptions {
+    createOrReplace?: boolean;
+    dropIfExists?: boolean;
     dropMode?: DropMode;
+    temporary?: boolean;
+    recursive?: boolean;
+    columns?: string[];
+    with?: {
+      checkOption?: 'LOCAL' | 'CASCADED';
+      securityBarrier?: boolean;
+      securityInvoker?: boolean;
+    };
+  }
+  export interface Role extends DbStructure.Role {
+    type: 'role';
+    action: 'create' | 'drop';
+  }
+  export interface RenameRole {
+    type: 'renameRole';
+    from: string;
+    to: string;
+  }
+  export interface ChangeRole {
+    type: 'changeRole';
+    name: string;
+    from: Partial<DbStructure.Role>;
+    to: Partial<DbStructure.Role>;
+  }
+  interface DefaultPrivilegeSetting {
+    privileges?: string[];
+    grantablePrivileges?: string[];
+  }
+  export interface DefaultPrivilegeObjectConfig {
+    tables?: DefaultPrivilegeSetting;
+    sequences?: DefaultPrivilegeSetting;
+    functions?: DefaultPrivilegeSetting;
+    types?: DefaultPrivilegeSetting;
+    schemas?: DefaultPrivilegeSetting;
+    largeObjects?: DefaultPrivilegeSetting;
+  }
+  export interface DefaultPrivilege {
+    type: 'defaultPrivilege';
+    owner?: string;
+    grantee: string;
+    schema?: string;
+    grant?: DefaultPrivilegeObjectConfig;
+    revoke?: DefaultPrivilegeObjectConfig;
+  }
+  export {};
+}
+interface TableMethods {
+  enum(name: string): EnumColumn<DefaultSchemaConfig, undefined, [string, ...string[]]>;
+}
+type Add = typeof add;
+declare function add(item: Column$1, options?: {
+  dropMode?: DropMode;
 }): SpecialChange;
 declare function add(emptyObject: EmptyObject): SpecialChange;
-declare function add(items: Record<string, Column>, options?: {
-    dropMode?: DropMode;
+declare function add(items: Record<string, Column$1>, options?: {
+  dropMode?: DropMode;
 }): Record<string, RakeDbAst.ChangeTableItem.Column>;
-interface Change extends RakeDbAst.ChangeTableItem.Change, ChangeOptions {
-}
+interface Change extends RakeDbAst.ChangeTableItem.Change, ChangeOptions {}
 type ChangeOptions = RakeDbAst.ChangeTableItem.ChangeUsing;
 interface SpecialChange {
-    type: SpecialChange;
+  type: SpecialChange;
 }
 interface OneWayChange {
-    type: 'change';
-    name?: string;
-    to: RakeDbAst.ColumnChange;
-    using?: RakeDbAst.ChangeTableItem.ChangeUsing;
+  type: 'change';
+  name?: string;
+  to: RakeDbAst.ColumnChange;
+  using?: RakeDbAst.ChangeTableItem.ChangeUsing;
+}
+interface TableChangeMethods extends TableMethods, TableDataMethods<string> {
+  name(name: string): TableChangeMethods;
+  add: Add;
+  drop: Add;
+  change(from: Column$1 | OneWayChange, to: Column$1 | OneWayChange, using?: ChangeOptions): Change;
+  default(value: unknown | RawSqlBase): OneWayChange;
+  nullable(): OneWayChange;
+  nonNullable(): OneWayChange;
+  comment(comment: string | null): OneWayChange;
+  rename(name: string): RakeDbAst.ChangeTableItem.Rename;
 }
-type TableChangeMethods = typeof tableChangeMethods;
-declare const tableChangeMethods: {
-    name(name: string): any;
-    add: typeof add;
-    drop: typeof add;
-    change(from: Column | OneWayChange, to: Column | OneWayChange, using?: ChangeOptions): Change;
-    default(value: unknown | RawSqlBase): OneWayChange;
-    nullable(): OneWayChange;
-    nonNullable(): OneWayChange;
-    comment(comment: string | null): OneWayChange;
-    /**
-     * Rename a column:
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.changeTable('table', (t) => ({
-     *     oldColumnName: t.rename('newColumnName'),
-     *   }));
-     * });
-     * ```
-     *
-     * Note that the renaming `ALTER TABLE` is executed before the rest of alterations,
-     * so if you're also adding a new constraint on this column inside the same `changeTable`,
-     * refer to it with a new name.
-     *
-     * @param name
-     */
-    rename(name: string): RakeDbAst.ChangeTableItem.Rename;
-    primaryKey<Columns extends [string, ...string[]], Name extends string>(columns: Columns, name?: Name | undefined): {
-        tableDataItem: true;
-        columns: Columns;
-        name: string extends Name ? never : Name;
-    };
-    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 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): 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): 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>;
-
+type TableChangeData = Record<string, RakeDbAst.ChangeTableItem.Column | RakeDbAst.ChangeTableItem.Rename | Change | SpecialChange | Column$1.Pick.Data>;
 interface DefaultPrivilegeObjectSetting<T> {
-    privileges?: readonly T[];
-    grantablePrivileges?: readonly T[];
+  privileges?: readonly T[];
+  grantablePrivileges?: readonly T[];
 }
-interface DefaultPrivilegeObjectConfig {
-    all?: boolean;
-    allGrantable?: boolean;
-    tables?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['Table']>;
-    sequences?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['Sequence']>;
-    functions?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['Function']>;
-    types?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['Type']>;
-    schemas?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['Schema']>;
-    largeObjects?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['LargeObject']>;
+interface DefaultPrivilegeObjectConfig$1 {
+  all?: boolean;
+  allGrantable?: boolean;
+  tables?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['Table']>;
+  sequences?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['Sequence']>;
+  functions?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['Function']>;
+  types?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['Type']>;
+  schemas?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['Schema']>;
+  largeObjects?: DefaultPrivilegeObjectSetting<DefaultPrivileges.Privilege['LargeObject']>;
 }
 interface ChangeDefaultPrivilegesArg {
-    owner?: string;
-    grantee: string;
-    schema?: string;
-    grant?: DefaultPrivilegeObjectConfig;
-    revoke?: DefaultPrivilegeObjectConfig;
+  owner?: string;
+  grantee: string;
+  schema?: string;
+  grant?: DefaultPrivilegeObjectConfig$1;
+  revoke?: DefaultPrivilegeObjectConfig$1;
 }
-
 type DropMode = 'CASCADE' | 'RESTRICT';
 type TableOptions = {
-    createIfNotExists?: boolean;
-    dropIfExists?: boolean;
-    dropMode?: DropMode;
-    comment?: string;
-    noPrimaryKey?: boolean;
-    snakeCase?: boolean;
-    language?: string;
+  createIfNotExists?: boolean;
+  dropIfExists?: boolean;
+  dropMode?: DropMode;
+  comment?: string;
+  noPrimaryKey?: boolean;
+  snakeCase?: boolean;
+  language?: string;
 };
 type MigrationColumnTypes<CT> = Omit<CT, 'enum'> & {
-    enum: (name: string) => EnumColumn<ColumnSchemaConfig, unknown, readonly string[]>;
+  enum: (name: string) => EnumColumn<ColumnSchemaConfig, unknown, readonly string[]>;
 };
 type ColumnsShapeCallback<CT, Shape extends ColumnsShape = ColumnsShape> = (t: MigrationColumnTypes<CT> & {
-    raw: typeof raw;
+  raw: typeof raw;
 }) => Shape;
 type ChangeTableOptions = {
-    snakeCase?: boolean;
-    language?: string;
-    comment?: string | [string, string] | null;
+  snakeCase?: boolean;
+  language?: string;
+  comment?: string | [string, string] | null;
 };
 type ChangeTableCallback<CT> = (t: TableChanger<CT>) => TableChangeData;
-interface SilentQueries extends AdapterBase {
-    silentQuery: AdapterBase['query'];
-    silentArrays: AdapterBase['arrays'];
+interface SilentQueries extends MigrationAdapter {
+  silentQuery: Adapter['query'];
+  silentArrays: Adapter['arrays'];
 }
 type DbMigration<CT> = DbResult<CT> & Migration<CT> & {
-    adapter: SilentQueries;
+  adapter: SilentQueries;
 };
 interface MigrationInterfaceResult {
-    adapter: SilentQueries;
-    getDb(columnTypes: unknown): DbMigration<DefaultColumnTypes<DefaultSchemaConfig>>;
+  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.
@@ -574,940 +529,940 @@ interface MigrationInterfaceResult {
  * @param up - migrate or rollback
  * @param config - config of `rakeDb`
  */
-declare const createMigrationInterface: (tx: AdapterBase, up: boolean, config: Pick<RakeDbConfig, "log" | "logger">) => MigrationInterfaceResult;
-type MigrationAdapter = AdapterBase;
+declare const createMigrationInterface: (tx: Adapter, up: boolean, config: Pick<RakeDbConfig, "log" | "logger">) => MigrationInterfaceResult;
+type MigrationAdapter = Adapter;
 declare class Migration<CT = unknown> {
-    adapter: MigrationAdapter;
-    log?: QueryLogObject;
-    up: boolean;
-    options: RakeDbConfig;
-    columnTypes: CT;
-    /**
-     * `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.
-     *
-     * To create an empty table, the callback with columns may be omitted.
-     *
-     * 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 = {
-     *   // create the table only if it not exists already
-     *   createIfNotExists?: boolean;
-     *
-     *   // drop the table only if it exists
-     *   dropIfExists?: boolean;
-     *
-     *   // 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
-     * @param dataFn - callback for creating composite indexes, primary keys, foreign keys
-     */
-    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>, 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>, 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>, dataFn?: TableDataFn<Shape, MaybeArray<TableDataItem>>): 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');
-     * });
-     * ```
-     *
-     * Prefix table name with a schema to set a different schema:
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.renameTable('fromSchema.oldTable', 'toSchema.newTable');
-     * });
-     * ```
-     *
-     * @param from - rename the table from
-     * @param to - rename the table to
-     */
-    renameTable(from: string, to: string): Promise<void>;
-    /**
-     * Set a different schema to the table:
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.changeTableSchema('tableName', 'fromSchema', 'toSchema');
-     * });
-     * ```
-     *
-     * @param table - table name
-     * @param from - current table schema
-     * @param to - desired table schema
-     */
-    changeTableSchema(table: string, 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>) => Column): Promise<void>;
-    /**
-     * 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
-     * @param fn - function returning a type of the column
-     */
-    dropColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes<CT>) => Column): 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 args - index options
-     */
-    addIndex(tableName: string, columns: (string | TableData.Index.ColumnOrExpressionOptions)[], ...args: [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 args - index options
-     */
-    dropIndex(tableName: string, columns: (string | TableData.Index.ColumnOrExpressionOptions)[], ...args: [options?: TableData.Index.OptionsArg]): Promise<void>;
-    /**
-     * Rename index:
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   // tableName can be prefixed with a schema
-     *   await db.renameIndex('tableName', 'oldIndexName', 'newIndexName');
-     * });
-     * ```
-     *
-     * @param tableName - table which this index belongs to
-     * @param from - rename the index from
-     * @param to - rename the index to
-     */
-    renameIndex(tableName: string, from: string, to: string): 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?: TableData.References.Options): 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?: TableData.References.Options): 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 name - optionally, set a primary key constraint name
-     */
-    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 name - optionally, set a primary key constraint name
-     */
-    dropPrimaryKey(tableName: string, columns: [string, ...string[]], 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: RawSqlBase): Promise<void>;
-    /**
-     * 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>;
-    /**
-     * Rename a table constraint such as a primary key or a database check.
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.renameConstraint(
-     *     'tableName', // may include schema: 'schema.table'
-     *     'oldConstraintName',
-     *     'newConstraintName',
-     *   );
-     * });
-     * ```
-     *
-     * @param tableName - name of the table containing the constraint, may include schema name, may include schema name
-     * @param from - current name of the constraint
-     * @param to - desired name
-     */
-    renameConstraint(tableName: string, from: string, to: string): 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>;
-    /**
-     * Renames a database schema, renames it backwards on roll back.
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.renameSchema('from', 'to');
-     * });
-     * ```
-     *
-     * @param from - existing schema to rename
-     * @param to - desired schema name
-     */
-    renameSchema(from: string, to: 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?: RakeDbAst.ExtensionArg): 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?: RakeDbAst.ExtensionArg): 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>;
-    /**
-     * Use these methods to add or drop one or multiple values from an existing enum.
-     *
-     * `addEnumValues` will drop values when rolling back the migration.
-     *
-     * Dropping a value internally acts in multiple steps:
-     *
-     * 1. Select all columns from the database that depends on the enum;
-     * 2. Alter all these columns to have text type;
-     * 3. Drop the enum;
-     * 4. Re-create the enum without the value given;
-     * 5. Alter all columns from the first step to have the enum type;
-     *
-     * In the case when the value is used by some table,
-     * migrating `dropEnumValue` or rolling back `addEnumValue` will throw an error with a descriptive message,
-     * in such case you'd need to manually resolve the issue by deleting rows with the value, or changing such values.
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.addEnumValue('numbers', 'four');
-     *
-     *   // you can pass options
-     *   await db.addEnumValue('numbers', 'three', {
-     *     // where to insert
-     *     before: 'four',
-     *     // skip if already exists
-     *     ifNotExists: true,
-     *   });
-     *
-     *   // enum name can be prefixed with schema
-     *   await db.addEnumValue('public.numbers', 'five', {
-     *     after: 'four',
-     *   });
-     * });
-     * ```
-     *
-     * @param enumName - target enum name
-     * @param values - array of values to add
-     * @param options - optional object with options
-     * @param options.before - insert before the specified value
-     * @param options.after - insert after the specified value
-     * @param options.ifNotExists - skip adding if already exists
-     */
-    addEnumValues(enumName: string, values: string[], options?: AddEnumValueOptions): Promise<void>;
-    /**
-     * See {@link addEnumValues}
-     */
-    dropEnumValues(enumName: string, values: string[], options?: AddEnumValueOptions): Promise<void>;
-    /**
-     * Rename one or multiple enum values using this method:
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   // rename value "from" to "to"
-     *   await db.rename('numbers', { from: 'to' });
-     *
-     *   // enum name can be prefixed with schema
-     *   await db.rename('public.numbers', { from: 'to' });
-     * });
-     * ```
-     *
-     * @param enumName - target enum name, can be prefixed with schema
-     * @param values - object where keys are for old names, values are for new names
-     */
-    renameEnumValues(enumName: string, values: RecordString): Promise<void>;
-    /**
-     * Drops the enum and re-creates it with a new set of values.
-     * Before dropping, changes all related column types to text, and after creating changes types back to the enum,
-     * in the same way as [dropEnumValues](/guide/migration-writing.html#addenumvalues,-dropenumvalues) works.
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.changeEnumValues(
-     *     // can be prefixed with schema: 'public.numbers'
-     *     'numbers',
-     *     // change from:
-     *     ['one', 'two'],
-     *     // change to:
-     *     ['three', 'four'],
-     *   );
-     * });
-     * ```
-     *
-     * @param enumName - target enum name, can be prefixed with schema
-     * @param fromValues - array of values before the change
-     * @param toValues - array of values to set
-     */
-    changeEnumValues(enumName: string, fromValues: string[], toValues: string[]): Promise<void>;
-    /**
-     * Rename a type (such as enum):
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.renameType('oldTypeName', 'newTypeName');
-     * });
-     * ```
-     *
-     * Prefix the type name with a schema to set a different schema:
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.renameType('fromSchema.oldType', 'toSchema.newType');
-     * });
-     * ```
-     *
-     * @param from - rename the type from
-     * @param to - rename the type to
-     */
-    renameType(from: string, to: string): Promise<void>;
-    /**
-     * Set a different schema to the type (such as enum):
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.changeTypeSchema('typeName', 'fromSchema', 'toSchema');
-     * });
-     * ```
-     *
-     * @param name - type name
-     * @param from - current table schema
-     * @param to - desired table schema
-     */
-    changeTypeSchema(name: string, from: string, to: string): Promise<void>;
-    /**
-     * Domain is a custom database type that is based on other type and can include `NOT NULL` and a `CHECK` (see [postgres tutorial](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-user-defined-data-types/)).
-     *
-     * Construct a column type in the function as the second argument.
-     *
-     * Specifiers [nullable](/guide/common-column-methods.html#nullable), [default](/guide/common-column-methods.html#default), [check](/guide/migration-column-methods.html#check), [collate](/guide/migration-column-methods.html#collate)
-     * will be saved to the domain type on database level.
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.createDomain('domainName', (t) =>
-     *     t.integer().check(t.sql`value = 42`),
-     *   );
-     *
-     *   // use `schemaName.domainName` format to specify a schema
-     *   await db.createDomain('schemaName.domainName', (t) =>
-     *     t
-     *       .text()
-     *       .nullable()
-     *       .collate('C')
-     *       .default('default text')
-     *       .check(t.sql`length(value) > 10`),
-     *   );
-     * });
-     * ```
-     *
-     * @param name - name of the domain
-     * @param fn - function returning a column type. Options `nullable`, `collate`, `default`, `check` will be applied to domain
-     */
-    createDomain(name: string, fn: DbDomainArg<CT>): 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. Options `nullable`, `collate`, `default`, `check` will be applied to domain
-     */
-    dropDomain(name: string, fn: DbDomainArg<CT>): Promise<void>;
-    /**
-     * To rename a domain:
-     *
-     * ```ts
-     * import { change } from '../dbScript';
-     *
-     * change(async (db) => {
-     *   await db.renameDomain('oldName', 'newName');
-     *
-     *   // to move domain to a different schema
-     *   await db.renameDomain('oldSchema.domain', 'newSchema.domain');
-     * });
-     * ```
-     *
-     * @param from - old domain name (can include schema)
-     * @param to - new domain name (can include schema)
-     */
-    renameDomain(from: string, to: string): 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 `t.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 t.sql with variables in such way:
-     *   const value = 'some value';
-     *   await db.createView(
-     *     'viewWithVariables',
-     *     t.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 | RawSqlBase): Promise<void>;
-    /**
-     * See {@link createView}
-     *
-     * @param name - name of the view
-     * @param sql - SQL to create the view with
-     */
-    createView(name: string, sql: string | RawSqlBase): 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 | RawSqlBase): 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 | RawSqlBase): 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>;
-    createRole(name: string, params?: Partial<DbStructure.Role>): Promise<void>;
-    dropRole(name: string, params?: Partial<DbStructure.Role>): Promise<void>;
-    renameRole(from: string, to: string): Promise<void>;
-    changeRole(name: string, params: {
-        from?: Partial<DbStructure.Role>;
-        to: Partial<DbStructure.Role>;
-    }): Promise<void>;
-    changeDefaultPrivileges(params: ChangeDefaultPrivilegesArg): Promise<void>;
+  adapter: MigrationAdapter;
+  log?: QueryLogObject;
+  up: boolean;
+  options: RakeDbConfig;
+  columnTypes: CT;
+  /**
+   * `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.
+   *
+   * To create an empty table, the callback with columns may be omitted.
+   *
+   * 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 = {
+   *   // create the table only if it not exists already
+   *   createIfNotExists?: boolean;
+   *
+   *   // drop the table only if it exists
+   *   dropIfExists?: boolean;
+   *
+   *   // 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
+   * @param dataFn - callback for creating composite indexes, primary keys, foreign keys
+   */
+  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>, 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>, 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>, dataFn?: TableDataFn<Shape, MaybeArray<TableDataItem>>): 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');
+   * });
+   * ```
+   *
+   * Prefix table name with a schema to set a different schema:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameTable('fromSchema.oldTable', 'toSchema.newTable');
+   * });
+   * ```
+   *
+   * @param from - rename the table from
+   * @param to - rename the table to
+   */
+  renameTable(from: string, to: string): Promise<void>;
+  /**
+   * Set a different schema to the table:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.changeTableSchema('tableName', 'fromSchema', 'toSchema');
+   * });
+   * ```
+   *
+   * @param table - table name
+   * @param from - current table schema
+   * @param to - desired table schema
+   */
+  changeTableSchema(table: string, 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>) => Column$1): Promise<void>;
+  /**
+   * 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
+   * @param fn - function returning a type of the column
+   */
+  dropColumn(tableName: string, columnName: string, fn: (t: MigrationColumnTypes<CT>) => Column$1): 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 args - index options
+   */
+  addIndex(tableName: string, columns: (string | TableData.Index.ColumnOrExpressionOptions)[], ...args: [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 args - index options
+   */
+  dropIndex(tableName: string, columns: (string | TableData.Index.ColumnOrExpressionOptions)[], ...args: [options?: TableData.Index.OptionsArg]): Promise<void>;
+  /**
+   * Rename index:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   // tableName can be prefixed with a schema
+   *   await db.renameIndex('tableName', 'oldIndexName', 'newIndexName');
+   * });
+   * ```
+   *
+   * @param tableName - table which this index belongs to
+   * @param from - rename the index from
+   * @param to - rename the index to
+   */
+  renameIndex(tableName: string, from: string, to: string): 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?: TableData.References.Options): 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?: TableData.References.Options): 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 name - optionally, set a primary key constraint name
+   */
+  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 name - optionally, set a primary key constraint name
+   */
+  dropPrimaryKey(tableName: string, columns: [string, ...string[]], 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: RawSqlBase): Promise<void>;
+  /**
+   * 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>;
+  /**
+   * Rename a table constraint such as a primary key or a database check.
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameConstraint(
+   *     'tableName', // may include schema: 'schema.table'
+   *     'oldConstraintName',
+   *     'newConstraintName',
+   *   );
+   * });
+   * ```
+   *
+   * @param tableName - name of the table containing the constraint, may include schema name, may include schema name
+   * @param from - current name of the constraint
+   * @param to - desired name
+   */
+  renameConstraint(tableName: string, from: string, to: string): 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>;
+  /**
+   * Renames a database schema, renames it backwards on roll back.
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameSchema('from', 'to');
+   * });
+   * ```
+   *
+   * @param from - existing schema to rename
+   * @param to - desired schema name
+   */
+  renameSchema(from: string, to: 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?: RakeDbAst.ExtensionArg): 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?: RakeDbAst.ExtensionArg): 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>;
+  /**
+   * Use these methods to add or drop one or multiple values from an existing enum.
+   *
+   * `addEnumValues` will drop values when rolling back the migration.
+   *
+   * Dropping a value internally acts in multiple steps:
+   *
+   * 1. Select all columns from the database that depends on the enum;
+   * 2. Alter all these columns to have text type;
+   * 3. Drop the enum;
+   * 4. Re-create the enum without the value given;
+   * 5. Alter all columns from the first step to have the enum type;
+   *
+   * In the case when the value is used by some table,
+   * migrating `dropEnumValue` or rolling back `addEnumValue` will throw an error with a descriptive message,
+   * in such case you'd need to manually resolve the issue by deleting rows with the value, or changing such values.
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.addEnumValue('numbers', 'four');
+   *
+   *   // you can pass options
+   *   await db.addEnumValue('numbers', 'three', {
+   *     // where to insert
+   *     before: 'four',
+   *     // skip if already exists
+   *     ifNotExists: true,
+   *   });
+   *
+   *   // enum name can be prefixed with schema
+   *   await db.addEnumValue('public.numbers', 'five', {
+   *     after: 'four',
+   *   });
+   * });
+   * ```
+   *
+   * @param enumName - target enum name
+   * @param values - array of values to add
+   * @param options - optional object with options
+   * @param options.before - insert before the specified value
+   * @param options.after - insert after the specified value
+   * @param options.ifNotExists - skip adding if already exists
+   */
+  addEnumValues(enumName: string, values: string[], options?: AddEnumValueOptions): Promise<void>;
+  /**
+   * See {@link addEnumValues}
+   */
+  dropEnumValues(enumName: string, values: string[], options?: AddEnumValueOptions): Promise<void>;
+  /**
+   * Rename one or multiple enum values using this method:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   // rename value "from" to "to"
+   *   await db.rename('numbers', { from: 'to' });
+   *
+   *   // enum name can be prefixed with schema
+   *   await db.rename('public.numbers', { from: 'to' });
+   * });
+   * ```
+   *
+   * @param enumName - target enum name, can be prefixed with schema
+   * @param values - object where keys are for old names, values are for new names
+   */
+  renameEnumValues(enumName: string, values: RecordString): Promise<void>;
+  /**
+   * Drops the enum and re-creates it with a new set of values.
+   * Before dropping, changes all related column types to text, and after creating changes types back to the enum,
+   * in the same way as [dropEnumValues](/guide/migration-writing.html#addenumvalues,-dropenumvalues) works.
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.changeEnumValues(
+   *     // can be prefixed with schema: 'public.numbers'
+   *     'numbers',
+   *     // change from:
+   *     ['one', 'two'],
+   *     // change to:
+   *     ['three', 'four'],
+   *   );
+   * });
+   * ```
+   *
+   * @param enumName - target enum name, can be prefixed with schema
+   * @param fromValues - array of values before the change
+   * @param toValues - array of values to set
+   */
+  changeEnumValues(enumName: string, fromValues: string[], toValues: string[]): Promise<void>;
+  /**
+   * Rename a type (such as enum):
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameType('oldTypeName', 'newTypeName');
+   * });
+   * ```
+   *
+   * Prefix the type name with a schema to set a different schema:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameType('fromSchema.oldType', 'toSchema.newType');
+   * });
+   * ```
+   *
+   * @param from - rename the type from
+   * @param to - rename the type to
+   */
+  renameType(from: string, to: string): Promise<void>;
+  /**
+   * Set a different schema to the type (such as enum):
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.changeTypeSchema('typeName', 'fromSchema', 'toSchema');
+   * });
+   * ```
+   *
+   * @param name - type name
+   * @param from - current table schema
+   * @param to - desired table schema
+   */
+  changeTypeSchema(name: string, from: string, to: string): Promise<void>;
+  /**
+   * Domain is a custom database type that is based on other type and can include `NOT NULL` and a `CHECK` (see [postgres tutorial](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-user-defined-data-types/)).
+   *
+   * Construct a column type in the function as the second argument.
+   *
+   * Specifiers [nullable](/guide/common-column-methods.html#nullable), [default](/guide/common-column-methods.html#default), [check](/guide/migration-column-methods.html#check), [collate](/guide/migration-column-methods.html#collate)
+   * will be saved to the domain type on database level.
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.createDomain('domainName', (t) =>
+   *     t.integer().check(t.sql`value = 42`),
+   *   );
+   *
+   *   // use `schemaName.domainName` format to specify a schema
+   *   await db.createDomain('schemaName.domainName', (t) =>
+   *     t
+   *       .text()
+   *       .nullable()
+   *       .collate('C')
+   *       .default('default text')
+   *       .check(t.sql`length(value) > 10`),
+   *   );
+   * });
+   * ```
+   *
+   * @param name - name of the domain
+   * @param fn - function returning a column type. Options `nullable`, `collate`, `default`, `check` will be applied to domain
+   */
+  createDomain(name: string, fn: DbDomainArg<CT>): 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. Options `nullable`, `collate`, `default`, `check` will be applied to domain
+   */
+  dropDomain(name: string, fn: DbDomainArg<CT>): Promise<void>;
+  /**
+   * To rename a domain:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameDomain('oldName', 'newName');
+   *
+   *   // to move domain to a different schema
+   *   await db.renameDomain('oldSchema.domain', 'newSchema.domain');
+   * });
+   * ```
+   *
+   * @param from - old domain name (can include schema)
+   * @param to - new domain name (can include schema)
+   */
+  renameDomain(from: string, to: string): 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 `t.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 t.sql with variables in such way:
+   *   const value = 'some value';
+   *   await db.createView(
+   *     'viewWithVariables',
+   *     t.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 | RawSqlBase): Promise<void>;
+  /**
+   * See {@link createView}
+   *
+   * @param name - name of the view
+   * @param sql - SQL to create the view with
+   */
+  createView(name: string, sql: string | RawSqlBase): 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 | RawSqlBase): 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 | RawSqlBase): 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>;
+  createRole(name: string, params?: Partial<DbStructure.Role>): Promise<void>;
+  dropRole(name: string, params?: Partial<DbStructure.Role>): Promise<void>;
+  renameRole(from: string, to: string): Promise<void>;
+  changeRole(name: string, params: {
+    from?: Partial<DbStructure.Role>;
+    to: Partial<DbStructure.Role>;
+  }): Promise<void>;
+  changeDefaultPrivileges(params: ChangeDefaultPrivilegesArg): Promise<void>;
 }
 interface AddEnumValueOptions {
-    ifNotExists?: boolean;
-    before?: string;
-    after?: string;
+  ifNotExists?: boolean;
+  before?: string;
+  after?: string;
 }
-
 interface CreateTableResult<Table extends string, Shape extends ColumnsShape> {
-    table: Db<Table, Shape>;
+  table: Db<Table, Shape>;
 }
-
 interface RakeDbCtx {
-    migrationsPromise?: Promise<MigrationsSet>;
+  migrationsPromise?: Promise<MigrationsSet>;
 }
 declare const getSchemaAndTableFromName: (schema: QuerySchema | undefined, name: string) => [string | undefined, string];
-declare const concatSchemaAndName: ({ schema, name, }: {
-    schema?: string;
-    name: string;
+declare const concatSchemaAndName: ({
+  schema,
+  name
+}: {
+  schema?: string;
+  name: string;
 }, excludeCurrentSchema?: string) => string;
-
 interface RakeDbChangeFnConfig {
-    columnTypes: unknown;
+  columnTypes: unknown;
 }
 /**
  * Function to use in migrations to wrap database changes
@@ -1515,59 +1470,56 @@ interface RakeDbChangeFnConfig {
  * and also returns the callback in case you want to export it from migration.
  */
 interface MigrationChangeFn<ColumnTypes> {
-    (fn: ChangeCallback$1<ColumnTypes>): MigrationChange;
+  (fn: ChangeCallback<ColumnTypes>): MigrationChange;
 }
 declare const createMigrationChangeFn: <ColumnTypes = DefaultColumnTypes<DefaultSchemaConfig>>(config: {
-    columnTypes?: ColumnTypes;
+  columnTypes?: ColumnTypes;
 }) => MigrationChangeFn<ColumnTypes>;
 interface MigrationChange {
-    fn: ChangeCallback$1<unknown>;
-    config: RakeDbChangeFnConfig;
+  fn: ChangeCallback<unknown>;
+  config: RakeDbChangeFnConfig;
 }
-type ChangeCallback$1<ColumnTypes> = (db: DbMigration<ColumnTypes>, up: boolean) => Promise<void>;
-
+type ChangeCallback<ColumnTypes> = (db: DbMigration<ColumnTypes>, up: boolean) => Promise<void>;
 interface OrmParam {
-    $getAdapter(): AdapterBase;
+  $getAdapter(): Adapter;
 }
-type DbParam = OrmParam | AdapterBase;
-
+type DbParam = OrmParam | Adapter;
 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;
+  migrationsTable: string;
+  logger?: QueryLogger;
 }) => Promise<void>;
-
 interface MigrateFnParams {
-    ctx?: RakeDbCtx;
-    count?: number;
-    force?: boolean;
+  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;
-    snakeCase?: boolean;
-    language?: string;
-    noPrimaryKey?: NoPrimaryKeyOption;
-    baseTable?: RakeDbBaseTable<unknown>;
+  migrationId?: RakeDbMigrationId;
+  renameMigrations?: RakeDbRenameMigrationsInput;
+  migrationsTable?: string;
+  transaction?: 'single' | 'per-migration';
+  transactionSearchPath?: SearchPath;
+  forceDefaultExports?: boolean;
+  beforeChange?: ChangeCallback$1;
+  afterChange?: ChangeCallback$1;
+  afterChangeCommit?: ChangeCommitCallback;
+  beforeMigrate?: MigrationCallback;
+  afterMigrate?: MigrationCallback;
+  beforeRollback?: MigrationCallback;
+  afterRollback?: MigrationCallback;
+  snakeCase?: boolean;
+  language?: string;
+  noPrimaryKey?: NoPrimaryKeyOption;
+  baseTable?: RakeDbBaseTable<unknown>;
 }
 interface MigrateConfigFileBased extends MigrateConfigBase {
-    basePath?: string;
-    migrationsPath: string;
-    import(path: string): Promise<unknown>;
+  basePath?: string;
+  migrationsPath: string;
+  import(path: string): Promise<unknown>;
 }
 interface MigrateConfigMigrationsProvided extends MigrateConfigBase {
-    migrations: ModuleExportsRecord;
+  migrations: ModuleExportsRecord;
 }
 /**
  * Minimal configuration required by public migration functions
@@ -1581,7 +1533,7 @@ interface MigrateConfigMigrationsProvided extends MigrateConfigBase {
  */
 type MigrateConfig = MigrateConfigFileBased | MigrateConfigMigrationsProvided;
 interface MigrateFn {
-    (db: DbParam, config: MigrateConfig, params?: MigrateFnParams): Promise<void>;
+  (db: DbParam, config: MigrateConfig, params?: MigrateFnParams): Promise<void>;
 }
 /**
  * Will run all pending yet migrations, sequentially in order,
@@ -1599,7 +1551,7 @@ interface MigrateFn {
 declare const migrate: MigrateFn;
 declare const migrateAndClose: MigrateFn;
 interface RunMigrationConfig extends QueryLogOptions {
-    transactionSearchPath?: SearchPath;
+  transactionSearchPath?: SearchPath;
 }
 declare function runMigration(db: DbParam, migration: () => MaybePromise<unknown>): Promise<void>;
 declare function runMigration(db: DbParam, config: RunMigrationConfig, migration: () => MaybePromise<unknown>): Promise<void>;
@@ -1634,315 +1586,313 @@ declare const rollback: MigrateFn;
  * @param params - optional redo parameters (ctx, count, force)
  */
 declare const redo: MigrateFn;
-
 interface MigrationItemHasLoad {
-    path?: string;
-    /**
-     * Function that loads the migration content,
-     * can store lazy import of a migration file.
-     * Promise can return `{ default: x }` where `x` is a return of `change` or an array of such returns.
-     */
-    load(): MaybePromise<unknown>;
+  path?: string;
+  /**
+   * Function that loads the migration content,
+   * can store lazy import of a migration file.
+   * Promise can return `{ default: x }` where `x` is a return of `change` or an array of such returns.
+   */
+  load(): MaybePromise<unknown>;
 }
 interface MigrationItem extends MigrationItemHasLoad {
-    path: string;
-    version: string;
+  path: string;
+  version: string;
 }
 interface MigrationsSet {
-    renameTo?: RakeDbRenameMigrations;
-    migrations: MigrationItem[];
+  renameTo?: RakeDbRenameMigrations;
+  migrations: MigrationItem[];
 }
-
 type SearchPath = (() => string) | string;
 interface RakeDbCliConfigInputBase<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends QueryLogOptions {
-    columnTypes?: CT | ((t: DefaultColumnTypes<DefaultSchemaConfig>) => CT);
-    baseTable?: RakeDbBaseTable<CT>;
-    schemaConfig?: SchemaConfig;
-    basePath?: string;
-    dbScript?: string;
-    migrationId?: 'serial' | RakeDbMigrationId;
-    recurrentPath?: string;
-    migrationsTable?: string;
-    snakeCase?: boolean;
-    language?: string;
-    commands?: {
-        [commandName: string]: RakeDbCommandFn | RakeDbCommand;
-    };
-    noPrimaryKey?: NoPrimaryKeyOption;
-    transactionSearchPath?: SearchPath;
-    /**
-     * Throw if a migration doesn't have a default export.
-     * This is needed when in your setup you're importing migration files first and execute them later,
-     * in that case you should export changes in migrations.
-     */
-    forceDefaultExports?: boolean;
-    /**
-     * Is called once per db before migrating or rolling back a set of migrations.
-     *
-     * @param arg.db - query builder
-     * @param arg.up - whether it's migrating up or down
-     * @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;
-    /**
-     * Is called once per db after migrating or rolling back a set of migrations.
-     * Runs inside the same transaction as migrations,
-     * for running after commit use {@link afterChangeCommit}.
-     *
-     * @param arg.db - query builder
-     * @param arg.up - whether it's migrating up or down
-     * @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;
-    /**
-     * Is called once per db after migrating or rolling back a set of migrations.
-     * Runs **after** committing migrations transaction.
-     *
-     * @param arg.options - database connection options
-     * @param arg.up - whether it's migrating up or down
-     * @param arg.migrations - array of executed (up or down) migrations
-     */
-    afterChangeCommit?: ChangeCommitCallback;
-    /**
-     * Is called once per db before migrating (up) a set of migrations.
-     *
-     * @param arg.db - query builder
-     * @param arg.migrations - applied migrations
-     */
-    beforeMigrate?: MigrationCallback;
-    /**
-     * Is called once per db after migrating (up) a set of migrations.
-     *
-     * @param arg.db - query builder
-     * @param arg.migrations - applied migrations
-     */
-    afterMigrate?: MigrationCallback;
-    /**
-     * Is called once per db before rolling back a set of migrations.
-     *
-     * @param arg.db - query builder
-     * @param arg.migrations - rolled back migrations
-     */
-    beforeRollback?: MigrationCallback;
-    /**
-     * Is called once per db before rolling back a set of migrations.
-     *
-     * @param arg.db - query builder
-     * @param arg.migrations - rolled back migrations
-     */
-    afterRollback?: MigrationCallback;
-    /**
-     * It may look odd, but it's required for `tsx` and other bundlers to have such `import` config specified explicitly.
-     */
-    import?(path: string): Promise<unknown>;
+  columnTypes?: CT | ((t: DefaultColumnTypes<DefaultSchemaConfig>) => CT);
+  baseTable?: RakeDbBaseTable<CT>;
+  schemaConfig?: SchemaConfig;
+  basePath?: string;
+  dbScript?: string;
+  migrationId?: 'serial' | RakeDbMigrationId;
+  recurrentPath?: string;
+  migrationsTable?: string;
+  snakeCase?: boolean;
+  language?: string;
+  commands?: {
+    [commandName: string]: RakeDbCommandFn | RakeDbCommand;
+  };
+  noPrimaryKey?: NoPrimaryKeyOption;
+  transactionSearchPath?: SearchPath;
+  /**
+   * Throw if a migration doesn't have a default export.
+   * This is needed when in your setup you're importing migration files first and execute them later,
+   * in that case you should export changes in migrations.
+   */
+  forceDefaultExports?: boolean;
+  /**
+   * Is called once per db before migrating or rolling back a set of migrations.
+   *
+   * @param arg.db - query builder
+   * @param arg.up - whether it's migrating up or down
+   * @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;
+  /**
+   * Is called once per db after migrating or rolling back a set of migrations.
+   * Runs inside the same transaction as migrations,
+   * for running after commit use {@link afterChangeCommit}.
+   *
+   * @param arg.db - query builder
+   * @param arg.up - whether it's migrating up or down
+   * @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;
+  /**
+   * Is called once per db after migrating or rolling back a set of migrations.
+   * Runs **after** committing migrations transaction.
+   *
+   * @param arg.options - database connection options
+   * @param arg.up - whether it's migrating up or down
+   * @param arg.migrations - array of executed (up or down) migrations
+   */
+  afterChangeCommit?: ChangeCommitCallback;
+  /**
+   * Is called once per db before migrating (up) a set of migrations.
+   *
+   * @param arg.db - query builder
+   * @param arg.migrations - applied migrations
+   */
+  beforeMigrate?: MigrationCallback;
+  /**
+   * Is called once per db after migrating (up) a set of migrations.
+   *
+   * @param arg.db - query builder
+   * @param arg.migrations - applied migrations
+   */
+  afterMigrate?: MigrationCallback;
+  /**
+   * Is called once per db before rolling back a set of migrations.
+   *
+   * @param arg.db - query builder
+   * @param arg.migrations - rolled back migrations
+   */
+  beforeRollback?: MigrationCallback;
+  /**
+   * Is called once per db before rolling back a set of migrations.
+   *
+   * @param arg.db - query builder
+   * @param arg.migrations - rolled back migrations
+   */
+  afterRollback?: MigrationCallback;
+  /**
+   * It may look odd, but it's required for `tsx` and other bundlers to have such `import` config specified explicitly.
+   */
+  import?(path: string): Promise<unknown>;
 }
 interface RakeDbCliConfigInputFileBased<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends RakeDbCliConfigInputBase<SchemaConfig, CT> {
-    migrationsPath?: string;
-    /**
-     * required for `tsx` and other bundlers to have such `import` config specified explicitly.
-     */
-    import(path: string): Promise<unknown>;
+  migrationsPath?: string;
+  /**
+   * required for `tsx` and other bundlers to have such `import` config specified explicitly.
+   */
+  import(path: string): Promise<unknown>;
 }
 interface RakeDbCliConfigInputCodeBased<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> extends RakeDbCliConfigInputBase<SchemaConfig, CT> {
-    /**
-     * To specify array of migrations explicitly, without loading them from files.
-     */
-    migrations: ModuleExportsRecord;
-    renameMigrations?: RakeDbRenameMigrationsInput;
+  /**
+   * To specify array of migrations explicitly, without loading them from files.
+   */
+  migrations: ModuleExportsRecord;
+  renameMigrations?: RakeDbRenameMigrationsInput;
 }
 type RakeDbCliConfigInput<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<DefaultSchemaConfig>> = RakeDbCliConfigInputFileBased<SchemaConfig, CT> | RakeDbCliConfigInputCodeBased<SchemaConfig, CT>;
 interface RakeDbConfig<ColumnTypes = unknown> extends QueryLogOptions {
-    /**
-     * Set by makeRakeDbConfig to distinguish between the user-provided initial config from the processed one.
-     */
-    __rakeDbConfig: true;
-    migrationsTable: string;
-    recurrentPath?: string;
-    columnTypes: ColumnTypes;
-    beforeChange?: ChangeCallback;
-    afterChange?: ChangeCallback;
-    beforeMigrate?: MigrationCallback;
-    afterMigrate?: MigrationCallback;
-    beforeRollback?: MigrationCallback;
-    afterRollback?: MigrationCallback;
-    migrationId: RakeDbMigrationId;
-    transactionSearchPath?: SearchPath;
-    forceDefaultExports?: boolean;
-    afterChangeCommit?: ChangeCommitCallback;
-    basePath: string;
-    import(path: string): Promise<unknown>;
-    migrationsPath: string;
-    transaction: 'single' | 'per-migration';
-    snakeCase?: boolean;
-    schemaConfig: ColumnSchemaConfig;
-    migrations?: ModuleExportsRecord;
-    dbScript: string;
-    renameMigrations?: RakeDbRenameMigrationsInput;
-    language?: string;
-    noPrimaryKey?: NoPrimaryKeyOption;
-    baseTable?: RakeDbBaseTable<unknown>;
-    commands: RakeDbCommands;
+  /**
+   * Set by makeRakeDbConfig to distinguish between the user-provided initial config from the processed one.
+   */
+  __rakeDbConfig: true;
+  migrationsTable: string;
+  recurrentPath?: string;
+  columnTypes: ColumnTypes;
+  beforeChange?: ChangeCallback$1;
+  afterChange?: ChangeCallback$1;
+  beforeMigrate?: MigrationCallback;
+  afterMigrate?: MigrationCallback;
+  beforeRollback?: MigrationCallback;
+  afterRollback?: MigrationCallback;
+  migrationId: RakeDbMigrationId;
+  transactionSearchPath?: SearchPath;
+  forceDefaultExports?: boolean;
+  afterChangeCommit?: ChangeCommitCallback;
+  basePath: string;
+  import(path: string): Promise<unknown>;
+  migrationsPath: string;
+  transaction: 'single' | 'per-migration';
+  snakeCase?: boolean;
+  schemaConfig: ColumnSchemaConfig;
+  migrations?: ModuleExportsRecord;
+  dbScript: string;
+  renameMigrations?: RakeDbRenameMigrationsInput;
+  language?: string;
+  noPrimaryKey?: NoPrimaryKeyOption;
+  baseTable?: RakeDbBaseTable<unknown>;
+  commands: RakeDbCommands;
 }
 declare const rakeDbConfigDefaults: {
-    schemaConfig: DefaultSchemaConfig;
-    snakeCase: boolean;
-    commands: {};
-    log: boolean;
-    logger: Console;
-    import(): never;
-    migrationId: {
-        serial: number;
-    };
-    migrationsTable: string;
-    transaction: string;
+  schemaConfig: any;
+  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>;
+  (adapters: Adapter[], config: RakeDbConfig, args: string[]): MaybePromise<unknown>;
 }
 interface RakeDbCommand {
-    run: RakeDbCommandFn;
-    help?: string;
-    helpArguments?: RecordString;
-    helpAfter?: string;
+  run: RakeDbCommandFn;
+  help?: string;
+  helpArguments?: RecordString;
+  helpAfter?: string;
 }
 interface RakeDbCommands {
-    [K: string]: RakeDbCommand;
+  [K: string]: RakeDbCommand;
 }
-interface ChangeCallback {
-    (arg: {
-        db: DbResult<unknown>;
-        up: boolean;
-        redo: boolean;
-        migrations: MigrationItem[];
-    }): void | Promise<void>;
+interface ChangeCallback$1 {
+  (arg: {
+    db: DbResult<unknown>;
+    up: boolean;
+    redo: boolean;
+    migrations: MigrationItem[];
+  }): void | Promise<void>;
 }
 interface ChangeCommitCallback {
-    (arg: {
-        adapter: AdapterBase;
-        up: boolean;
-        migrations: MigrationItem[];
-    }): void | Promise<void>;
+  (arg: {
+    adapter: Adapter;
+    up: boolean;
+    migrations: MigrationItem[];
+  }): void | Promise<void>;
 }
 interface MigrationCallback {
-    (arg: {
-        db: DbResult<unknown>;
-        migrations: MigrationItem[];
-    }): void | Promise<void>;
+  (arg: {
+    db: DbResult<unknown>;
+    migrations: MigrationItem[];
+  }): void | Promise<void>;
 }
 interface RakeDbBaseTable<CT> {
-    exportAs: string;
-    getFilePath(): string;
-    nowSQL?: string;
-    new (): {
-        types: CT;
-        snakeCase?: boolean;
-        language?: string;
-    };
+  exportAs: string;
+  getFilePath(): string;
+  nowSQL?: string;
+  new (): {
+    types: CT;
+    snakeCase?: boolean;
+    language?: string;
+  };
 }
 interface ModuleExportsRecord {
-    [fileName: string]: () => Promise<unknown>;
+  [fileName: string]: () => Promise<unknown>;
 }
 type RakeDbMigrationId = 'timestamp' | {
-    serial: number;
+  serial: number;
 };
 interface RakeDbRenameMigrationsMap {
-    [K: string]: number;
+  [K: string]: number;
 }
 interface RakeDbRenameMigrations {
-    to: RakeDbMigrationId;
-    map(): MaybePromise<RakeDbRenameMigrationsMap>;
+  to: RakeDbMigrationId;
+  map(): MaybePromise<RakeDbRenameMigrationsMap>;
 }
 interface RakeDbRenameMigrationsInput {
-    to: RakeDbMigrationId;
-    map: RakeDbRenameMigrationsMap;
+  to: RakeDbMigrationId;
+  map: RakeDbRenameMigrationsMap;
 }
-
 interface RakeDbCliResult<ColumnTypes, Options> {
-    change: MigrationChangeFn<ColumnTypes>;
-    run(options: Options, args?: string[]): Promise<void>;
+  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[]): MigrationChangeFn<ColumnTypes>;
+  <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[]): MigrationChangeFn<ColumnTypes>;
 }
-declare const rakeDbCliWithAdapter: RakeDbFn<MaybeArray<AdapterBase>>;
+declare const rakeDbCliWithAdapter: RakeDbFn<MaybeArray<Adapter>>;
 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 encodeColumnDefault: (def: unknown, values: unknown[], column?: Column$1.Pick.Data) => string | null;
 declare const getConstraintName: (table: string, constraint: {
-    references?: {
-        columns: string[];
-    };
-    check?: unknown;
-    identity?: unknown;
+  references?: {
+    columns: string[];
+  };
+  check?: unknown;
+  identity?: unknown;
 }, snakeCase: boolean | undefined) => string;
 interface GetIndexOrExcludeName {
-    (table: string, columns: ({
-        column?: string;
-    } | {
-        expression: string;
-    })[]): string;
+  (table: string, columns: ({
+    column?: string;
+  } | {
+    expression: string;
+  })[]): string;
 }
 declare const getIndexName: GetIndexOrExcludeName;
 declare const getExcludeName: GetIndexOrExcludeName;
-declare const getMigrationsSchemaAndTable: (adapter: AdapterBase, config: {
-    migrationsTable: string;
+declare const getMigrationsSchemaAndTable: (adapter: Adapter, config: {
+  migrationsTable: string;
 }) => {
-    schema?: string;
-    table: string;
+  schema?: string;
+  table: string;
 };
-
-declare const promptSelect: ({ message, options, active, inactive, }: {
-    message: string;
-    options: string[];
-    active?: (s: string) => string;
-    inactive?: (s: string) => string;
+declare const promptSelect: ({
+  message,
+  options,
+  active,
+  inactive
+}: {
+  message: string;
+  options: string[];
+  active?: (s: string) => string;
+  inactive?: (s: string) => string;
 }) => Promise<number>;
-
 declare const astToMigration: (currentSchema: string, config: RakeDbConfig, asts: RakeDbAst[]) => string | undefined;
-
 interface StructureToAstCtx {
-    snakeCase?: boolean;
-    unsupportedTypes: Record<string, string[]>;
-    currentSchema: string;
-    columnSchemaConfig: ColumnSchemaConfig;
-    columnsByType: ColumnsByType;
+  snakeCase?: boolean;
+  unsupportedTypes: Record<string, string[]>;
+  currentSchema: string;
+  columnSchemaConfig: ColumnSchemaConfig;
+  columnsByType: ColumnsByType;
 }
 interface StructureToAstTableData {
-    primaryKey?: TableData.PrimaryKey;
-    indexes: DbStructure.Index[];
-    excludes: DbStructure.Exclude[];
-    constraints: DbStructure.Constraint[];
-    roles?: DbStructure.Role[];
+  primaryKey?: TableData.PrimaryKey;
+  indexes: DbStructure.Index[];
+  excludes: DbStructure.Exclude[];
+  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 structureToAst: (ctx: StructureToAstCtx, adapter: Adapter, 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_internal.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any>;
+declare const instantiateDbColumn: (ctx: StructureToAstCtx, data: IntrospectedStructure, domains: DbStructureDomainsMap, dbColumn: DbStructure.Column) => Column$1;
 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;
+declare const getDbStructureTableData: (data: IntrospectedStructure, {
+  name,
+  schemaName
+}: DbStructure.Table) => StructureToAstTableData;
 interface ColumnChecks {
-    [K: string]: string[];
+  [K: string]: string[];
 }
 declare const getDbTableColumnsChecks: (tableData: StructureToAstTableData) => ColumnChecks;
-declare const dbColumnToAst: (ctx: StructureToAstCtx, data: IntrospectedStructure, domains: DbStructureDomainsMap, tableName: string, item: DbStructure.Column, table?: DbStructure.Table, tableData?: StructureToAstTableData, checks?: ColumnChecks) => [key: string, column: Column];
-
+declare const dbColumnToAst: (ctx: StructureToAstCtx, data: IntrospectedStructure, domains: DbStructureDomainsMap, tableName: string, item: DbStructure.Column, table?: DbStructure.Table, tableData?: StructureToAstTableData, checks?: ColumnChecks) => [key: string, column: Column$1];
 declare const writeMigrationFile: (config: RakeDbConfig, version: string, name: string, migrationCode: string) => Promise<void>;
 declare const makeFileVersion: (ctx: RakeDbCtx, config: RakeDbConfig) => Promise<string>;
-
 type CreateOrDropOk = 'done' | 'already';
 /**
- * To create a database, reconfigure the connection with a power user and an existing database to connect to.
+ * To create a database, clone the connection with a power user and an existing database to connect to.
  *
  * ```ts
  * import { createDatabase } from 'orchid-orm/migrations';
  *
- * const adapter = db.$adapter.reconfigure({
+ * const adapter = db.$adapter.clone({
  *   user: 'postgres',
  *   database: 'postgres',
  * });
@@ -1953,19 +1903,22 @@ type CreateOrDropOk = 'done' | 'already';
  * });
  * ```
  */
-declare const createDatabase: (db: DbParam, { database, owner, }: {
-    database: string;
-    owner?: string;
+declare const createDatabase: (db: DbParam, {
+  database,
+  owner
+}: {
+  database: string;
+  owner?: string;
 }) => Promise<CreateOrDropOk>;
 /**
- * To drop a database, reconfigure the connection with a power user and a different database to connect to.
+ * To drop a database, clone the connection with a power user and a different database to connect to.
  *
  * Ensure the connections to the database are closed before dropping, because Postgres won't be able to drop it otherwise.
  *
  * ```ts
  * import { createDatabase } from 'orchid-orm/migrations';
  *
- * const adapter = db.$adapter.reconfigure({
+ * const adapter = db.$adapter.clone({
  *   user: 'postgres',
  *   database: 'postgres',
  * });
@@ -1976,8 +1929,10 @@ declare const createDatabase: (db: DbParam, { database, owner, }: {
  * });
  * ```
  */
-declare const dropDatabase: (db: DbParam, { database }: {
-    database: string;
+declare const dropDatabase: (db: DbParam, {
+  database
+}: {
+  database: string;
 }) => Promise<CreateOrDropOk>;
 /**
  * `createSchema` uses a savepoint when it is called in a transaction to not break it if the schema already exists.
@@ -2027,9 +1982,5 @@ declare const createTable: (db: DbParam, sql: string) => Promise<"done" | "alrea
  * ```
  */
 declare const dropTable: (db: DbParam, sql: string) => Promise<"done" | "already">;
-
-declare class RakeDbError extends Error {
-}
-
-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 };
+declare class RakeDbError extends Error {}
+export { type ChangeCallback, type DbMigration, type DbStructure, type IntrospectedStructure, type MigrateConfig, type MigrateFn, type MigrationChangeFn, type RakeDbAst, type RakeDbChangeFnConfig, type RakeDbCliConfigInput, type RakeDbCliResult, type RakeDbConfig, RakeDbError, type RakeDbFn, type SilentQueries, type StructureToAstCtx, type StructureToAstTableData, 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 };