kysely 0.25.0 → 0.26.0

package/dist/cjs/query-builder/delete-result.js

@@ -2,15 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeleteResult = void 0;
 class DeleteResult {
-    #numDeletedRows;
+    numDeletedRows;
     constructor(numDeletedRows) {
-        this.#numDeletedRows = numDeletedRows;
-    }
-    get numDeletedRows() {
-        return this.#numDeletedRows;
+        this.numDeletedRows = numDeletedRows;
     }
 }
 exports.DeleteResult = DeleteResult;
-Object.defineProperty(DeleteResult.prototype, 'numDeletedRows', {
-    enumerable: true,
-});

package/dist/cjs/query-builder/function-module.d.ts

@@ -1,7 +1,7 @@
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { ExpressionWrapper } from '../expression/expression-wrapper.js';
 import { CoalesceReferenceExpressionList } from '../parser/coalesce-parser.js';
-import { ExtractTypeFromReferenceExpression, SimpleReferenceExpression, ReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { ExtractTypeFromReferenceExpression, ReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { Equals, IsAny } from '../util/type-utils.js';
 import { AggregateFunctionBuilder } from './aggregate-function-builder.js';
 /**
@@ -12,24 +12,36 @@ import { AggregateFunctionBuilder } from './aggregate-function-builder.js';
  *
  * ### Examples
  *
- * ```ts
- * const { count } = db.fn
+ * <!-- siteExample("select", "Function calls", 60) -->
+ *
+ * This example uses the `fn` module to select some aggregates:
  *
- * await db.selectFrom('person')
+ * ```ts
+ * const result = await db.selectFrom('person')
  *   .innerJoin('pet', 'pet.owner_id', 'person.id')
- *   .select([
+ *   .select(({ fn }) => [
  *     'person.id',
- *     count('pet.id').as('pet_count')
+ *
+ *     // The `fn` module contains the most common
+ *     // functions.
+ *     fn.count<number>('pet.id').as('pet_count'),
+ *
+ *     // You can call any function using the
+ *     // `agg` method
+ *     fn.agg<string[]>('array_agg', ['pet.name']).as('pet_names')
  *   ])
  *   .groupBy('person.id')
- *   .having(count('pet.id'), '>', 10)
+ *   .having((eb) => eb.fn.count('pet.id'), '>', 10)
  *   .execute()
  * ```
  *
  * The generated SQL (PostgreSQL):
  *
  * ```sql
- * select "person"."id", count("pet"."id") as "pet_count"
+ * select
+ *   "person"."id",
+ *   count("pet"."id") as "pet_count",
+ *   array_agg("pet"."name") as "pet_names"
  * from "person"
  * inner join "pet" on "pet"."owner_id" = "person"."id"
  * group by "person"."id"
@@ -66,7 +78,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *   .where(sql`upper(first_name)`, '=', 'JENNIFER')
      * ```
      */
-    <T>(name: string, args: ReadonlyArray<ReferenceExpression<DB, TB>>): ExpressionWrapper<T>;
+    <T>(name: string, args: ReadonlyArray<ReferenceExpression<DB, TB>>): ExpressionWrapper<DB, TB, T>;
     /**
      * Creates an aggregate function call.
      *
@@ -108,10 +120,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { avg } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(avg('price').as('avg_price'))
+     *   .select((eb) => eb.fn.avg('price').as('avg_price'))
      *   .execute()
      * ```
      *
@@ -140,10 +150,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * the first type argument:
      *
      * ```ts
-     * const { avg } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(avg<number>('price').as('avg_price'))
+     *   .select((eb) => eb.fn.avg<number>('price').as('avg_price'))
      *   .execute()
      * ```
      *
@@ -153,14 +161,12 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * function.
      *
      * ```ts
-     * const { avg } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(avg<number | null>('price').as('avg_price'))
+     *   .select((eb) => eb.fn.avg<number | null>('price').as('avg_price'))
      *   .execute()
      * ```
      */
-    avg<O extends number | string | null = number | string, C extends SimpleReferenceExpression<DB, TB> = SimpleReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    avg<O extends number | string | null = number | string, C extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Calls the `coalesce` function for given arguments.
      *
@@ -182,10 +188,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { coalesce } = db.fn
-     *
      * db.selectFrom('participant')
-     *   .select(coalesce('nickname', sql<string>`'<anonymous>'`).as('nickname'))
+     *   .select((eb) => eb.fn.coalesce('nickname', sql<string>`'<anonymous>'`).as('nickname'))
      *   .where('room_id', '=', roomId)
      *   .execute()
      * ```
@@ -211,10 +215,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * You can combine this function with other helpers in this module:
      *
      * ```ts
-     * const { avg, coalesce } = db.fn
-     *
      * db.selectFrom('person')
-     *   .select(coalesce(avg<number | null>('age'), sql<number>`0`).as('avg_age'))
+     *   .select((eb) => eb.fn.coalesce(eb.fn.avg<number | null>('age'), sql<number>`0`).as('avg_age'))
      *   .where('first_name', '=', 'Jennifer')
      *   .execute()
      * ```
@@ -225,7 +227,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * select coalesce(avg("age"), 0) as "avg_age" from "person" where "first_name" = $1
      * ```
      */
-    coalesce<V extends ReferenceExpression<DB, TB>, OV extends ReferenceExpression<DB, TB>[]>(value: V, ...otherValues: OV): ExpressionWrapper<CoalesceReferenceExpressionList<DB, TB, [V, ...OV]>>;
+    coalesce<V extends ReferenceExpression<DB, TB>, OV extends ReferenceExpression<DB, TB>[]>(value: V, ...otherValues: OV): ExpressionWrapper<DB, TB, CoalesceReferenceExpressionList<DB, TB, [V, ...OV]>>;
     /**
      * Calls the `count` function for the column given as the argument.
      *
@@ -241,10 +243,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { count } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(count('id').as('num_toys'))
+     *   .select((eb) => eb.fn.count('id').as('num_toys'))
      *   .execute()
      * ```
      *
@@ -265,10 +265,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * the type as the first type argument:
      *
      * ```ts
-     * const { count } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(count<number>('id').as('num_toys'))
+     *   .select((eb) => eb.fn.count<number>('id').as('num_toys'))
      *   .execute()
      * ```
      *
@@ -280,7 +278,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    count<O extends number | string | bigint, C extends SimpleReferenceExpression<DB, TB> = SimpleReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    count<O extends number | string | bigint, C extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Calls the `count` function with `*` or `table.*` as argument.
      *
@@ -297,10 +295,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { countAll } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(countAll().as('num_toys'))
+     *   .select((eb) => eb.fn.countAll().as('num_toys'))
      *   .execute()
      * ```
      *
@@ -321,10 +317,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * the type as the first type argument:
      *
      * ```ts
-     * const { countAll } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(countAll<number>().as('num_toys'))
+     *   .select((eb) => eb.fn.countAll<number>().as('num_toys'))
      *   .execute()
      * ```
      *
@@ -332,11 +326,9 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * table:
      *
      * ```ts
-     * const { countAll } = db.fn
-     *
      * db.selectFrom('toy')
      *   .innerJoin('pet', 'pet.id', 'toy.pet_id')
-     *   .select(countAll('toy').as('num_toys'))
+     *   .select((eb) => eb.fn.countAll('toy').as('num_toys'))
      *   .execute()
      * ```
      *
@@ -374,10 +366,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { max } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(max('price').as('max_price'))
+     *   .select((eb) => eb.fn.max('price').as('max_price'))
      *   .execute()
      * ```
      *
@@ -401,10 +391,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * function.
      *
      * ```ts
-     * const { max } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(max<number | null, 'price'>('price').as('max_price'))
+     *   .select((eb) => eb.fn.max<number | null, 'price'>('price').as('max_price'))
      *   .execute()
      * ```
      */
@@ -426,10 +414,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { min } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(min('price').as('min_price'))
+     *   .select((eb) => eb.fn.min('price').as('min_price'))
      *   .execute()
      * ```
      *
@@ -453,10 +439,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * function.
      *
      * ```ts
-     * const { min } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(min<number | null, 'price'>('price').as('min_price'))
+     *   .select((eb) => eb.fn.min<number | null, 'price'>('price').as('min_price'))
      *   .execute()
      * ```
      */
@@ -474,10 +458,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ### Examples
      *
      * ```ts
-     * const { sum } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(sum('price').as('total_price'))
+     *   .select((eb) => eb.fn.sum('price').as('total_price'))
      *   .execute()
      * ```
      *
@@ -506,10 +488,8 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * the first type argument:
      *
      * ```ts
-     * const { sum } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(sum<number>('price').as('total_price'))
+     *   .select((eb) => eb.fn.sum<number>('price').as('total_price'))
      *   .execute()
      * ```
      *
@@ -519,16 +499,14 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * function.
      *
      * ```ts
-     * const { sum } = db.fn
-     *
      * db.selectFrom('toy')
-     *   .select(sum<number | null>('price').as('total_price'))
+     *   .select((eb) => eb.fn.sum<number | null>('price').as('total_price'))
      *   .execute()
      * ```
      */
-    sum<O extends number | string | bigint | null = number | string | bigint, C extends SimpleReferenceExpression<DB, TB> = SimpleReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
+    sum<O extends number | string | bigint | null = number | string | bigint, C extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(column: C): AggregateFunctionBuilder<DB, TB, O>;
 }
 export declare function createFunctionModule<DB, TB extends keyof DB>(): FunctionModule<DB, TB>;
-declare type OutputBoundStringReference<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = IsAny<O> extends true ? C : Equals<ExtractTypeFromReferenceExpression<DB, TB, C> | null, O | null> extends true ? C : never;
-declare type StringReferenceBoundAggregateFunctionBuilder<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = AggregateFunctionBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C> | (IsAny<O> extends true ? never : null extends O ? null : never)>;
+type OutputBoundStringReference<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = IsAny<O> extends true ? C : Equals<ExtractTypeFromReferenceExpression<DB, TB, C> | null, O | null> extends true ? C : never;
+type StringReferenceBoundAggregateFunctionBuilder<DB, TB extends keyof DB, C extends StringReference<DB, TB>, O> = AggregateFunctionBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C> | (IsAny<O> extends true ? never : null extends O ? null : never)>;
 export {};

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

@@ -1,9 +1,8 @@
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { ExistsExpression } from '../parser/unary-operation-parser.js';
 import { SqlBool } from '../util/type-utils.js';
-import { HavingExpressionBuilder } from './deprecated-having-expression-builder.js';
 export interface HavingInterface<DB, TB extends keyof DB> {
     /**
      * Just like {@link WhereInterface.where | where} but adds a `having` statement
@@ -17,37 +16,5 @@ export interface HavingInterface<DB, TB extends keyof DB> {
      * instead of a `where` statement.
      */
     havingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHaving<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHaving(factory: HavingExpressionFactory<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHaving(expression: Expression<any>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHavingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    havingExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    havingNotExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHavingExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHavingNotExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
 }
-export declare type HavingExpressionFactory<DB, TB extends keyof DB> = (eb: HavingExpressionBuilder<DB, TB>) => Expression<SqlBool> | HavingExpressionBuilder<DB, TB>;
+export type HavingExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => Expression<SqlBool>;

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

@@ -15,7 +15,7 @@ import { ReturningRow } from '../parser/returning-parser.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReturningInterface } from './returning-interface.js';
-import { OnConflictBuilder, OnConflictDoNothingBuilder, OnConflictUpdateBuilder } from './on-conflict-builder.js';
+import { OnConflictBuilder, OnConflictDatabase, OnConflictDoNothingBuilder, OnConflictTables, OnConflictUpdateBuilder } from './on-conflict-builder.js';
 import { Selectable } from '../util/column-type.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
@@ -46,23 +46,31 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * ### Examples
      *
-     * Insert a row into `person`:
+     * <!-- siteExample("insert", "Single row", 10) -->
+     *
+     * Insert a single row:
+     *
      * ```ts
      * const result = await db
      *   .insertInto('person')
      *   .values({
      *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
+     *     last_name: 'Aniston',
+     *     age: 40
      *   })
-     *   .executeTakeFirstOrThrow()
+     *   .executeTakeFirst()
+     *
+     * console.log(result.insertId)
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name", "last_name") values ($1, $2)
+     * insert into "person" ("first_name", "last_name", "age") values ($1, $2, $3)
      * ```
      *
+     * <!-- siteExample("insert", "Multiple rows", 20) -->
+     *
      * On dialects that support it (for example PostgreSQL) you can insert multiple
      * rows by providing an array. Note that the return value is once again very
      * dialect-specific. Some databases may only return the id of the *last* inserted
@@ -73,10 +81,12 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .insertInto('person')
      *   .values([{
      *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
+     *     last_name: 'Aniston',
+     *     age: 40,
      *   }, {
      *     first_name: 'Arnold',
      *     last_name: 'Schwarzenegger',
+     *     age: 70,
      *   }])
      *   .execute()
      * ```
@@ -84,56 +94,61 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name", "last_name") values (($1, $2), ($3, $4))
+     * insert into "person" ("first_name", "last_name", "age") values (($1, $2, $3), ($4, $5, $6))
      * ```
      *
-     * On PostgreSQL you need to chain `returning` to the query to get
-     * the inserted row's columns (or any other expression) as the
-     * return value:
+     * <!-- siteExample("insert", "Returning data", 30) -->
+     *
+     * On supported dialects like PostgreSQL you need to chain `returning` to the query to get
+     * the inserted row's columns (or any other expression) as the return value. `returning`
+     * works just like `select`. Refer to `select` method's examples and documentation for
+     * more info.
      *
      * ```ts
-     * const row = await db
+     * const result = await db
      *   .insertInto('person')
      *   .values({
      *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
+     *     last_name: 'Aniston',
+     *     age: 40,
      *   })
-     *   .returning('id')
+     *   .returning(['id', 'first_name as name'])
      *   .executeTakeFirstOrThrow()
-     *
-     * row.id
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name", "last_name") values ($1, $2) returning "id"
+     * insert into "person" ("first_name", "last_name", "age") values ($1, $2, $3) returning "id", "first_name" as "name"
      * ```
      *
-     * In addition to primitives, the values can also be raw sql expressions or
-     * select queries:
+     * <!-- siteExample("insert", "Complex values", 40) -->
+     *
+     * In addition to primitives, the values can also be arbitrary expressions.
+     * You can build the expressions by using a callback and calling the methods
+     * on the expression builder passed to it:
      *
      * ```ts
      * import { sql } from 'kysely'
      *
      * const result = await db
      *   .insertInto('person')
-     *   .values((eb) => ({
+     *   .values(({ ref, selectFrom, fn }) => ({
      *     first_name: 'Jennifer',
      *     last_name: sql`${'Ani'} || ${'ston'}`,
-     *     middle_name: eb.ref('first_name'),
-     *     age: eb.selectFrom('person').select(sql`avg(age)`),
+     *     middle_name: ref('first_name'),
+     *     age: selectFrom('person')
+     *       .select(fn.avg<number>('age')
+     *       .as('avg_age')),
      *   }))
      *   .executeTakeFirst()
-     *
-     * console.log(result.insertId)
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
      * insert into "person" ("first_name", "last_name", "age")
-     * values ($1, $2 || $3, (select avg(age) from "person"))
+     * values ($1, $2 || $3, (select avg("age") as "avg_age" from "person"))
      * ```
      *
      * You can also use the callback version of subqueries or raw expressions:
@@ -181,17 +196,29 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * ### Examples
      *
+     * <!-- siteExample("insert", "Insert subquery", 50) -->
+     *
+     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method:
+     *
      * ```ts
-     * db.insertInto('person')
-     *   .columns(['first_name'])
-     *   .expression((eb) => eb.selectFrom('pet').select('pet.name'))
+     * const result = await db.insertInto('person')
+     *   .columns(['first_name', 'last_name', 'age'])
+     *   .expression((eb) => eb
+     *     .selectFrom('pet')
+     *     .select((eb) => [
+     *       'pet.name',
+     *       eb.val('Petson').as('last_name'),
+     *       eb.val(7).as('age'),
+     *     ])
+     *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name")
-     * select "pet"."name" from "pet"
+     * insert into "person" ("first_name", "last_name", "age")
+     * select "pet"."name", $1 as "first_name", $2 as "last_name" from "pet"
      * ```
      */
     expression(expression: ExpressionOrFactory<DB, TB, any>): InsertQueryBuilder<DB, TB, O>;
@@ -368,7 +395,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   )
      * ```
      */
-    onConflict(callback: (builder: OnConflictBuilder<DB, TB>) => OnConflictDoNothingBuilder<DB, TB> | OnConflictUpdateBuilder<DB, TB>): InsertQueryBuilder<DB, TB, O>;
+    onConflict(callback: (builder: OnConflictBuilder<DB, TB>) => OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>> | OnConflictDoNothingBuilder<DB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Adds `on duplicate key update` to the query.
      *
@@ -439,7 +466,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
-     *   .returning(eb => [
+     *   .returning((eb) => [
      *     'id as id',
      *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name'),
      *     eb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
@@ -477,10 +504,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * ```
      */
     $call<T>(func: (qb: this) => T): T;
-    /**
-     * @deprecated Use `$call` instead
-     */
-    call<T>(func: (qb: this) => T): T;
     /**
      * Call `func(this)` if `condition` is true.
      *
@@ -517,10 +540,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * ```
      */
     $if<O2>(condition: boolean, func: (qb: this) => InsertQueryBuilder<DB, TB, O2>): O2 extends InsertResult ? InsertQueryBuilder<DB, TB, InsertResult> : O2 extends O & infer E ? InsertQueryBuilder<DB, TB, O & Partial<E>> : InsertQueryBuilder<DB, TB, Partial<O2>>;
-    /**
-     * @deprecated Use `$if` instead
-     */
-    if<O2>(condition: boolean, func: (qb: this) => InsertQueryBuilder<DB, TB, O2>): O2 extends InsertResult ? InsertQueryBuilder<DB, TB, InsertResult> : O2 extends O & infer E ? InsertQueryBuilder<DB, TB, O & Partial<E>> : InsertQueryBuilder<DB, TB, Partial<O2>>;
     /**
      * Change the output type of the query.
      *
@@ -528,10 +547,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * don't support your use case.
      */
     $castTo<T>(): InsertQueryBuilder<DB, TB, T>;
-    /**
-     * @deprecated Use `$castTo` instead.
-     */
-    castTo<T>(): InsertQueryBuilder<DB, TB, T>;
     /**
      * Narrows (parts of) the output type of the query.
      *
@@ -615,10 +630,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * ```
      */
     $assertType<T extends O>(): O extends T ? InsertQueryBuilder<DB, TB, T> : KyselyTypeError<`$assertType() call failed: The type passed in is not equal to the output type of the query.`>;
-    /**
-     * @deprecated Use `$assertType` instead.
-     */
-    assertType<T extends O>(): O extends T ? InsertQueryBuilder<DB, TB, T> : KyselyTypeError<`assertType() call failed: The type passed in is not equal to the output type of the query.`>;
     /**
      * Returns a copy of this InsertQueryBuilder instance with the given plugin installed.
      */