kysely 0.23.1 → 0.23.3

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

@@ -4,7 +4,7 @@ import { SelectExpression } from '../parser/select-parser.js';
 import { InsertObject } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { MergePartial, SingleResultType } from '../util/type-utils.js';
-import { MutationObject } from '../parser/update-set-parser.js';
+import { UpdateObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
@@ -18,6 +18,7 @@ import { OnConflictBuilder, OnConflictDoNothingBuilder, OnConflictUpdateBuilder
 import { Selectable } from '../util/column-type.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
+import { KyselyTypeError } from '../util/type-error.js';
 export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable {
     #private;
     constructor(props: InsertQueryBuilderProps);
@@ -384,7 +385,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .onDuplicateKeyUpdate({ species: 'hamster' })
      * ```
      */
-    onDuplicateKeyUpdate(updates: MutationObject<DB, TB, TB>): InsertQueryBuilder<DB, TB, O>;
+    onDuplicateKeyUpdate(updates: UpdateObject<DB, TB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Allows you to return data from modified rows.
      *
@@ -459,7 +460,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * ### Examples
      *
-     * The next example uses a helper funtion `log` to log a query:
+     * The next example uses a helper function `log` to log a query:
      *
      * ```ts
      * function log<T extends Compilable>(qb: T): T {
@@ -517,6 +518,48 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * don't support your use case.
      */
     castTo<T>(): InsertQueryBuilder<DB, TB, T>;
+    /**
+     * 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
+     * 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:
+     *
+     * ```
+     * 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
+     * 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.
+     *
+     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
+     * structurally equal to the current type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .with('new_person', (qb) => qb
+     *     .insertInto('person')
+     *     .values(person)
+     *     .returning('id')
+     *     .assertType<{ id: string }>()
+     *   )
+     *   .with('new_pet', (qb) => qb
+     *     .insertInto('pet')
+     *     .values({ owner_id: (eb) => eb.selectFrom('new_person').select('id'), ...pet })
+     *     .returning(['name as pet_name', 'species'])
+     *     .assertType<{ pet_name: string, species: Species }>()
+     *   )
+     *   .selectFrom(['new_person', 'new_pet'])
+     *   .selectAll()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    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.
      */

package/dist/esm/query-builder/insert-query-builder.js

@@ -322,7 +322,7 @@ export class InsertQueryBuilder {
      *
      * ### Examples
      *
-     * The next example uses a helper funtion `log` to log a query:
+     * The next example uses a helper function `log` to log a query:
      *
      * ```ts
      * function log<T extends Compilable>(qb: T): T {
@@ -391,6 +391,50 @@ export class InsertQueryBuilder {
     castTo() {
         return new InsertQueryBuilder(this.#props);
     }
+    /**
+     * 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
+     * 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:
+     *
+     * ```
+     * 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
+     * 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.
+     *
+     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
+     * structurally equal to the current type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .with('new_person', (qb) => qb
+     *     .insertInto('person')
+     *     .values(person)
+     *     .returning('id')
+     *     .assertType<{ id: string }>()
+     *   )
+     *   .with('new_pet', (qb) => qb
+     *     .insertInto('pet')
+     *     .values({ owner_id: (eb) => eb.selectFrom('new_person').select('id'), ...pet })
+     *     .returning(['name as pet_name', 'species'])
+     *     .assertType<{ pet_name: string, species: Species }>()
+     *   )
+     *   .selectFrom(['new_person', 'new_pet'])
+     *   .selectAll()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    assertType() {
+        return new InsertQueryBuilder(this.#props);
+    }
     /**
      * Returns a copy of this InsertQueryBuilder instance with the given plugin installed.
      */

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

@@ -4,7 +4,7 @@ import { OperationNodeSource } from '../operation-node/operation-node-source.js'
 import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { MutationObject } from '../parser/update-set-parser.js';
+import { UpdateObject } from '../parser/update-set-parser.js';
 import { AnyColumn } from '../util/type-utils.js';
 import { WhereInterface } from './where-interface.js';
 export declare class OnConflictBuilder<DB, TB extends keyof DB> implements WhereInterface<DB, TB> {
@@ -339,6 +339,25 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * See {@link WhereInterface.orWhereNotExists} for more info.
      */
     orWhereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictBuilder<DB, TB>;
+    /**
+     * Clears all where clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where('id','=',42)
+     *   .clearWhere()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearWhere(): OnConflictBuilder<DB, TB>;
     /**
      * Adds the "do nothing" conflict action.
      *
@@ -387,7 +406,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * do update set "first_name" = $3
      * ```
      */
-    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
+    doUpdateSet(updates: UpdateObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
 }
 export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;
@@ -703,5 +722,24 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * See {@link WhereInterface.orWhereNotExists} for more info.
      */
     orWhereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictUpdateBuilder<DB, TB>;
+    /**
+     * Clears all where clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where('id','=',42)
+     *   .clearWhere()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearWhere(): OnConflictUpdateBuilder<DB, TB>;
     toOperationNode(): OnConflictNode;
 }

package/dist/esm/query-builder/on-conflict-builder.js

@@ -154,6 +154,12 @@ export class OnConflictBuilder {
             onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseNotExists(arg)),
         });
     }
+    clearWhere() {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithoutIndexWhere(this.#props.onConflictNode),
+        });
+    }
     /**
      * Adds the "do nothing" conflict action.
      *
@@ -312,6 +318,12 @@ export class OnConflictUpdateBuilder {
             onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseNotExists(arg)),
         });
     }
+    clearWhere() {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithoutUpdateWhere(this.#props.onConflictNode),
+        });
+    }
     toOperationNode() {
         return this.#props.onConflictNode;
     }

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

@@ -19,6 +19,7 @@ import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, HavingGrouper, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
 import { ExistsExpression } from '../parser/unary-operation-parser.js';
+import { KyselyTypeError } from '../util/type-error.js';
 export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, HavingInterface<DB, TB>, Expression<O>, Compilable<O>, Explainable {
     #private;
     constructor(props: SelectQueryBuilderProps);
@@ -1291,6 +1292,102 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     exceptAll(expression: Expression<O>): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Clears all select clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name'])
+     *   .clearSelect()
+     *   .select(['id','gender'])
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select "id", "gender" from "person"
+     * ```
+     */
+    clearSelect(): SelectQueryBuilder<DB, TB, {}>;
+    /**
+     * Clears all where clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where('id','=',42)
+     *   .clearWhere()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearWhere(): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Clears limit clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .limit(10)
+     *   .clearLimit()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearLimit(): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Clears offset clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .limit(10)
+     *   .offset(20)
+     *   .clearOffset()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" limit 10
+     * ```
+     */
+    clearOffset(): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Clears all `order by` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .orderBy('id')
+     *   .clearOrderBy()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearOrderBy(): SelectQueryBuilder<DB, TB, O>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
@@ -1299,7 +1396,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *
      * ### Examples
      *
-     * The next example uses a helper funtion `log` to log a query:
+     * The next example uses a helper function `log` to log a query:
      *
      * ```ts
      * function log<T extends Compilable>(qb: T): T {
@@ -1392,6 +1489,46 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * don't support your use case.
      */
     castTo<T>(): SelectQueryBuilder<DB, TB, T>;
+    /**
+     * 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
+     * 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:
+     *
+     * ```
+     * 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
+     * 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.
+     *
+     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
+     * structurally equal to the current type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .with('first_and_last', (qb) => qb
+     *     .selectFrom('person')
+     *     .select(['first_name', 'last_name'])
+     *     .assertType<{ first_name: string, last_name: string }>()
+     *   )
+     *   .with('age', (qb) => qb
+     *     .selectFrom('person')
+     *     .select('age')
+     *     .assertType<{ age: number }>()
+     *   )
+     *   .selectFrom(['first_and_last', 'age'])
+     *   .selectAll()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    assertType<T extends O>(): O extends T ? SelectQueryBuilder<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 SelectQueryBuilder instance with the given plugin installed.
      */

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

@@ -579,6 +579,109 @@ export class SelectQueryBuilder {
             queryNode: SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, parseSetOperation('except', expression, true)),
         });
     }
+    /**
+     * Clears all select clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name'])
+     *   .clearSelect()
+     *   .select(['id','gender'])
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select "id", "gender" from "person"
+     * ```
+     */
+    clearSelect() {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithoutSelections(this.#props.queryNode),
+        });
+    }
+    clearWhere() {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode),
+        });
+    }
+    /**
+     * Clears limit clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .limit(10)
+     *   .clearLimit()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearLimit() {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithoutLimit(this.#props.queryNode),
+        });
+    }
+    /**
+     * Clears offset clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .limit(10)
+     *   .offset(20)
+     *   .clearOffset()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" limit 10
+     * ```
+     */
+    clearOffset() {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithoutOffset(this.#props.queryNode),
+        });
+    }
+    /**
+     * Clears all `order by` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .orderBy('id')
+     *   .clearOrderBy()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearOrderBy() {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithoutOrderBy(this.#props.queryNode),
+        });
+    }
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
@@ -587,7 +690,7 @@ export class SelectQueryBuilder {
      *
      * ### Examples
      *
-     * The next example uses a helper funtion `log` to log a query:
+     * The next example uses a helper function `log` to log a query:
      *
      * ```ts
      * function log<T extends Compilable>(qb: T): T {
@@ -693,6 +796,48 @@ export class SelectQueryBuilder {
     castTo() {
         return new SelectQueryBuilder(this.#props);
     }
+    /**
+     * 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
+     * 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:
+     *
+     * ```
+     * 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
+     * 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.
+     *
+     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
+     * structurally equal to the current type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .with('first_and_last', (qb) => qb
+     *     .selectFrom('person')
+     *     .select(['first_name', 'last_name'])
+     *     .assertType<{ first_name: string, last_name: string }>()
+     *   )
+     *   .with('age', (qb) => qb
+     *     .selectFrom('person')
+     *     .select('age')
+     *     .assertType<{ age: number }>()
+     *   )
+     *   .selectFrom(['first_and_last', 'age'])
+     *   .selectAll()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    assertType() {
+        return new SelectQueryBuilder(this.#props);
+    }
     /**
      * Returns a copy of this SelectQueryBuilder instance with the given plugin installed.
      */

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

@@ -7,7 +7,7 @@ import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
-import { MutationObject } from '../parser/update-set-parser.js';
+import { UpdateObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
@@ -21,6 +21,7 @@ import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
 import { ExistsExpression } from '../parser/unary-operation-parser.js';
+import { KyselyTypeError } from '../util/type-error.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 {
     #private;
     constructor(props: UpdateQueryBuilderProps);
@@ -408,6 +409,25 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * Just like {@link whereExists} but creates an `or not exists` clause.
      */
     orWhereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    /**
+     * Clears all where clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where('id','=',42)
+     *   .clearWhere()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearWhere(): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a from clause to the update query.
      *
@@ -650,7 +670,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * where "id" = $4
      * ```
      */
-    set(row: MutationObject<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
+    set(row: UpdateObject<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Allows you to return data from modified rows.
      *
@@ -725,7 +745,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *
      * ### Examples
      *
-     * The next example uses a helper funtion `log` to log a query:
+     * The next example uses a helper function `log` to log a query:
      *
      * ```ts
      * function log<T extends Compilable>(qb: T): T {
@@ -784,6 +804,50 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * don't support your use case.
      */
     castTo<T>(): UpdateQueryBuilder<DB, UT, TB, T>;
+    /**
+     * 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
+     * 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:
+     *
+     * ```
+     * 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
+     * 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.
+     *
+     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
+     * structurally equal to the current type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .with('updated_person', (qb) => qb
+     *     .updateTable('person')
+     *     .set(person)
+     *     .where('id', '=', person.id)
+     *     .returning('first_name')
+     *     .assertType<{ first_name: string }>()
+     *   )
+     *   .with('updated_pet', (qb) => qb
+     *     .updateTable('pet')
+     *     .set(pet)
+     *     .where('owner_id', '=', person.id)
+     *     .returning(['name as pet_name', 'species'])
+     *     .assertType<{ pet_name: string, species: Species }>()
+     *   )
+     *   .selectFrom(['updated_person', 'updated_pet'])
+     *   .selectAll()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    assertType<T extends O>(): O extends T ? UpdateQueryBuilder<DB, UT, 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 UpdateQueryBuilder instance with the given plugin installed.
      */