kysely 0.27.2 → 0.27.4

package/dist/cjs/query-builder/returning-interface.d.ts

@@ -67,6 +67,8 @@ export interface ReturningInterface<DB, TB extends keyof DB, O> {
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
      */
     returningAll(): ReturningInterface<DB, TB, Selectable<DB[TB]>>;
 }

package/dist/cjs/query-builder/select-query-builder.d.ts

@@ -26,6 +26,8 @@ import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ExpressionWrapper } from '../expression/expression-wrapper.js';
 import { SelectQueryBuilderExpression } from './select-query-builder-expression.js';
 import { ValueExpression } from '../parser/value-parser.js';
+import { FetchModifier } from '../operation-node/fetch-node.js';
+import { TopModifier } from '../operation-node/top-node.js';
 export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInterface<DB, TB>, HavingInterface<DB, TB>, SelectQueryBuilderExpression<O>, Compilable<O>, Explainable, Streamable<O> {
     /**
      * Adds a `where` expression to the query.
@@ -289,7 +291,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     sql`coalesce(first_name, last_name)`,
+     *     sql<string>`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )
@@ -540,6 +542,45 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * In case you use the {@link sql} tag you need to specify the type of the expression
      * (in this example `string`).
      *
+     *  <!-- siteExample("select", "Not null", 51) -->
+     *
+     * Sometimes you can be sure something's not null, but Kysely isn't able to infer
+     * it. For example calling `where('last_name', 'is not', null)` doesn't make
+     * `last_name` not null in the result type, but unless you have other where statements
+     * you can be sure it's never null.
+     *
+     * Kysely has a couple of helpers for dealing with these cases: `$notNull()` and `$narrowType`.
+     * Both are used in the following example:
+     *
+     * ```ts
+     * import { NotNull } from 'kysely'
+     * import { jsonObjectFrom } from 'kysely/helpers/postgres'
+     *
+     * const persons = db
+     *   .selectFrom('person')
+     *   .select((eb) => [
+     *     'last_name',
+     *      // Let's assume we know the person has at least one
+     *      // pet. We can use the `.$notNull()` method to make
+     *      // the expression not null. You could just as well
+     *      // add `pet` to the `$narrowType` call below.
+     *      jsonObjectFrom(
+     *        eb.selectFrom('pet')
+     *          .selectAll()
+     *          .limit(1)
+     *          .whereRef('person.id', '=', 'pet.owner_id')
+     *      ).$notNull().as('pet')
+     *   ])
+     *   .where('last_name', 'is not', null)
+     *   // $narrowType can be used to narrow the output type.
+     *   // The special `NotNull` type can be used to make a
+     *   // selection not null. You could add `pet: NotNull`
+     *   // here and omit the `$notNull()` call on it.
+     *   // Use whichever way you prefer.
+     *   .$narrowType<{ last_name: NotNull }>()
+     *   .execute()
+     * ```
+     *
      * All the examples above assume you know the column names at compile time.
      * While it's better to build your code like that (that way you also know
      * the types) sometimes it's not possible or you just prefer to write more
@@ -809,8 +850,10 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * builder for creating more complex joins. The join builder has a
      * bunch of `on*` methods for building the `on` clause of the join.
      * There's basically an equivalent for every `where` method
-     * (`on`, `onRef` etc.). You can do all the same things with the
-     * `on` method that you can with the corresponding `where` method.
+     * (`on`, `onRef` etc.).
+     *
+     * You can do all the same things with the
+     * `on` method that you can with the corresponding `where` method (like [OR expressions for example](https://kysely.dev/docs/examples/WHERE/or-where)).
      * See the `where` method documentation for more examples.
      *
      * ```ts
@@ -820,6 +863,10 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *     (join) => join
      *       .onRef('pet.owner_id', '=', 'person.id')
      *       .on('pet.name', '=', 'Doggo')
+     *       .on((eb) => eb.or([
+     *         eb('person.age', '>', 18),
+     *         eb('person.age', '<', 100)
+     *       ]))
      *   )
      *   .selectAll()
      *   .execute()
@@ -833,6 +880,10 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * inner join "pet"
      * on "pet"."owner_id" = "person"."id"
      * and "pet"."name" = $1
+     * and (
+     *   "person"."age" > $2
+     *   OR "person"."age" < $3
+     * )
      * ```
      *
      * <!-- siteExample("join", "Subquery join", 40) -->
@@ -992,7 +1043,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *     .limit(1)
      *   )
      *   .orderBy(
-     *     sql`concat(first_name, last_name)`
+     *     sql<string>`concat(first_name, last_name)`
      *   )
      *   .execute()
      * ```
@@ -1051,7 +1102,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .selectFrom('person')
      *   .select([
      *     'first_name',
-     *     sql`max(id)`.as('max_id')
+     *     sql<string>`max(id)`.as('max_id')
      *   ])
      *   .groupBy('first_name')
      *   .execute()
@@ -1075,7 +1126,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .select([
      *     'first_name',
      *     'last_name',
-     *     sql`max(id)`.as('max_id')
+     *     sql<string>`max(id)`.as('max_id')
      *   ])
      *   .groupBy([
      *     'first_name',
@@ -1103,10 +1154,10 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .select([
      *     'first_name',
      *     'last_name',
-     *     sql`max(id)`.as('max_id')
+     *     sql<string>`max(id)`.as('max_id')
      *   ])
      *   .groupBy([
-     *     sql`concat(first_name, last_name)`,
+     *     sql<string>`concat(first_name, last_name)`,
      *     (qb) => qb.selectFrom('pet').select('id').limit(1)
      *   ])
      *   .execute()
@@ -1150,6 +1201,13 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .selectFrom('person')
      *   .select('first_name')
      *   .limit(10)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name" from "person" limit $1
      * ```
      *
      * Select rows from index 10 to index 19 of the result:
@@ -1158,13 +1216,20 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * return await db
      *   .selectFrom('person')
      *   .select('first_name')
-     *   .offset(10)
      *   .limit(10)
+     *   .offset(10)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name" from "person" limit $1 offset $2
      * ```
      */
-    limit(limit: ValueExpression<DB, TB, number>): SelectQueryBuilder<DB, TB, O>;
+    limit(limit: ValueExpression<DB, TB, number | bigint>): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds an offset clause to the query.
+     * Adds an `offset` clause to the query.
      *
      * ### Examples
      *
@@ -1174,11 +1239,87 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * return await db
      *   .selectFrom('person')
      *   .select('first_name')
-     *   .offset(10)
      *   .limit(10)
+     *   .offset(10)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name" from "person" limit $1 offset $2
      * ```
      */
-    offset(offset: ValueExpression<DB, TB, number>): SelectQueryBuilder<DB, TB, O>;
+    offset(offset: ValueExpression<DB, TB, number | bigint>): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Adds a `fetch` clause to the query.
+     *
+     * This clause is only supported by some dialects like PostgreSQL or MS SQL Server.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * return await db
+     *   .selectFrom('person')
+     *   .select('first_name')
+     *   .orderBy('first_name')
+     *   .offset(0)
+     *   .fetch(10)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * select "first_name"
+     * from "person"
+     * order by "first_name"
+     * offset 0 rows
+     * fetch next 10 rows only
+     * ```
+     */
+    fetch(rowCount: number | bigint, modifier?: FetchModifier): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Adds a `top` clause to the query.
+     *
+     * This clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Select 10 biggest ages:
+     *
+     * ```ts
+     * return await db
+     *   .selectFrom('person')
+     *   .select('age')
+     *   .top(10)
+     *   .orderBy('age desc')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * select top(10) "age" from "person" order by "age" desc
+     * ```
+     *
+     * Select 10% first rows:
+     *
+     * ```ts
+     * return await db
+     *  .selectFrom('person')
+     *  .selectAll()
+     *  .top(10, 'percent')
+     *  .execute()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * select top(10) percent * from "person"
+     * ```
+     */
+    top(expression: number | bigint, modifiers?: TopModifier): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `union`.
      *
@@ -1457,6 +1598,25 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * ```
      */
     clearOrderBy(): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Clears `group by` clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .groupBy('id')
+     *   .clearGroupBy()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearGroupBy(): SelectQueryBuilder<DB, TB, O>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.
@@ -1484,7 +1644,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
     /**
      * Call `func(this)` if `condition` is true.
      *
-     * NOTE: This method has an impact on typescript performance and it should only be used
+     * NOTE: This method has an impact on TypeScript performance and it should only be used
      * when necessary. Remember that you can call most methods like `where` conditionally
      * like this:
      *
@@ -1662,17 +1822,17 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
-     * This method can be used to simplify excessively complex types to make typescript happy
+     * This method can be used to simplify excessively complex types to make TypeScript happy
      * and much faster.
      *
      * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
-     * for typescript and you get errors like this:
+     * for TypeScript and you get errors like this:
      *
      * ```
      * error TS2589: Type instantiation is excessively deep and possibly infinite.
      * ```
      *
-     * In these case you can often use this method to help typescript a little bit. When you use this
+     * In these case you can often use this method to help TypeScript a little bit. When you use this
      * method to assert the output type of a query, Kysely can drop the complex output type that
      * consists of multiple nested helper types and replace it with the simple asserted type.
      *

package/dist/cjs/query-builder/select-query-builder.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSelectQueryBuilder = void 0;
+exports.createSelectQueryBuilder = createSelectQueryBuilder;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const select_modifier_node_js_1 = require("../operation-node/select-modifier-node.js");
 const join_parser_js_1 = require("../parser/join-parser.js");
@@ -21,6 +21,8 @@ const set_operation_parser_js_1 = require("../parser/set-operation-parser.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
 const expression_wrapper_js_1 = require("../expression/expression-wrapper.js");
 const value_parser_js_1 = require("../parser/value-parser.js");
+const fetch_parser_js_1 = require("../parser/fetch-parser.js");
+const top_parser_js_1 = require("../parser/top-parser.js");
 class SelectQueryBuilderImpl {
     #props;
     constructor(props) {
@@ -188,6 +190,18 @@ class SelectQueryBuilderImpl {
             queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOffset(this.#props.queryNode, offset_node_js_1.OffsetNode.create((0, value_parser_js_1.parseValueExpression)(offset))),
         });
     }
+    fetch(rowCount, modifier = 'only') {
+        return new SelectQueryBuilderImpl({
+            ...this.#props,
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithFetch(this.#props.queryNode, (0, fetch_parser_js_1.parseFetch)(rowCount, modifier)),
+        });
+    }
+    top(expression, modifiers) {
+        return new SelectQueryBuilderImpl({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithTop(this.#props.queryNode, (0, top_parser_js_1.parseTop)(expression, modifiers)),
+        });
+    }
     union(expression) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
@@ -257,6 +271,12 @@ class SelectQueryBuilderImpl {
             queryNode: select_query_node_js_1.SelectQueryNode.cloneWithoutOrderBy(this.#props.queryNode),
         });
     }
+    clearGroupBy() {
+        return new SelectQueryBuilderImpl({
+            ...this.#props,
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithoutGroupBy(this.#props.queryNode),
+        });
+    }
     $call(func) {
         return func(this);
     }
@@ -330,7 +350,6 @@ class SelectQueryBuilderImpl {
 function createSelectQueryBuilder(props) {
     return new SelectQueryBuilderImpl(props);
 }
-exports.createSelectQueryBuilder = createSelectQueryBuilder;
 /**
  * {@link SelectQueryBuilder} with an alias. The result of calling {@link SelectQueryBuilder.as}.
  */

package/dist/cjs/query-builder/update-query-builder.d.ts

@@ -3,7 +3,7 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
 import { TableExpression, From, FromTables } from '../parser/table-parser.js';
 import { SelectExpression, SelectCallback } from '../parser/select-parser.js';
-import { ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
+import { ReturningAllRow, ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
@@ -17,7 +17,6 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
-import { Selectable } from '../util/column-type.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
@@ -25,7 +24,8 @@ import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ValueExpression } from '../parser/value-parser.js';
-export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
+import { OutputCallback, OutputExpression, OutputInterface, OutputPrefix, SelectExpressionFromOutputCallback, SelectExpressionFromOutputExpression } from './output-interface.js';
+export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OutputInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: UpdateQueryBuilderProps);
     /**
@@ -290,7 +290,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     sql`coalesce(first_name, last_name)`,
+     *     sql<string>`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )
@@ -400,6 +400,46 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * ```
      */
     clearWhere(): UpdateQueryBuilder<DB, UT, TB, O>;
+    /**
+     * Changes an `update` query into a `update top` query.
+     *
+     * `top` clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Update the first row:
+     *
+     * ```ts
+     * await db.updateTable('person')
+     *   .top(1)
+     *   .set({ first_name: 'Foo' })
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * update top(1) "person" set "first_name" = @1 where "age" > @2
+     * ```
+     *
+     * Update the 50% first rows:
+     *
+     * ```ts
+     * await db.updateTable('person')
+     *   .top(50, 'percent')
+     *   .set({ first_name: 'Foo' })
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * update top(50) percent "person" set "first_name" = @1 where "age" > @2
+     * ```
+     */
+    top(expression: number | bigint, modifiers?: 'percent'): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a from clause to the update query.
      *
@@ -555,6 +595,26 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      */
     fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilderWithFullJoin<DB, UT, TB, O, TE>;
     fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilderWithFullJoin<DB, UT, TB, O, TE>;
+    /**
+     * Adds a limit clause to the update query for supported databases, such as MySQL.
+     *
+     * ### Examples
+     *
+     * Update the first 2 rows in the 'person' table:
+     *
+     * ```ts
+     * return await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'Foo' })
+     *   .limit(2);
+     * ```
+     *
+     * The generated SQL (MySQL):
+     * ```sql
+     * update `person` set `first_name` = 'Foo' limit 2
+     * ```
+     */
+    limit(limit: ValueExpression<DB, TB, number>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Sets the values to update for an {@link Kysely.updateTable | update} query.
      *
@@ -635,7 +695,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   .set('first_name', 'Foo')
      *   // As always, both arguments can be arbitrary expressions or
      *   // callbacks that give you access to an expression builder:
-     *   .set(sql`address['postalCode']`, (eb) => eb.val('61710))
+     *   .set(sql<string>`address['postalCode']`, (eb) => eb.val('61710))
      *   .where('id', '=', '1')
      *   .executeTakeFirst()
      * ```
@@ -676,7 +736,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *     first_name: selectFrom('person').select('first_name').limit(1),
      *     middle_name: ref('first_name'),
      *     age: eb('age', '+', 1),
-     *     last_name: sql`${'Ani'} || ${'ston'}`,
+     *     last_name: sql<string>`${'Ani'} || ${'ston'}`,
      *   }))
      *   .where('id', '=', 1)
      *   .executeTakeFirst()
@@ -762,8 +822,113 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
+     */
+    returningAll<T extends TB>(tables: ReadonlyArray<T>): UpdateQueryBuilder<DB, UT, TB, ReturningAllRow<DB, T, O>>;
+    returningAll<T extends TB>(table: T): UpdateQueryBuilder<DB, UT, TB, ReturningAllRow<DB, T, O>>;
+    returningAll(): UpdateQueryBuilder<DB, UT, TB, ReturningAllRow<DB, TB, O>>;
+    /**
+     * Allows you to return data from modified rows.
+     *
+     * On supported databases like MS SQL Server (MSSQL), this method can be chained
+     * to `insert`, `update`, `delete` and `merge` queries to return data.
+     *
+     * Also see the {@link outputAll} method.
+     *
+     * ### Examples
+     *
+     * Return one column:
+     *
+     * ```ts
+     * const { id } = await db
+     *   .insertInto('person')
+     *   .output('inserted.id')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return multiple columns:
+     *
+     * ```ts
+     * const { id, first_name } = await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'John', last_name: 'Doe' })
+     *   .output([
+     *     'deleted.first_name as old_first_name',
+     *     'deleted.last_name as old_last_name',
+     *     'inserted.first_name as new_first_name',
+     *     'inserted.last_name as new_last_name',
+     *   ])
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return arbitrary expressions:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const { id, full_name } = await db
+     *   .deleteFrom('person')
+     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name')
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return the action performed on the row:
+     *
+     * ```ts
+     * await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .whenNotMatched()
+     *   .thenInsertValues({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'male'
+     *   })
+     *   .output([
+     *     'inserted.id as inserted_id',
+     *     'deleted.id as deleted_id',
+     *   ])
+     * ```
+     */
+    output<OE extends OutputExpression<DB, UT>>(selections: readonly OE[]): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>>;
+    output<CB extends OutputCallback<DB, TB>>(callback: CB): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputCallback<CB>>>;
+    output<OE extends OutputExpression<DB, TB>>(selection: OE): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>>;
+    /**
+     * Adds an `output {prefix}.*` to an `insert`/`update`/`delete`/`merge` query on databases
+     * that support `output` such as MS SQL Server (MSSQL).
+     *
+     * Also see the {@link output} method.
+     */
+    outputAll(table: OutputPrefix): UpdateQueryBuilder<DB, UT, TB, ReturningAllRow<DB, TB, O>>;
+    /**
+     * Clears all `returning` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.updateTable('person')
+     *   .returningAll()
+     *   .set({ age: 39 })
+     *   .where('first_name', '=', 'John')
+     *   .clearReturning()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * update "person" set "age" = 39 where "first_name" = "John"
+     * ```
      */
-    returningAll(): UpdateQueryBuilder<DB, UT, TB, Selectable<DB[TB]>>;
+    clearReturning(): UpdateQueryBuilder<DB, UT, TB, UpdateResult>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.
@@ -880,17 +1045,17 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
-     * This method can be used to simplify excessively complex types to make typescript happy
+     * This method can be used to simplify excessively complex types to make TypeScript happy
      * and much faster.
      *
      * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
-     * for typescript and you get errors like this:
+     * for TypeScript and you get errors like this:
      *
      * ```
      * error TS2589: Type instantiation is excessively deep and possibly infinite.
      * ```
      *
-     * In these case you can often use this method to help typescript a little bit. When you use this
+     * In these case you can often use this method to help TypeScript a little bit. When you use this
      * method to assert the output type of a query, Kysely can drop the complex output type that
      * consists of multiple nested helper types and replace it with the simple asserted type.
      *