kysely 0.11.1 → 0.12.0

package/dist/cjs/query-creator.d.ts

@@ -1,5 +1,8 @@
-import { QueryBuilder } from './query-builder/query-builder.js';
-import { QueryBuilderWithTable, TableExpression, TableReference } from './parser/table-parser.js';
+import { SelectQueryBuilder } from './query-builder/select-query-builder.js';
+import { InsertQueryBuilder } from './query-builder/insert-query-builder.js';
+import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
+import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
+import { TableExpression, TableExpressionDatabase, TableExpressionTables, TableReference } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { RawBuilder } from './raw-builder/raw-builder.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression } from './parser/with-parser.js';
@@ -16,7 +19,8 @@ export declare class QueryCreator<DB> {
      *
      * The tables passed to this method are built as the query's `from` clause.
      *
-     * @example
+     * ### Examples
+     *
      * Create a select query for one table:
      *
      * ```ts
@@ -29,12 +33,11 @@ export declare class QueryCreator<DB> {
      * select * from "person"
      * ```
      *
-     * @example
      * Create a select query for one table with an alias:
      *
      * ```ts
      * const persons = await db.selectFrom('person as p')
-     *   .select(['p.id', 'p.first_name'])
+     *   .select(['p.id', 'first_name'])
      *   .execute()
      *
      * console.log(persons[0].id)
@@ -43,15 +46,14 @@ export declare class QueryCreator<DB> {
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select "p"."id", "p"."first_name" from "person" as "p"
+     * select "p"."id", "first_name" from "person" as "p"
      * ```
      *
-     * @example
      * Create a select query from a subquery:
      *
      * ```ts
      * const persons = await db.selectFrom(
-     *     db.selectFrom('person').select('person.id as identifier').as('p')
+     *     (eb) => eb.selectFrom('person').select('person.id as identifier').as('p')
      *   )
      *   .select('p.identifier')
      *   .execute()
@@ -68,12 +70,11 @@ export declare class QueryCreator<DB> {
      * ) as p
      * ```
      *
-     * @example
      * Create a select query from raw sql:
      *
      * ```ts
      * const items = await db.selectFrom(
-     *     db.raw<{ one: number }>('(select 1 as one)').as('q')
+     *     db.raw<{ one: number }>('(select 1 as one)').as('q')
      *   )
      *   .select('q.one')
      *   .execute()
@@ -94,7 +95,6 @@ export declare class QueryCreator<DB> {
      * raw segment / query so that Kysely can figure out what columns are
      * available for the query.
      *
-     * @example
      * The `selectFrom` method also accepts an array for multiple tables. All
      * the above examples can also be used in an array.
      *
@@ -102,7 +102,7 @@ export declare class QueryCreator<DB> {
      * const items = await db.selectFrom([
      *     'person as p',
      *     db.selectFrom('pet').select('pet.species').as('a'),
-     *     db.raw<{ one: number }>('(select 1 as one)').as('q')
+     *     db.raw<{ one: number }>('(select 1 as one)').as('q')
      *   ])
      *   .select(['p.id', 'a.species', 'q.one'])
      *   .execute()
@@ -118,20 +118,21 @@ export declare class QueryCreator<DB> {
      *   (select 1 as one) as "q"
      * ```
      */
-    selectFrom<F extends TableExpression<DB, keyof DB>>(from: F[]): QueryBuilderWithTable<DB, never, {}, F>;
-    selectFrom<F extends TableExpression<DB, keyof DB>>(from: F): QueryBuilderWithTable<DB, never, {}, F>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
     /**
      * Creates an insert query.
      *
      * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
-     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
      * the inserted row if the db returned one.
      *
-     * See the {@link QueryBuilder.values | values} method for more info and examples. Also see
-     * the {@link QueryBuilder.returning | returning} method for a way to return columns
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples. Also see
+     * the {@link ReturningInterface.returning | returning} method for a way to return columns
      * on supported databases like PostgreSQL.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .insertInto('person')
@@ -145,11 +146,10 @@ export declare class QueryCreator<DB> {
      * console.log(result.insertId)
      * ```
      *
-     * @example
      * Some databases like PostgreSQL support the `returning` method:
      *
      * ```ts
-     * const { id } = await db
+     * const { id } = await db
      *   .insertInto('person')
      *   .values({
      *     id: db.generated,
@@ -160,16 +160,17 @@ export declare class QueryCreator<DB> {
      *   .executeTakeFirst()
      * ```
      */
-    insertInto<T extends keyof DB & string>(table: T): QueryBuilder<DB, T, InsertResult>;
+    insertInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
     /**
      * Creates a delete query.
      *
-     * See the {@link QueryBuilder.where} method for examples on how to specify
+     * See the {@link WhereInterface.where} method for examples on how to specify
      * a where clause for the delete operation.
      *
      * The return value of the query is an instance of {@link DeleteResult}.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .deleteFrom('person')
@@ -179,19 +180,20 @@ export declare class QueryCreator<DB> {
      * console.log(result.numDeletedRows)
      * ```
      */
-    deleteFrom<TR extends TableReference<DB>>(table: TR): QueryBuilderWithTable<DB, never, DeleteResult, TR>;
+    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, DeleteResult>;
     /**
      * Creates an update query.
      *
-     * See the {@link QueryBuilder.where} method for examples on how to specify
+     * See the {@link WhereInterface.where} method for examples on how to specify
      * a where clause for the update operation.
      *
-     * See the {@link QueryBuilder.set} method for examples on how to
+     * See the {@link UpdateQueryBuilder.set} method for examples on how to
      * specify the updates.
      *
      * The return value of the query is an {@link UpdateResult}.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .updateTable('person')
@@ -202,11 +204,12 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
-    updateTable<TR extends TableReference<DB>>(table: TR): QueryBuilderWithTable<DB, never, UpdateResult, TR>;
+    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
     /**
      * Creates a `with` query (common table expressions).
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db
      *   .with('jennifers', (db) => db
@@ -233,7 +236,8 @@ export declare class QueryCreator<DB> {
      * This only affects the query created through the builder returned from
      * this method and doesn't modify the `db` instance.
      *
-     * @example
+     * ### Examples
+     *
      * ```
      * await db.withSchema('mammals')
      *  .selectFrom('pet')
@@ -250,7 +254,6 @@ export declare class QueryCreator<DB> {
      * on "public"."person"."id" = "mammals"."pet"."owner_id"
      * ```
      *
-     * @example
      * `withSchema` is smart enough to not add schema for aliases,
      * common table expressions or other places where the schema
      * doesn't belong to:
@@ -288,14 +291,8 @@ export declare class QueryCreator<DB> {
      * Raw builder instances can be passed to pretty much anywhere: `select`, `where`,
      * `*Join`, `groupBy`, `orderBy` etc. Just try it. If the method accepts it, it works.
      *
-     * @param sql - The raw SQL. Special strings `?` and `??` can be used as parameter
-     *    placeholders. `?` for values and `??` for identifiers such as column names
-     *    or `column.table` references.
+     * ### Examples
      *
-     * @param params - The parameters that will be bound to the `?` and `??` placeholders in
-     *    the sql string.
-     *
-     * @example
      * Example of using `raw` in a select statement:
      *
      * ```ts
@@ -349,7 +346,6 @@ export declare class QueryCreator<DB> {
      * array, never to the SQL string directly. But if the column names or values are trusted
      * and known at compile time, there is no reason to use parameters.
      *
-     * @example
      * Example of using `raw` in `where`:
      *
      * ```ts
@@ -375,7 +371,6 @@ export declare class QueryCreator<DB> {
      * years. The number of years in this example is an untrusted user input, and therefore we use
      * a `?` placeholder for it.
      *
-     * @example
      * Example of creating a completely raw query from scratch:
      *
      * ```ts
@@ -387,6 +382,13 @@ export declare class QueryCreator<DB> {
      * this case we know the resulting items will be of type `Person` se specify that.
      * The result of `execute()` method is always an array. In this case the type of
      * the `persons` variable is `Person[]`.
+     *
+     * @param sql - The raw SQL. Special strings `?` and `??` can be used as parameter
+     *    placeholders. `?` for values and `??` for identifiers such as column names
+     *    or `column.table` references.
+     *
+     * @param params - The parameters that will be bound to the `?` and `??` placeholders in
+     *    the sql string.
      */
     raw<T = unknown>(sql: string, parameters?: any[]): RawBuilder<T>;
 }

package/dist/cjs/query-creator.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryCreator = void 0;
-const query_builder_js_1 = require("./query-builder/query-builder.js");
+const select_query_builder_js_1 = require("./query-builder/select-query-builder.js");
+const insert_query_builder_js_1 = require("./query-builder/insert-query-builder.js");
+const delete_query_builder_js_1 = require("./query-builder/delete-query-builder.js");
+const update_query_builder_js_1 = require("./query-builder/update-query-builder.js");
 const delete_query_node_js_1 = require("./operation-node/delete-query-node.js");
 const insert_query_node_js_1 = require("./operation-node/insert-query-node.js");
 const select_query_node_js_1 = require("./operation-node/select-query-node.js");
@@ -19,7 +22,7 @@ class QueryCreator {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
     selectFrom(from) {
-        return new query_builder_js_1.QueryBuilder({
+        return new select_query_builder_js_1.SelectQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
             parseContext: this.#props.parseContext,
@@ -30,14 +33,15 @@ class QueryCreator {
      * Creates an insert query.
      *
      * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
-     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
      * the inserted row if the db returned one.
      *
-     * See the {@link QueryBuilder.values | values} method for more info and examples. Also see
-     * the {@link QueryBuilder.returning | returning} method for a way to return columns
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples. Also see
+     * the {@link ReturningInterface.returning | returning} method for a way to return columns
      * on supported databases like PostgreSQL.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .insertInto('person')
@@ -51,11 +55,10 @@ class QueryCreator {
      * console.log(result.insertId)
      * ```
      *
-     * @example
      * Some databases like PostgreSQL support the `returning` method:
      *
      * ```ts
-     * const { id } = await db
+     * const { id } = await db
      *   .insertInto('person')
      *   .values({
      *     id: db.generated,
@@ -67,7 +70,7 @@ class QueryCreator {
      * ```
      */
     insertInto(table) {
-        return new query_builder_js_1.QueryBuilder({
+        return new insert_query_builder_js_1.InsertQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
             parseContext: this.#props.parseContext,
@@ -77,12 +80,13 @@ class QueryCreator {
     /**
      * Creates a delete query.
      *
-     * See the {@link QueryBuilder.where} method for examples on how to specify
+     * See the {@link WhereInterface.where} method for examples on how to specify
      * a where clause for the delete operation.
      *
      * The return value of the query is an instance of {@link DeleteResult}.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .deleteFrom('person')
@@ -93,7 +97,7 @@ class QueryCreator {
      * ```
      */
     deleteFrom(table) {
-        return new query_builder_js_1.QueryBuilder({
+        return new delete_query_builder_js_1.DeleteQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
             parseContext: this.#props.parseContext,
@@ -103,15 +107,16 @@ class QueryCreator {
     /**
      * Creates an update query.
      *
-     * See the {@link QueryBuilder.where} method for examples on how to specify
+     * See the {@link WhereInterface.where} method for examples on how to specify
      * a where clause for the update operation.
      *
-     * See the {@link QueryBuilder.set} method for examples on how to
+     * See the {@link UpdateQueryBuilder.set} method for examples on how to
      * specify the updates.
      *
      * The return value of the query is an {@link UpdateResult}.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .updateTable('person')
@@ -123,7 +128,7 @@ class QueryCreator {
      * ```
      */
     updateTable(table) {
-        return new query_builder_js_1.QueryBuilder({
+        return new update_query_builder_js_1.UpdateQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
             parseContext: this.#props.parseContext,
@@ -133,7 +138,8 @@ class QueryCreator {
     /**
      * Creates a `with` query (common table expressions).
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db
      *   .with('jennifers', (db) => db
@@ -168,7 +174,8 @@ class QueryCreator {
      * This only affects the query created through the builder returned from
      * this method and doesn't modify the `db` instance.
      *
-     * @example
+     * ### Examples
+     *
      * ```
      * await db.withSchema('mammals')
      *  .selectFrom('pet')
@@ -185,7 +192,6 @@ class QueryCreator {
      * on "public"."person"."id" = "mammals"."pet"."owner_id"
      * ```
      *
-     * @example
      * `withSchema` is smart enough to not add schema for aliases,
      * common table expressions or other places where the schema
      * doesn't belong to:
@@ -228,14 +234,8 @@ class QueryCreator {
      * Raw builder instances can be passed to pretty much anywhere: `select`, `where`,
      * `*Join`, `groupBy`, `orderBy` etc. Just try it. If the method accepts it, it works.
      *
-     * @param sql - The raw SQL. Special strings `?` and `??` can be used as parameter
-     *    placeholders. `?` for values and `??` for identifiers such as column names
-     *    or `column.table` references.
-     *
-     * @param params - The parameters that will be bound to the `?` and `??` placeholders in
-     *    the sql string.
+     * ### Examples
      *
-     * @example
      * Example of using `raw` in a select statement:
      *
      * ```ts
@@ -289,7 +289,6 @@ class QueryCreator {
      * array, never to the SQL string directly. But if the column names or values are trusted
      * and known at compile time, there is no reason to use parameters.
      *
-     * @example
      * Example of using `raw` in `where`:
      *
      * ```ts
@@ -315,7 +314,6 @@ class QueryCreator {
      * years. The number of years in this example is an untrusted user input, and therefore we use
      * a `?` placeholder for it.
      *
-     * @example
      * Example of creating a completely raw query from scratch:
      *
      * ```ts
@@ -327,6 +325,13 @@ class QueryCreator {
      * this case we know the resulting items will be of type `Person` se specify that.
      * The result of `execute()` method is always an array. In this case the type of
      * the `persons` variable is `Person[]`.
+     *
+     * @param sql - The raw SQL. Special strings `?` and `??` can be used as parameter
+     *    placeholders. `?` for values and `??` for identifiers such as column names
+     *    or `column.table` references.
+     *
+     * @param params - The parameters that will be bound to the `?` and `??` placeholders in
+     *    the sql string.
      */
     raw(sql, parameters) {
         return new raw_builder_js_1.RawBuilder({

package/dist/cjs/query-executor/query-executor.d.ts

@@ -6,7 +6,7 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryId } from '../util/query-id.js';
 /**
  * This class abstracts away the details of how to compile a query into SQL
- * and execute it. Instead of passing around all those details, {@link QueryBuilder}
+ * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
  * and other classes that execute queries can just pass around and instance of
  * `QueryExecutor`.
  */

package/dist/cjs/query-executor/query-executor.js

@@ -4,7 +4,7 @@ exports.QueryExecutor = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 /**
  * This class abstracts away the details of how to compile a query into SQL
- * and execute it. Instead of passing around all those details, {@link QueryBuilder}
+ * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
  * and other classes that execute queries can just pass around and instance of
  * `QueryExecutor`.
  */

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

@@ -5,6 +5,7 @@ import { RawNode } from '../operation-node/raw-node.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
+import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 export declare class RawBuilder<O = unknown> implements OperationNodeSource {
     #private;
     constructor(props: RawBuilderProps);
@@ -16,6 +17,7 @@ export declare class RawBuilder<O = unknown> implements OperationNodeSource {
      * of this `RawBuilder` with a new output type.
      */
     castTo<T>(): RawBuilder<T>;
+    withPlugin(plugin: KyselyPlugin): RawBuilder<O>;
     toOperationNode(): RawNode;
     compile(): CompiledQuery;
     execute(): Promise<QueryResult<O>>;

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

@@ -27,6 +27,12 @@ class RawBuilder {
             ...this.#props,
         });
     }
+    withPlugin(plugin) {
+        return new RawBuilder({
+            ...this.#props,
+            executor: this.#props.executor.withPlugin(plugin),
+        });
+    }
     toOperationNode() {
         const parameterPlaceholderRegex = /(\?\??)/g;
         const sql = this.#props.sql;

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

@@ -60,7 +60,7 @@ export declare class AlterTableExecutor implements OperationNodeSource, Compilab
 }
 export interface AlterTableExecutorProps extends AlterTableBuilderProps {
 }
-export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableAddColumnBuilder>, OperationNodeSource, Compilable {
+export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableAddColumnBuilderProps);
     autoIncrement(): AlterTableAddColumnBuilder;
@@ -81,7 +81,7 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
 export interface AlterTableAddColumnBuilderProps extends AlterTableBuilderProps {
     readonly columnBuilder: ColumnDefinitionBuilder;
 }
-export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableModifyColumnBuilder>, OperationNodeSource, Compilable {
+export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableModifyColumnBuilderProps);
     autoIncrement(): AlterTableModifyColumnBuilder;

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

@@ -4,7 +4,7 @@ import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 import { DefaultValueExpression } from '../parser/default-value-parser.js';
-export interface ColumnDefinitionBuilderInterface<R> {
+export interface ColumnDefinitionBuilderInterface {
     /**
      * Adds `auto_increment` or `autoincrement` to the column definition
      * depending on the dialect.
@@ -12,14 +12,14 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * Some dialects like PostgreSQL don't support this. On PostgreSQL
      * you can use the `serial` or `bigserial` data type instead.
      */
-    autoIncrement(): R;
+    autoIncrement(): ColumnDefinitionBuilderInterface;
     /**
      * Makes the column the primary key.
      *
      * If you want to specify a composite primary key use the
      * {@link TableBuilder.addPrimaryKeyConstraint} method.
      */
-    primaryKey(): R;
+    primaryKey(): ColumnDefinitionBuilderInterface;
     /**
      * Adds a foreign key constraint for the column.
      *
@@ -27,12 +27,13 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * column definition (like MySQL 5) you need to call the table level
      * {@link TableBuilder.addForeignKeyConstraint} method instead.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * col.references('person.id')
      * ```
      */
-    references(ref: string): R;
+    references(ref: string): ColumnDefinitionBuilderInterface;
     /**
      * Adds an `on delete` constraint for the foreign key column.
      *
@@ -40,33 +41,36 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * column definition (like MySQL 5) you need to call the table level
      * {@link TableBuilder.addForeignKeyConstraint} method instead.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * col.references('person.id').onDelete('cascade')
      * ```
      */
-    onDelete(onDelete: OnModifyForeignAction): R;
+    onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilderInterface;
     /**
      * Adds an `on update` constraint for the foreign key column.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * col.references('person.id').onUpdate('cascade')
      * ```
      */
-    onUpdate(onUpdate: OnModifyForeignAction): R;
+    onUpdate(onUpdate: OnModifyForeignAction): ColumnDefinitionBuilderInterface;
     /**
      * Adds a unique constraint for the column.
      */
-    unique(): R;
+    unique(): ColumnDefinitionBuilderInterface;
     /**
      * Adds a `not null` constraint for the column.
      */
-    notNull(): R;
+    notNull(): ColumnDefinitionBuilderInterface;
     /**
      * Adds a default value constraint for the column.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('pet')
@@ -74,11 +78,12 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): R;
+    defaultTo(value: PrimitiveValue | AnyRawBuilder): ColumnDefinitionBuilderInterface;
     /**
      * Adds a check constraint for the column.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('pet')
@@ -86,11 +91,12 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    check(sql: string): R;
+    check(sql: string): ColumnDefinitionBuilderInterface;
     /**
      * Makes the column a generated column using a `generated always as` statement.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('person')
@@ -100,12 +106,13 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    generatedAlwaysAs(sql: string): R;
+    generatedAlwaysAs(sql: string): ColumnDefinitionBuilderInterface;
     /**
      * Makes a generated column stored instead of virtual. This method can only
      * be used with {@link generatedAlwaysAs}
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('person')
@@ -116,9 +123,9 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    stored(): R;
+    stored(): ColumnDefinitionBuilderInterface;
 }
-export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface<ColumnDefinitionBuilder>, OperationNodeSource {
+export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource {
     #private;
     constructor(node: ColumnDefinitionNode);
     autoIncrement(): ColumnDefinitionBuilder;

package/dist/cjs/schema/create-index-builder.d.ts

@@ -30,7 +30,8 @@ export declare class CreateIndexBuilder implements OperationNodeSource, Compilab
     /**
      * Specifies an arbitrary expression for the index.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db.schema
      *   .createIndex('person_first_name_index')

package/dist/cjs/schema/create-index-builder.js

@@ -64,7 +64,8 @@ class CreateIndexBuilder {
     /**
      * Specifies an arbitrary expression for the index.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db.schema
      *   .createIndex('person_first_name_index')