kysely 0.22.0 → 0.23.1

package/dist/cjs/raw-builder/raw-builder.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AliasedRawBuilder = exports.RawBuilder = void 0;
+exports.AliasedRawBuilder = exports.isRawBuilder = exports.RawBuilder = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -18,6 +18,10 @@ class RawBuilder {
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
     as(alias) {
         return new AliasedRawBuilder(this, alias);
     }
@@ -61,6 +65,15 @@ class RawBuilder {
     }
 }
 exports.RawBuilder = RawBuilder;
+function isRawBuilder(obj) {
+    return ((0, object_utils_js_1.isObject)(obj) &&
+        (0, object_utils_js_1.isFunction)(obj.as) &&
+        (0, object_utils_js_1.isFunction)(obj.castTo) &&
+        (0, object_utils_js_1.isFunction)(obj.withPlugin) &&
+        (0, object_utils_js_1.isFunction)(obj.toOperationNode) &&
+        (0, object_utils_js_1.isFunction)(obj.execute));
+}
+exports.isRawBuilder = isRawBuilder;
 (0, prevent_await_js_1.preventAwait)(RawBuilder, "don't await RawBuilder instances directly. To execute the query you need to call `execute`");
 /**
  * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
@@ -68,14 +81,15 @@ exports.RawBuilder = RawBuilder;
 class AliasedRawBuilder {
     #rawBuilder;
     #alias;
-    /**
-     * @private
-     *
-     * This needs to be here just so that the typings work. Without this
-     * the generated .d.ts file contains no reference to the type param A
-     * which causes this type to be equal to AliasedRawBuilder with any A
-     * as long as O is the same.
-     */
+    constructor(rawBuilder, alias) {
+        this.#rawBuilder = rawBuilder;
+        this.#alias = alias;
+    }
+    /** @private */
+    get expression() {
+        return this.#rawBuilder;
+    }
+    /** @private */
     get alias() {
         return this.#alias;
     }
@@ -84,9 +98,5 @@ class AliasedRawBuilder {
             ? this.#alias.toOperationNode()
             : identifier_node_js_1.IdentifierNode.create(this.#alias));
     }
-    constructor(rawBuilder, alias) {
-        this.#rawBuilder = rawBuilder;
-        this.#alias = alias;
-    }
 }
 exports.AliasedRawBuilder = AliasedRawBuilder;

package/dist/cjs/raw-builder/sql.d.ts

@@ -101,10 +101,10 @@ export interface Sql {
      * `sql.value(value)` is a shortcut for:
      *
      * ```ts
-     * sql`${value}`
+     * sql<ValueType>`${value}`
      * ```
      */
-    value(value: unknown): RawBuilder<unknown>;
+    value<T>(value: T): RawBuilder<T>;
     /**
      * This can be used to add runtime column references to SQL snippets.
      *
@@ -234,7 +234,7 @@ export interface Sql {
      * select "public"."person"."first_name" from "public"."person"
      * ```
      */
-    id(...ids: string[]): RawBuilder<unknown>;
+    id(...ids: readonly string[]): RawBuilder<unknown>;
     /**
      * This can be used to add literal values to SQL snippets.
      *
@@ -334,6 +334,6 @@ export interface Sql {
      * BEFORE $1::varchar, (1 == 1)::varchar, (select * from "person")::varchar, false::varchar, "first_name" AFTER
      * ```
      */
-    join(array: unknown[], separator?: RawBuilder<any>): RawBuilder<unknown>;
+    join(array: readonly unknown[], separator?: RawBuilder<any>): RawBuilder<unknown>;
 }
 export declare const sql: Sql;

package/dist/cjs/schema/alter-column-builder.d.ts

@@ -0,0 +1,28 @@
+import { AlterColumnNode } from '../operation-node/alter-column-node.js';
+import { ColumnDataType } from '../operation-node/data-type-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { DefaultValueExpression } from '../parser/default-value-parser.js';
+export declare class AlterColumnBuilder {
+    protected readonly alterColumnNode: AlterColumnNode;
+    constructor(alterColumnNode: AlterColumnNode);
+    setDataType(dataType: ColumnDataType): AlteredColumnBuilder;
+    setDefault(value: DefaultValueExpression): AlteredColumnBuilder;
+    dropDefault(): AlteredColumnBuilder;
+    setNotNull(): AlteredColumnBuilder;
+    dropNotNull(): AlteredColumnBuilder;
+}
+/**
+ * Allows us to force consumers to do something, anything, when altering a column.
+ *
+ * Basically, deny the following:
+ *
+ * ```ts
+ * db.schema.alterTable('person').alterColumn('age', (ac) => ac)
+ * ```
+ *
+ * Which would now throw a compilation error, instead of a runtime error.
+ */
+export declare class AlteredColumnBuilder extends AlterColumnBuilder implements OperationNodeSource {
+    toOperationNode(): AlterColumnNode;
+}
+export declare type AlterColumnBuilderCallback = (builder: AlterColumnBuilder) => AlteredColumnBuilder;

package/dist/cjs/schema/alter-column-builder.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlteredColumnBuilder = exports.AlterColumnBuilder = void 0;
+const alter_column_node_js_1 = require("../operation-node/alter-column-node.js");
+const data_type_node_js_1 = require("../operation-node/data-type-node.js");
+const default_value_parser_js_1 = require("../parser/default-value-parser.js");
+class AlterColumnBuilder {
+    alterColumnNode;
+    constructor(alterColumnNode) {
+        this.alterColumnNode = alterColumnNode;
+    }
+    setDataType(dataType) {
+        return new AlteredColumnBuilder(alter_column_node_js_1.AlterColumnNode.cloneWith(this.alterColumnNode, {
+            dataType: data_type_node_js_1.DataTypeNode.create(dataType),
+        }));
+    }
+    setDefault(value) {
+        return new AlteredColumnBuilder(alter_column_node_js_1.AlterColumnNode.cloneWith(this.alterColumnNode, {
+            setDefault: (0, default_value_parser_js_1.parseDefaultValueExpression)(value),
+        }));
+    }
+    dropDefault() {
+        return new AlteredColumnBuilder(alter_column_node_js_1.AlterColumnNode.cloneWith(this.alterColumnNode, {
+            dropDefault: true,
+        }));
+    }
+    setNotNull() {
+        return new AlteredColumnBuilder(alter_column_node_js_1.AlterColumnNode.cloneWith(this.alterColumnNode, {
+            setNotNull: true,
+        }));
+    }
+    dropNotNull() {
+        return new AlteredColumnBuilder(alter_column_node_js_1.AlterColumnNode.cloneWith(this.alterColumnNode, {
+            dropNotNull: true,
+        }));
+    }
+}
+exports.AlterColumnBuilder = AlterColumnBuilder;
+/**
+ * Allows us to force consumers to do something, anything, when altering a column.
+ *
+ * Basically, deny the following:
+ *
+ * ```ts
+ * db.schema.alterTable('person').alterColumn('age', (ac) => ac)
+ * ```
+ *
+ * Which would now throw a compilation error, instead of a runtime error.
+ */
+class AlteredColumnBuilder extends AlterColumnBuilder {
+    toOperationNode() {
+        return this.alterColumnNode;
+    }
+}
+exports.AlteredColumnBuilder = AlteredColumnBuilder;

package/dist/cjs/schema/alter-table-builder.d.ts

@@ -1,38 +1,36 @@
-import { AlterColumnNode } from '../operation-node/alter-column-node.js';
 import { AlterTableNode } from '../operation-node/alter-table-node.js';
-import { ColumnDataType } from '../operation-node/data-type-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { OnModifyForeignAction } from '../operation-node/references-node.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { Compilable } from '../util/compilable.js';
-import { ColumnDefinitionBuilder, ColumnDefinitionBuilderInterface } from './column-definition-builder.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
+import { ColumnDefinitionBuilderCallback } from './column-definition-builder.js';
 import { QueryId } from '../util/query-id.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { DataTypeExpression } from '../parser/data-type-parser.js';
 import { ForeignKeyConstraintBuilder, ForeignKeyConstraintBuilderInterface } from './foreign-key-constraint-builder.js';
-import { DefaultValueExpression } from '../parser/default-value-parser.js';
+import { Expression } from '../expression/expression.js';
+import { AlterColumnBuilderCallback } from './alter-column-builder.js';
 /**
  * This builder can be used to create a `alter table` query.
  */
-export declare class AlterTableBuilder {
+export declare class AlterTableBuilder implements ColumnAlteringInterface {
     #private;
     constructor(props: AlterTableBuilderProps);
     renameTo(newTableName: string): AlterTableExecutor;
     setSchema(newSchema: string): AlterTableExecutor;
-    alterColumn(column: string): AlterColumnBuilder;
-    dropColumn(column: string): AlterTableExecutor;
-    renameColumn(column: string, newColumn: string): AlterTableExecutor;
+    alterColumn(column: string, alteration: AlterColumnBuilderCallback): AlterTableColumnAlteringBuilder;
+    dropColumn(column: string): AlterTableColumnAlteringBuilder;
+    renameColumn(column: string, newColumn: string): AlterTableColumnAlteringBuilder;
     /**
      * See {@link CreateTableBuilder.addColumn}
      */
-    addColumn(columnName: string, dataType: DataTypeExpression, build?: AlterTableAddColumnBuilderCallback): AlterTableAddColumnBuilder;
+    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
     /**
      * Creates an `alter table modify column` query. The `modify column` statement
      * is only implemeted by MySQL and oracle AFAIK. On other databases you
      * should use the `alterColumn` method.
      */
-    modifyColumn(columnName: string, dataType: DataTypeExpression): AlterTableModifyColumnBuilder;
+    modifyColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
     /**
      * See {@link CreateTableBuilder.addUniqueConstraint}
      */
@@ -40,7 +38,7 @@ export declare class AlterTableBuilder {
     /**
      * See {@link CreateTableBuilder.addCheckConstraint}
      */
-    addCheckConstraint(constraintName: string, checkExpression: AnyRawBuilder): AlterTableExecutor;
+    addCheckConstraint(constraintName: string, checkExpression: Expression<any>): AlterTableExecutor;
     /**
      * See {@link CreateTableBuilder.addForeignKeyConstraint}
      *
@@ -50,23 +48,17 @@ export declare class AlterTableBuilder {
      */
     addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
     dropConstraint(constraintName: string): AlterTableDropConstraintBuilder;
+    /**
+     * Calls the given function passing `this` as the only argument.
+     *
+     * See {@link CreateTableBuilder.call}
+     */
+    call<T>(func: (qb: this) => T): T;
 }
 export interface AlterTableBuilderProps {
     readonly queryId: QueryId;
-    readonly alterTableNode: AlterTableNode;
     readonly executor: QueryExecutor;
-}
-export declare class AlterColumnBuilder {
-    #private;
-    constructor(props: AlterColumnBuilderProps);
-    setDataType(dataType: ColumnDataType): AlterTableExecutor;
-    setDefault(value: DefaultValueExpression): AlterTableExecutor;
-    dropDefault(): AlterTableExecutor;
-    setNotNull(): AlterTableExecutor;
-    dropNotNull(): AlterTableExecutor;
-}
-export interface AlterColumnBuilderProps extends AlterTableBuilderProps {
-    readonly alterColumnNode: AlterColumnNode;
+    readonly node: AlterTableNode;
 }
 export declare class AlterTableExecutor implements OperationNodeSource, Compilable {
     #private;
@@ -77,336 +69,42 @@ export declare class AlterTableExecutor implements OperationNodeSource, Compilab
 }
 export interface AlterTableExecutorProps extends AlterTableBuilderProps {
 }
-export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
-    #private;
-    constructor(props: AlterTableAddColumnBuilderProps);
-    /**
-     * Adds `auto_increment` or `autoincrement` to the column definition
-     * depending on the dialect.
-     *
-     * Some dialects like PostgreSQL don't support this. On PostgreSQL
-     * you can use the `serial` or `bigserial` data type instead.
-     */
-    autoIncrement(): AlterTableAddColumnBuilder;
-    /**
-     * Makes the column the primary key.
-     *
-     * If you want to specify a composite primary key use the
-     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
-     */
-    primaryKey(): AlterTableAddColumnBuilder;
-    /**
-     * Adds a foreign key constraint for the column.
-     *
-     * If your database engine doesn't support foreign key constraints in the
-     * column definition (like MySQL 5) you need to call the table level
-     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id')
-     * ```
-     */
-    references(ref: string): AlterTableAddColumnBuilder;
-    /**
-     * Adds an `on delete` constraint for the foreign key column.
-     *
-     * If your database engine doesn't support foreign key constraints in the
-     * column definition (like MySQL 5) you need to call the table level
-     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id').onDelete('cascade')
-     * ```
-     */
-    onDelete(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
-    /**
-     * Adds an `on update` constraint for the foreign key column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id').onUpdate('cascade')
-     * ```
-     */
-    onUpdate(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
-    /**
-     * Adds a unique constraint for the column.
-     */
-    unique(): AlterTableAddColumnBuilder;
+export interface ColumnAlteringInterface {
+    alterColumn(column: string, alteration: AlterColumnBuilderCallback): ColumnAlteringInterface;
+    dropColumn(column: string): ColumnAlteringInterface;
+    renameColumn(column: string, newColumn: string): ColumnAlteringInterface;
     /**
-     * Adds a `not null` constraint for the column.
-     */
-    notNull(): AlterTableAddColumnBuilder;
-    /**
-     * Adds a `unsigned` modifier for the column.
-     *
-     * This only works on some dialects like MySQL.
-     */
-    unsigned(): AlterTableAddColumnBuilder;
-    /**
-     * Adds a default value constraint for the column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
-     *   .execute()
-     * ```
-     *
-     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
-     * an arbitrary SQL expression using the {@link sql} template tag:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn(
-     *     'number_of_legs',
-     *     'integer',
-     *     (col) => col.defaultTo(sql`any SQL here`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    defaultTo(value: DefaultValueExpression): AlterTableAddColumnBuilder;
-    /**
-     * Adds a check constraint for the column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) =>
-     *     col.check(sql`number_of_legs < 5`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    check(expression: AnyRawBuilder): AlterTableAddColumnBuilder;
-    /**
-     * Makes the column a generated column using a `generated always as` statement.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('person')
-     *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    generatedAlwaysAs(expression: AnyRawBuilder): AlterTableAddColumnBuilder;
-    /**
-     * Adds the `generated always as identity` specifier on supported dialects.
-     */
-    generatedAlwaysAsIdentity(): AlterTableAddColumnBuilder;
-    /**
-     * Adds the `generated by default as identity` specifier on supported dialects.
+     * See {@link CreateTableBuilder.addColumn}
      */
-    generatedByDefaultAsIdentity(): AlterTableAddColumnBuilder;
+    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): ColumnAlteringInterface;
     /**
-     * Makes a generated column stored instead of virtual. This method can only
-     * be used with {@link generatedAlwaysAs}
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.schema
-     *   .createTable('person')
-     *   .addColumn('full_name', 'varchar(255)', (col) => col
-     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
-     *     .stored()
-     *   )
-     *   .execute()
-     * ```
+     * Creates an `alter table modify column` query. The `modify column` statement
+     * is only implemeted by MySQL and oracle AFAIK. On other databases you
+     * should use the `alterColumn` method.
      */
-    stored(): AlterTableAddColumnBuilder;
-    toOperationNode(): AlterTableNode;
-    compile(): CompiledQuery;
-    execute(): Promise<void>;
+    modifyColumn(columnName: string, dataType: DataTypeExpression, build: ColumnDefinitionBuilderCallback): ColumnAlteringInterface;
 }
-export interface AlterTableAddColumnBuilderProps extends AlterTableBuilderProps {
-    readonly columnBuilder: ColumnDefinitionBuilder;
-}
-export declare type AlterTableAddColumnBuilderCallback = (builder: AlterTableAddColumnBuilder) => AlterTableAddColumnBuilder;
-export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
+export declare class AlterTableColumnAlteringBuilder implements ColumnAlteringInterface, OperationNodeSource, Compilable {
     #private;
-    constructor(props: AlterTableModifyColumnBuilderProps);
-    /**
-     * Adds `auto_increment` or `autoincrement` to the column definition
-     * depending on the dialect.
-     *
-     * Some dialects like PostgreSQL don't support this. On PostgreSQL
-     * you can use the `serial` or `bigserial` data type instead.
-     */
-    autoIncrement(): AlterTableModifyColumnBuilder;
-    /**
-     * Makes the column the primary key.
-     *
-     * If you want to specify a composite primary key use the
-     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
-     */
-    primaryKey(): AlterTableModifyColumnBuilder;
-    /**
-     * Adds a foreign key constraint for the column.
-     *
-     * If your database engine doesn't support foreign key constraints in the
-     * column definition (like MySQL 5) you need to call the table level
-     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id')
-     * ```
-     */
-    references(ref: string): AlterTableModifyColumnBuilder;
-    /**
-     * Adds an `on delete` constraint for the foreign key column.
-     *
-     * If your database engine doesn't support foreign key constraints in the
-     * column definition (like MySQL 5) you need to call the table level
-     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id').onDelete('cascade')
-     * ```
-     */
-    onDelete(onDelete: OnModifyForeignAction): AlterTableModifyColumnBuilder;
-    /**
-     * Adds an `on update` constraint for the foreign key column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id').onUpdate('cascade')
-     * ```
-     */
-    onUpdate(onUpdate: OnModifyForeignAction): AlterTableModifyColumnBuilder;
-    /**
-     * Adds a unique constraint for the column.
-     */
-    unique(): AlterTableModifyColumnBuilder;
-    /**
-     * Adds a `not null` constraint for the column.
-     */
-    notNull(): AlterTableModifyColumnBuilder;
+    constructor(props: AlterTableColumnAlteringBuilderProps);
+    alterColumn(column: string, alteration: AlterColumnBuilderCallback): AlterTableColumnAlteringBuilder;
+    dropColumn(column: string): AlterTableColumnAlteringBuilder;
+    renameColumn(column: string, newColumn: string): AlterTableColumnAlteringBuilder;
     /**
-     * Adds a `unsigned` modifier for the column.
-     *
-     * This only works on some dialects like MySQL.
-     */
-    unsigned(): AlterTableModifyColumnBuilder;
-    /**
-     * Adds a default value constraint for the column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
-     *   .execute()
-     * ```
-     *
-     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
-     * an arbitrary SQL expression using the {@link sql} template tag:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn(
-     *     'number_of_legs',
-     *     'integer',
-     *     (col) => col.defaultTo(sql`any SQL here`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    defaultTo(value: DefaultValueExpression): AlterTableModifyColumnBuilder;
-    /**
-     * Adds a check constraint for the column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) =>
-     *     col.check(sql`number_of_legs < 5`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    check(expression: AnyRawBuilder): AlterTableModifyColumnBuilder;
-    /**
-     * Makes the column a generated column using a `generated always as` statement.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('person')
-     *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    generatedAlwaysAs(expression: AnyRawBuilder): AlterTableModifyColumnBuilder;
-    /**
-     * Adds the `generated always as identity` specifier on supported dialects.
-     */
-    generatedAlwaysAsIdentity(): AlterTableModifyColumnBuilder;
-    /**
-     * Adds the `generated by default as identity` specifier on supported dialects.
+     * See {@link CreateTableBuilder.addColumn}
      */
-    generatedByDefaultAsIdentity(): AlterTableModifyColumnBuilder;
+    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
     /**
-     * Makes a generated column stored instead of virtual. This method can only
-     * be used with {@link generatedAlwaysAs}
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.schema
-     *   .createTable('person')
-     *   .addColumn('full_name', 'varchar(255)', (col) => col
-     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
-     *     .stored()
-     *   )
-     *   .execute()
-     * ```
+     * Creates an `alter table modify column` query. The `modify column` statement
+     * is only implemeted by MySQL and oracle AFAIK. On other databases you
+     * should use the `alterColumn` method.
      */
-    stored(): AlterTableModifyColumnBuilder;
+    modifyColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface AlterTableModifyColumnBuilderProps extends AlterTableBuilderProps {
-    readonly columnBuilder: ColumnDefinitionBuilder;
+export interface AlterTableColumnAlteringBuilderProps extends AlterTableBuilderProps {
 }
 export declare class AlterTableAddForeignKeyConstraintBuilder implements ForeignKeyConstraintBuilderInterface<AlterTableAddForeignKeyConstraintBuilder>, OperationNodeSource, Compilable {
     #private;