kysely 0.12.0 → 0.14.0

package/dist/esm/plugin/immediate-value.ts/immediate-value-plugin.d.ts

@@ -12,6 +12,40 @@ import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } fro
  */
 export declare class ImmediateValuePlugin implements KyselyPlugin {
     #private;
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * const plugin = {
+     *   data: new WeakMap<QueryId, SomeData>(),
+     *
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     this.data.set(args.queryId, something)
+     *     return args.node
+     *   },
+     *
+     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
+     *     const data = this.data.get(args.queryId)
+     *     return args.result
+     *   }
+     * }
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
     transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
     transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
 }

package/dist/esm/plugin/with-schema/with-schema-plugin.d.ts

@@ -5,6 +5,40 @@ import { UnknownRow } from '../../util/type-utils.js';
 export declare class WithSchemaPlugin implements KyselyPlugin {
     #private;
     constructor(schema: string);
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * const plugin = {
+     *   data: new WeakMap<QueryId, SomeData>(),
+     *
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     this.data.set(args.queryId, something)
+     *     return args.node
+     *   },
+     *
+     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
+     *     const data = this.data.get(args.queryId)
+     *     return args.result
+     *   }
+     * }
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
     transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
     transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
 }

package/dist/esm/plugin/with-schema/with-schema-transformer.js

@@ -79,6 +79,9 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
         if ('joins' in node && node.joins) {
             this.#collectTablesFromJoins(node.joins, tables);
         }
+        if ('with' in node && node.with) {
+            this.#removeCommonTableExpressionTables(node.with, tables);
+        }
         return tables;
     }
     #collectTablesFromTableExpressionNodes(nodes, tables) {
@@ -101,4 +104,9 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
             tables.add(table.table.identifier);
         }
     }
+    #removeCommonTableExpressionTables(node, tables) {
+        for (const expr of node.expressions) {
+            tables.delete(expr.name.table.table.identifier);
+        }
+    }
 }

package/dist/esm/query-builder/delete-query-builder.d.ts

@@ -20,28 +20,573 @@ import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
     #private;
     constructor(props: DeleteQueryBuilderProps);
+    /**
+     * Adds a `where` clause to the query.
+     *
+     * Also see {@link orWhere}, {@link whereExists} and {@link whereRef}.
+     *
+     * ### Examples
+     *
+     * Find a row by column value:
+     *
+     * ```ts
+     * const person = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where('id', '=', 100)
+     *   .executeTakeFirst()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "id" = $1
+     * ```
+     *
+     * Operator can be any supported operator or if the typings don't support it
+     * you can always use `db.raw('your operator')`.
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where('id', '>', 100)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "id" > $1
+     * ```
+     *
+     * The `where` methods don't change the type of the query. You can add
+     * conditional `where`s easily by doing something like this:
+     *
+     * ```ts
+     * let query = db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *
+     * if (firstName) {
+     *   query = query.where('first_name', '=', firstName)
+     * }
+     *
+     * const persons = await query.execute()
+     * ```
+     *
+     * This is true for basically all methods execpt the `select` and
+     * `returning` methods, which DO change the return type of the
+     * query.
+     *
+     * Both the first and third argument can also be subqueries.
+     * A subquery is defined by passing a function and calling
+     * the `selectFrom` method of the object passed into the
+     * function:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where(
+     *     (qb) => qb.selectFrom('pet')
+     *       .select('pet.name')
+     *       .whereRef('pet.owner_id', '=', 'person.id')
+     *       .limit(1),
+     *     '=',
+     *     'Fluffy'
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * where (
+     *   select "pet"."name"
+     *   from "pet"
+     *   where "pet"."owner_id" = "person"."id"
+     *   limit $1
+     * ) = $2
+     * ```
+     *
+     * A `where in` query can be built by using the `in` operator and an array
+     * of values. The values in the array can also be subqueries or raw
+     * instances.
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where('person.id', 'in', [100, 200, 300])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "id" in ($1, $2, $3)
+     * ```
+     *
+     * If everything else fails, you can always pass {@link Kysely.raw | raw}
+     * as any of the arguments, including the operator:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where(
+     *     db.raw('coalesce(first_name, last_name)'),
+     *     'like',
+     *     '%' + name + '%',
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * where coalesce(first_name, last_name) like $1
+     * ```
+     *
+     * If you only pass one function argument to this method, it can be
+     * used to create parentheses around other where statements:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where((qb) => qb
+     *     .where('id', '=', 1)
+     *     .orWhere('id', '=', 2)
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" (where "id" = 1 or "id" = 2)
+     * ```
+     *
+     * In all examples above the columns were known at compile time
+     * (except for the `raw` expressions). By default kysely only allows
+     * you to refer to columns that exist in the database **and** can be
+     * referred to in the current query and context.
+     *
+     * Sometimes you may want to refer to columns that come from the user
+     * input and thus are not available at compile time.
+     *
+     * You have two options, `db.raw` or `db.dynamic`. The example below
+     * uses both:
+     *
+     * ```ts
+     * const { ref } = db.dynamic
+     *
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where(ref(columnFromUserInput), '=', 1)
+     *   .orWhere(db.raw('??', [columnFromUserInput]), '=', 2)
+     *   .execute()
+     * ```
+     */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
     where(grouper: WhereGrouper<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     where(raw: AnyRawBuilder): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Adds a `where` clause where both sides of the operator are references
+     * to columns.
+     *
+     * The normal `where` method treats the right hand side argument as a
+     * value by default. `whereRef` treats it as a column reference. This method is
+     * expecially useful with joins and correclated subqueries.
+     *
+     * ### Examples
+     *
+     * Usage with a join:
+     *
+     * ```ts
+     * db.selectFrom(['person', 'pet'])
+     *   .selectAll()
+     *   .whereRef('person.first_name', '=', 'pet.name')
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person", "pet" where "person"."first_name" = "pet"."name"
+     * ```
+     *
+     * Usage in a subquery:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll('person')
+     *   .select((qb) => qb
+     *     .selectFrom('pet')
+     *     .select('name')
+     *     .whereRef('pet.owner_id', '=', 'person.id')
+     *     .limit(1)
+     *     .as('pet_name')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person".*, (
+     *   select "name"
+     *   from "pet"
+     *   where "pet"."owner_id" = "person"."id"
+     *   limit $1
+     * ) as "pet_name"
+     * from "person"
+     */
     whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
+     *
+     * It's often necessary to wrap `or where` clauses in parentheses to control
+     * precendence. You can use the one argument version of the `where` method
+     * for that. See the examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where('id', '=', 1)
+     *   .orWhere('id', '=', 2)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "id" = 1 or "id" = 2
+     * ```
+     *
+     * Grouping with parentheses:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where((qb) => qb
+     *     .where('id', '=', 1)
+     *     .orWhere('id', '=', 2)
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" (where "id" = 1 or "id" = 2)
+     * ```
+     *
+     * Even the first `where` can be an `orWhere`. This is useful
+     * if you are looping through a set of conditions:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where((qb) => qb
+     *     .orWhere('id', '=', 1)
+     *     .orWhere('id', '=', 2)
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" (where "id" = 1 or "id" = 2)
+     * ```
+     */
     orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): DeleteQueryBuilder<DB, TB, O>;
     orWhere(grouper: WhereGrouper<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
     orWhere(raw: AnyRawBuilder): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Adds an `or where` clause to the query. Otherwise works just like {@link whereRef}.
+     *
+     * Also see {@link orWhere} and {@link where}.
+     */
     orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Adds a `where exists` clause to the query.
+     *
+     * You can either use a subquery or a raw instance.
+     *
+     * ### Examples
+     *
+     * The query below selets all persons that own a pet named Catto:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .whereExists((qb) => qb
+     *     .selectFrom('pet')
+     *     .select('pet.id')
+     *     .whereRef('person.id', '=', 'pet.owner_id')
+     *     .where('pet.name', '=', 'Catto')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * where exists (
+     *   select "pet"."id"
+     *   from "pet"
+     *   where "person"."id" = "pet"."owner_id"
+     *   and "pet"."name" = $1
+     * )
+     * ```
+     *
+     * The same query as in the previous example but with using raw:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .whereExists(
+     *     db.raw(
+     *       '(select pet.id from pet where person.id = pet.owner_id and pet.name = ?)',
+     *       ['Catto']
+     *     )
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * where exists (
+     *   select pet.id
+     *   from pet
+     *   where person.id = pet.owner_id
+     *   and pet.name = $1
+     * )
+     * ```
+     */
     whereExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Just like {@link whereExists} but creates a `not exists` clause.
+     */
     whereNotExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Just like {@link whereExists} but creates a `or exists` clause.
+     */
     orWhereExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Just like {@link whereExists} but creates a `or not exists` clause.
+     */
     orWhereNotExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Joins another table to the query using an inner join.
+     *
+     * ### Examples
+     *
+     * Simple usage by providing a table name and two columns to join:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   // `select` needs to come after the call to `innerJoin` so
+     *   // that you can select from the joined table.
+     *   .select('person.id', 'pet.name')
+     *   .execute()
+     *
+     * result[0].id
+     * result[0].name
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person"."id", "pet"."name"
+     * from "person"
+     * inner join "pet"
+     * on "pet"."owner_id" = "person"."id"
+     * ```
+     *
+     * You can give an alias for the joined table like this:
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin('pet as p', 'p.owner_id', 'person.id')
+     *   .where('p.name', '=', 'Doggo')
+     *   .selectAll()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * inner join "pet" as "p"
+     * on "p"."owner_id" = "person"."id"
+     * where "p".name" = $1
+     * ```
+     *
+     * You can provide a function as the second argument to get a join
+     * 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`, `onExists` etc.). You can do all the same things
+     * with the `on` method that you can with the corresponding `where`
+     * method. See the `where` method documentation for more examples.
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin(
+     *     'pet',
+     *     (join) => join
+     *       .onRef('pet.owner_id', '=', 'person.id')
+     *       .on('pet.name', '=', 'Doggo')
+     *   )
+     *   .selectAll()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * inner join "pet"
+     * on "pet"."owner_id" = "person"."id"
+     * and "pet"."name" = $1
+     * ```
+     *
+     * You can join a subquery by providing a function as the first
+     * argument:
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin(
+     *     (qb) => qb.selectFrom('pet')
+     *       .select(['owner_id', 'name'])
+     *       .where('name', '=', 'Doggo')
+     *       .as('doggos'),
+     *     'doggos.owner_id',
+     *     'person.id',
+     *   )
+     *   .selectAll()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * inner join (
+     *   select "owner_id", "name"
+     *   from "pet"
+     *   where "name" = $1
+     * ) as "doggos"
+     * on "doggos"."owner_id" = "person"."id"
+     * ```
+     */
     innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
     innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    /**
+     * Just like {@link innerJoin} but adds a left join nstead of an inner join.
+     */
     leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
     leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    /**
+     * Just like {@link innerJoin} but adds a right join instead of an inner join.
+     */
     rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
     rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    /**
+     * Just like {@link innerJoin} but adds a full join instead of an inner join.
+     */
     fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
     fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    /**
+     * Allows you to return data from modified rows.
+     *
+     * On supported databases like PostgreSQL, this method can be chained to
+     * `insert`, `update` and `delete` queries to return data.
+     *
+     * Note that on SQLite you need to give aliases for the expressions to avoid
+     * [this bug](https://sqlite.org/forum/forumpost/033daf0b32) in SQLite.
+     * For example `.returning('id as id')`.
+     *
+     * Also see the {@link returningAll} method.
+     *
+     * ### Examples
+     *
+     * Return one column:
+     *
+     * ```ts
+     * const { id } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     id: db.generated,
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning('id')
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return multiple columns:
+     *
+     * ```ts
+     * const { id, first_name } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     id: db.generated,
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning(['id', 'last_name'])
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return arbitrary expressions:
+     *
+     * ```ts
+     * const { raw } = db
+     *
+     * const { id, full_name, first_pet_id } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     id: db.generated,
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning([
+     *     'id as id',
+     *     raw<string>(`concat(first_name, ' ', last_name)`).as('full_name'),
+     *     (qb) => qb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
+     *   ])
+     *   .executeTakeFirst()
+     * ```
+     */
     returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
     returning<SE extends SelectExpression<DB, TB>>(selection: SE): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    /**
+     * Adds a `returning *` to an insert/update/delete query on databases
+     * that support `returning` such as PostgreSQL.
+     */
     returningAll(): DeleteQueryBuilder<DB, TB, DB[TB]>;
     /**
      * Simply calls the given function passing `this` as the only argument.