kysely 0.23.5 → 0.24.1

package/dist/cjs/query-builder/on-conflict-builder.d.ts

@@ -1,12 +1,12 @@
 import { Expression } from '../expression/expression.js';
 import { OnConflictNode } from '../operation-node/on-conflict-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { UpdateObject } from '../parser/update-set-parser.js';
+import { UpdateExpression } from '../parser/update-set-parser.js';
 import { AnyColumn } from '../util/type-utils.js';
-import { WhereInterface } from './where-interface.js';
+import { WhereExpressionFactory, WhereInterface } from './where-interface.js';
 export declare class OnConflictBuilder<DB, TB extends keyof DB> implements WhereInterface<DB, TB> {
     #private;
     constructor(props: OnConflictBuilderProps);
@@ -47,53 +47,37 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OnConflictBuilder<DB, TB>;
     /**
-     * Adds a `where` clause to the query.
+     * Adds a `where` expression to the query.
      *
-     * Also see {@link orWhere}, {@link whereExists} and {@link whereRef}.
+     * Calling this method multiple times will combine the expressions using `and`.
      *
-     * ### Examples
+     * Also see {@link whereRef}
      *
-     * Find a row by column value:
+     * ### Examples
      *
      * ```ts
      * const person = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where('id', '=', 100)
+     *   .where('first_name', '=', 'Jennifer')
+     *   .where('age', '>', 40)
      *   .executeTakeFirst()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person" where "id" = $1
+     * select * from "person" where "first_name" = $1 and "age" > $2
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use
+     * you can always use:
      *
      * ```ts
      * sql`your operator`
      * ```
      *
-     * The next example uses the `>` operator:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .where('id', '>', 100)
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" where "id" > $1
-     * ```
-     *
-     * `where` methods don't change the type of the query. You can add
-     * conditional statements easily by doing something like this:
+     * You can add expressions conditionally like this:
      *
      * ```ts
      * let query = db
@@ -106,16 +90,16 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      *   query = query.where('first_name', '=', firstName)
      * }
      *
+     * if (lastName) {
+     *   query = query.where('last_name', '=', lastName)
+     * }
+     *
      * const persons = await query.execute()
      * ```
      *
-     * This is true for basically all methods execpt the `select` and
-     * `returning`, that __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:
+     * Both the first and third argument can also be arbitrary expressions like
+     * subqueries. An expression can defined by passing a function and calling
+     * the methods of the {@link ExpressionBuilder} passed to the callback:
      *
      * ```ts
      * const persons = await db
@@ -146,8 +130,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * ```
      *
      * 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
-     * {@link sql} expressions.
+     * of values. The values in the array can also be expressions:
      *
      * ```ts
      * const persons = await db
@@ -163,40 +146,53 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * If everything else fails, you can always use the {@link sql} tag
-     * as any of the arguments, including the operator:
+     * For complex `where` expressions you can pass in a single callback and
+     * use the {@link ExpressionBuilder} to build your expression:
      *
      * ```ts
-     * import { sql } from 'kysely'
-     *
      * const persons = await db
      *   .selectFrom('person')
-     *   .selectAll()
-     *   .where(
-     *     sql`coalesce(first_name, last_name)`,
-     *     'like',
-     *     '%' + name + '%',
-     *   )
-     *   .execute()
+     *   .selectAll('person')
+     *   .where(({ cmpr, or, and, not, exists, selectFrom, val }) => and([
+     *     or([
+     *       cmpr('first_name', '=', firstName),
+     *       cmpr('age', '<', maxAge)
+     *     ]),
+     *     not(exists(
+     *       selectFrom('pet').select('pet.id').whereRef('pet.owner_id', '=', 'person.id')
+     *     ))
+     *   ]))
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person"
-     * where coalesce(first_name, last_name) like $1
+     * select "person".*
+     * from "person"
+     * where (
+     *   (
+     *     "first_name" = $1
+     *     or "age" < $2
+     *   )
+     *   and not exists (
+     *     select "pet"."id" from "pet" where "pet"."owner_id" = "person"."id"
+     *   )
+     * )
      * ```
      *
-     * If you only pass one function argument to this method, it can be
-     * used to create parentheses around other where statements:
+     * If everything else fails, you can always use the {@link sql} tag
+     * as any of the arguments, including the operator:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where((qb) => qb
-     *     .where('id', '=', 1)
-     *     .orWhere('id', '=', 2)
+     *   .where(
+     *     sql`coalesce(first_name, last_name)`,
+     *     'like',
+     *     '%' + name + '%',
      *   )
      *   .execute()
      * ```
@@ -204,7 +200,8 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person" (where "id" = 1 or "id" = 2)
+     * select * from "person"
+     * where coalesce(first_name, last_name) like $1
      * ```
      *
      * In all examples above the columns were known at compile time
@@ -226,11 +223,11 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(ref(columnFromUserInput), '=', 1)
-     *   .orWhere(sql.id(columnFromUserInput), '=', 2)
+     *   .where(sql.id(columnFromUserInput), '=', 2)
      *   .execute()
      * ```
      */
-    where(grouper: WhereGrouper<DB, TB>): OnConflictBuilder<DB, TB>;
+    where(factory: WhereExpressionFactory<DB, TB>): OnConflictBuilder<DB, TB>;
     where(expression: Expression<any>): OnConflictBuilder<DB, TB>;
     /**
      * Specify an index predicate for the index target.
@@ -239,108 +236,39 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      */
     whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): OnConflictBuilder<DB, TB>;
     /**
-     * Specify an index predicate for the index target.
-     *
-     * See {@link WhereInterface.orWhere} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OnConflictBuilder<DB, TB>;
     /**
-     * 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)
-     * ```
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
+    orWhere(factory: WhereExpressionFactory<DB, TB>): OnConflictBuilder<DB, TB>;
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
-    orWhere(grouper: WhereGrouper<DB, TB>): OnConflictBuilder<DB, TB>;
     orWhere(expression: Expression<any>): OnConflictBuilder<DB, TB>;
     /**
-     * Specify an index predicate for the index target.
-     *
-     * See {@link WhereInterface.orWhereRef} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): OnConflictBuilder<DB, TB>;
     /**
-     * Specify an index predicate for the index target.
-     *
-     * See {@link WhereInterface.whereExists} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     whereExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictBuilder<DB, TB>;
     /**
-     * Specify an index predicate for the index target.
-     *
-     * See {@link WhereInterface.whereNotExists} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     whereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictBuilder<DB, TB>;
     /**
-     * Specify an index predicate for the index target.
-     *
-     * See {@link WhereInterface.orWhereExists} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictBuilder<DB, TB>;
     /**
-     * Specify an index predicate for the index target.
-     *
-     * See {@link WhereInterface.orWhereNotExists} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictBuilder<DB, TB>;
     /**
-     * Clears all where clauses from the query.
+     * Clears all where expressions from the query.
      *
      * ### Examples
      *
@@ -405,8 +333,29 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * on conflict ("pic")
      * do update set "first_name" = $3
      * ```
+     *
+     * In the next example we use the `ref` method to reference
+     * columns of the virtual table `excluded` in a type-safe way
+     * to create an upsert operation:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict((oc) => oc
+     *     .column('id')
+     *     .doUpdateSet((eb) => ({
+     *       first_name: eb.ref('excluded.first_name'),
+     *       last_name: eb.ref('excluded.last_name')
+     *     }))
+     *   )
+     * ```
+     */
+    doUpdateSet(update: UpdateExpression<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
      */
-    doUpdateSet(updates: UpdateObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
+    $call<T>(func: (qb: this) => T): T;
 }
 export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;
@@ -430,53 +379,37 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OnConflictUpdateBuilder<DB, TB>;
     /**
-     * Adds a `where` clause to the query.
+     * Adds a `where` expression to the query.
      *
-     * Also see {@link orWhere}, {@link whereExists} and {@link whereRef}.
+     * Calling this method multiple times will combine the expressions using `and`.
      *
-     * ### Examples
+     * Also see {@link whereRef}
      *
-     * Find a row by column value:
+     * ### Examples
      *
      * ```ts
      * const person = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where('id', '=', 100)
+     *   .where('first_name', '=', 'Jennifer')
+     *   .where('age', '>', 40)
      *   .executeTakeFirst()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person" where "id" = $1
+     * select * from "person" where "first_name" = $1 and "age" > $2
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use
+     * you can always use:
      *
      * ```ts
      * sql`your operator`
      * ```
      *
-     * The next example uses the `>` operator:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .where('id', '>', 100)
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" where "id" > $1
-     * ```
-     *
-     * `where` methods don't change the type of the query. You can add
-     * conditional statements easily by doing something like this:
+     * You can add expressions conditionally like this:
      *
      * ```ts
      * let query = db
@@ -489,16 +422,16 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      *   query = query.where('first_name', '=', firstName)
      * }
      *
+     * if (lastName) {
+     *   query = query.where('last_name', '=', lastName)
+     * }
+     *
      * const persons = await query.execute()
      * ```
      *
-     * This is true for basically all methods execpt the `select` and
-     * `returning`, that __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:
+     * Both the first and third argument can also be arbitrary expressions like
+     * subqueries. An expression can defined by passing a function and calling
+     * the methods of the {@link ExpressionBuilder} passed to the callback:
      *
      * ```ts
      * const persons = await db
@@ -529,8 +462,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * ```
      *
      * 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
-     * {@link sql} expressions.
+     * of values. The values in the array can also be expressions:
      *
      * ```ts
      * const persons = await db
@@ -546,40 +478,53 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * If everything else fails, you can always use the {@link sql} tag
-     * as any of the arguments, including the operator:
+     * For complex `where` expressions you can pass in a single callback and
+     * use the {@link ExpressionBuilder} to build your expression:
      *
      * ```ts
-     * import { sql } from 'kysely'
-     *
      * const persons = await db
      *   .selectFrom('person')
-     *   .selectAll()
-     *   .where(
-     *     sql`coalesce(first_name, last_name)`,
-     *     'like',
-     *     '%' + name + '%',
-     *   )
-     *   .execute()
+     *   .selectAll('person')
+     *   .where(({ cmpr, or, and, not, exists, selectFrom, val }) => and([
+     *     or([
+     *       cmpr('first_name', '=', firstName),
+     *       cmpr('age', '<', maxAge)
+     *     ]),
+     *     not(exists(
+     *       selectFrom('pet').select('pet.id').whereRef('pet.owner_id', '=', 'person.id')
+     *     ))
+     *   ]))
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person"
-     * where coalesce(first_name, last_name) like $1
+     * select "person".*
+     * from "person"
+     * where (
+     *   (
+     *     "first_name" = $1
+     *     or "age" < $2
+     *   )
+     *   and not exists (
+     *     select "pet"."id" from "pet" where "pet"."owner_id" = "person"."id"
+     *   )
+     * )
      * ```
      *
-     * If you only pass one function argument to this method, it can be
-     * used to create parentheses around other where statements:
+     * If everything else fails, you can always use the {@link sql} tag
+     * as any of the arguments, including the operator:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where((qb) => qb
-     *     .where('id', '=', 1)
-     *     .orWhere('id', '=', 2)
+     *   .where(
+     *     sql`coalesce(first_name, last_name)`,
+     *     'like',
+     *     '%' + name + '%',
      *   )
      *   .execute()
      * ```
@@ -587,7 +532,8 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person" (where "id" = 1 or "id" = 2)
+     * select * from "person"
+     * where coalesce(first_name, last_name) like $1
      * ```
      *
      * In all examples above the columns were known at compile time
@@ -609,11 +555,11 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(ref(columnFromUserInput), '=', 1)
-     *   .orWhere(sql.id(columnFromUserInput), '=', 2)
+     *   .where(sql.id(columnFromUserInput), '=', 2)
      *   .execute()
      * ```
      */
-    where(grouper: WhereGrouper<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
+    where(factory: WhereExpressionFactory<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
     where(expression: Expression<any>): OnConflictUpdateBuilder<DB, TB>;
     /**
      * Specify a where condition for the update operation.
@@ -622,108 +568,39 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      */
     whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
     /**
-     * Specify a where condition for the update operation.
-     *
-     * See {@link WhereInterface.orWhere} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OnConflictUpdateBuilder<DB, TB>;
     /**
-     * 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)
-     * ```
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
+    orWhere(factory: WhereExpressionFactory<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
-    orWhere(grouper: WhereGrouper<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
     orWhere(expression: Expression<any>): OnConflictUpdateBuilder<DB, TB>;
     /**
-     * Specify a where condition for the update operation.
-     *
-     * See {@link WhereInterface.orWhereRef} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): OnConflictUpdateBuilder<DB, TB>;
     /**
-     * Specify a where condition for the update operation.
-     *
-     * See {@link WhereInterface.whereExists} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     whereExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictUpdateBuilder<DB, TB>;
     /**
-     * Specify a where condition for the update operation.
-     *
-     * See {@link WhereInterface.whereNotExists} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     whereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictUpdateBuilder<DB, TB>;
     /**
-     * Specify a where condition for the update operation.
-     *
-     * See {@link WhereInterface.orWhereExists} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictUpdateBuilder<DB, TB>;
     /**
-     * Specify a where condition for the update operation.
-     *
-     * See {@link WhereInterface.orWhereNotExists} for more info.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictUpdateBuilder<DB, TB>;
     /**
-     * Clears all where clauses from the query.
+     * Clears all where expressions from the query.
      *
      * ### Examples
      *
@@ -741,5 +618,10 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * ```
      */
     clearWhere(): OnConflictUpdateBuilder<DB, TB>;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
     toOperationNode(): OnConflictNode;
 }