kysely 0.13.0 → 0.15.1

package/dist/cjs/parser/insert-values-parser.js

@@ -4,7 +4,6 @@ exports.parseInsertObjectOrList = void 0;
 const column_node_js_1 = require("../operation-node/column-node.js");
 const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
-const generated_placeholder_js_1 = require("../util/generated-placeholder.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const value_parser_js_1 = require("./value-parser.js");
 const values_node_js_1 = require("../operation-node/values-node.js");
@@ -24,7 +23,7 @@ function parseColumnNamesAndIndexes(rows) {
     for (const row of rows) {
         const cols = Object.keys(row);
         for (const col of cols) {
-            if (!columns.has(col) && !(0, generated_placeholder_js_1.isGeneratedPlaceholder)(row[col])) {
+            if (!columns.has(col) && row[col] !== undefined) {
                 columns.set(col, columns.size);
             }
         }
@@ -37,7 +36,7 @@ function parseRowValues(ctx, row, columns) {
     for (const col of rowColumns) {
         const columnIdx = columns.get(col);
         const value = row[col];
-        if (columnIdx !== undefined && !(0, generated_placeholder_js_1.isGeneratedPlaceholder)(value)) {
+        if (columnIdx !== undefined) {
             rowValues[columnIdx] = value;
         }
     }

package/dist/cjs/parser/reference-parser.d.ts

@@ -3,17 +3,18 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { PrimitiveValue } from '../util/object-utils.js';
-import { AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
+import { AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ParseContext } from './parse-context.js';
 import { ComplexExpression } from './complex-expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { SelectType } from '../util/column-type.js';
 export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any> | ComplexExpression<DB, TB>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
-export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
-declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, R = RowType<DB, TB>> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends keyof R ? R[RE] : PrimitiveValue;
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
+declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : PrimitiveValue;
 export declare function parseReferenceExpressionOrList(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(ctx: ParseContext, exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
 export declare function parseStringReference(ref: string): ColumnNode | ReferenceNode;

package/dist/cjs/parser/select-parser.d.ts

@@ -1,10 +1,11 @@
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { AliasedQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
+import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { ParseContext } from './parse-context.js';
 import { AliasedComplexExpression } from './complex-expression-parser.js';
+import { Selectable, SelectType } from '../util/column-type.js';
 export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedComplexExpression<DB, TB>;
 export declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpression<DB, TB> | ReadonlyArray<SelectExpression<DB, TB>>;
 /**
@@ -15,14 +16,19 @@ export declare type QueryBuilderWithSelection<DB, TB extends keyof DB, O, SE> =
 /**
  * `selectAll` output query builder type.
  */
-export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends keyof DB> = SelectQueryBuilder<DB, TB, O & RowType<DB, S>>;
+export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends keyof DB> = SelectQueryBuilder<DB, TB, O & AllSelection<DB, S>>;
 export declare type Selection<DB, TB extends keyof DB, SE> = {
-    [A in ExtractAliasFromSelectExpression<SE>]: ExtractTypeFromSelectExpression<DB, TB, SE, A>;
+    [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
 };
 declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedRawBuilder<any, infer RA> ? RA : SE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : SE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
 declare type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
 declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
-declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any, R = RowType<DB, TB>> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends keyof R ? R[C] : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends keyof R ? R[SE] : never : never;
+declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never : never;
+declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
+    [C in AnyColumn<DB, TB>]: {
+        [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
+    }[TB];
+}>;
 export declare function parseSelectExpressionOrList(ctx: ParseContext, selection: SelectExpressionOrList<any, any>): SelectionNode[];
 export declare function parseSelectAll(table?: string | string[]): SelectionNode[];
 export {};

package/dist/cjs/parser/update-set-parser.d.ts

@@ -1,7 +1,8 @@
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
+import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ParseContext } from './parse-context.js';
 import { ValueExpression } from './value-parser.js';
 export declare type MutationObject<DB, TB extends keyof DB> = {
-    [C in keyof DB[TB]]?: ValueExpression<DB, TB, DB[TB][C]>;
+    [C in UpdateKeys<DB[TB]>]?: ValueExpression<DB, TB, UpdateType<DB[TB][C]>>;
 };
 export declare function parseUpdateObject(ctx: ParseContext, row: MutationObject<any, any>): ReadonlyArray<ColumnUpdateNode>;

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

@@ -17,6 +17,7 @@ import { JoinInterface } from './join-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
+import { Selectable } from '../util/column-type.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);
@@ -539,7 +540,6 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * const { id } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -553,7 +553,6 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * const { id, first_name } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -569,7 +568,6 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -587,7 +585,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
      */
-    returningAll(): DeleteQueryBuilder<DB, TB, DB[TB]>;
+    returningAll(): DeleteQueryBuilder<DB, TB, Selectable<DB[TB]>>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *

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

@@ -3,18 +3,19 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 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 { AnyColumn, SingleResultType } from '../util/type-utils.js';
+import { SingleResultType } from '../util/type-utils.js';
 import { MutationObject } 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';
-import { OnConflictConstraintTarget } from '../parser/on-conflict-parser.js';
 import { ParseContext } from '../parser/parse-context.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { ComplexExpression } from '../parser/complex-expression-parser.js';
 import { ReturningInterface } from './returning-interface.js';
+import { OnConflictBuilder, OnConflictDoNothingBuilder, OnConflictUpdateBuilder } from './on-conflict-builder.js';
+import { Selectable } from '../util/column-type.js';
 export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
     #private;
     constructor(props: InsertQueryBuilderProps);
@@ -23,13 +24,10 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * This method takes an object whose keys are column names and values are
      * values to insert. In addition to the column's type, the values can be
-     * {@link Kysely.raw | raw} instances, select queries or the
-     * {@link Kysely.generated | generated} placeholder.
+     * {@link Kysely.raw | raw} instances or select queries.
      *
-     * You must provide all values defined by the interface of the table you
-     * are inserting into. Values that are generated by the database like auto incrementing
-     * identifiers can be marked with the {@link Kysely.generated} placeholder unless you
-     * want to insert a specific value instead of the generated default.
+     * You must provide all fields you haven't explicitly marked as nullable
+     * or optional using {@link Generated} or {@link ColumnType}.
      *
      * The return value of an `insert` query is an instance of {@link InsertResult}. The
      * {@link InsertResult.insertId | insertId} field holds the auto incremented primary
@@ -48,7 +46,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const id = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -70,11 +67,9 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * await db
      *   .insertInto('person')
      *   .values([{
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   }, {
-     *     id: db.generated,
      *     first_name: 'Arnold',
      *     last_name: 'Schwarzenegger',
      *   }])
@@ -95,7 +90,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const row = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -118,7 +112,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const result = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: db.raw('? || ?', ['Ani', 'ston']),
      *     age: db.selectFrom('person').select(raw('avg(age)')),
@@ -144,7 +137,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .select(['id', 'first_name', 'gender'])
      *   .limit(1)
      * ).insertInto('pet').values({
-     *   id: db.generated,
      *   owner_id: (eb) => eb.selectFrom('jennifer').select('id'),
      *   name: (eb) => eb.selectFrom('jennifer').select('first_name'),
      *   species: 'cat',
@@ -196,21 +188,32 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      */
     expression(expression: ComplexExpression<DB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**
-     * Ignores the insert if the column or constraint given as the first
-     * argument conflicts with the current rows in the database. The
-     * default behavior without this method call is to throw an error.
+     * Changes an `insert into` query to an `insert ignore into` query.
      *
-     * For example if a table has a field `name` that has a unique constraint
-     * and you try to insert a row with a `name` that already exists in the
-     * database, calling `onConflictDoNothing('name')` will ignore the conflict
-     * and do nothing. By default the query would throw.
+     * If you use the ignore modifier, ignorable errors that occur while executing the
+     * insert statement are ignored. For example, without ignore, a row that duplicates
+     * an existing unique index or primary key value in the table causes a duplicate-key
+     * error and the statement is aborted. With ignore, the row is discarded and no error
+     * occurs.
      *
-     * Only some dialects like PostgreSQL and SQLite implement the `on conflict`
-     * statement. On MySQL you should use the {@link ignore} method to achieve
-     * similar results.
+     * This is only supported on some dialects like MySQL. On most dialects you should
+     * use the {@link onConflict} method.
      *
-     * Also see the {@link onConflictUpdate} method if you want to perform an
-     * update in case of a conflict (upsert).
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .ignore()
+     *   .values(values)
+     *   .execute()
+     * ```
+     */
+    ignore(): InsertQueryBuilder<DB, TB, O>;
+    /**
+     * Adds an `on conflict` clause to the query.
+     *
+     * `on conflict` is only supported by some dialects like PostgreSQL and SQLite. On MySQL
+     * you can use {@link ignore} and {@link onDuplicateKeyUpdate} to achieve similar results.
      *
      * ### Examples
      *
@@ -218,11 +221,13 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * await db
      *   .insertInto('pet')
      *   .values({
-     *     id: db.generated,
      *     name: 'Catto',
      *     species: 'cat',
      *   })
-     *   .onConflictDoNothing('name')
+     *   .onConflict((oc) => oc
+     *     .column('name')
+     *     .doUpdateSet({ species: 'hamster' })
+     *   )
      *   .execute()
      * ```
      *
@@ -231,22 +236,24 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * ```sql
      * insert into "pet" ("name", "species")
      * values ($1, $2)
-     * on conflict ("name") do nothing
+     * on conflict ("name")
+     * do update set "species" = $3
      * ```
      *
-     * You can provide the name of the constraint instead of a column name
+     * You can provide the name of the constraint instead of a column name:
      *
      * ```ts
      * await db
      *   .insertInto('pet')
      *   .values({
-     *     id: db.generated,
      *     name: 'Catto',
      *     species: 'cat',
      *   })
-     *   .onConflictDoNothing({
-     *     constraint: 'pet_name_key'
-     *   })
+     *   .onConflict((oc) => oc
+     *     .constraint('pet_name_key')
+     *     .doUpdateSet({ species: 'hamster' })
+     *   )
+     *   .execute()
      *   .execute()
      * ```
      *
@@ -256,66 +263,49 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * insert into "pet" ("name", "species")
      * values ($1, $2)
      * on conflict on constraint "pet_name_key"
-     * do nothing
+     * do update set "species" = $3
      * ```
-     */
-    onConflictDoNothing(column: AnyColumn<DB, TB>): InsertQueryBuilder<DB, TB, O>;
-    onConflictDoNothing(columns: ReadonlyArray<AnyColumn<DB, TB>>): InsertQueryBuilder<DB, TB, O>;
-    onConflictDoNothing(constraint: OnConflictConstraintTarget): InsertQueryBuilder<DB, TB, O>;
-    /**
-     * Changes an `insert into` query to an `insert ignore into` query.
      *
-     * If you use the ignore modifier, ignorable errors that occur while executing the
-     * insert statement are ignored. For example, without ignore, a row that duplicates
-     * an existing unique index or primary key value in the table causes a duplicate-key
-     * error and the statement is aborted. With ignore, the row is discarded and no error
-     * occurs.
-     *
-     * This is only supported on some dialects like MySQL. On most dialects you should
-     * use the {@link onConflictDoNothing} method.
-     *
-     * ### Examples
+     * You can also specify an expression as the conflict target in case
+     * the unique index is an expression index:
      *
      * ```ts
-     * await db.insertInto('person')
-     *   .ignore()
-     *   .values(values)
+     * await db
+     *   .insertInto('pet')
+     *   .values({
+     *     name: 'Catto',
+     *     species: 'cat',
+     *   })
+     *   .onConflict((oc) => oc
+     *     .expression(db.raw('lower(name)'))
+     *     .doUpdateSet({ species: 'hamster' })
+     *   )
      *   .execute()
      * ```
-     */
-    ignore(): InsertQueryBuilder<DB, TB, O>;
-    /**
-     * Ignores an insert if the column or constraint given as the first
-     * argument conflicts with the current rows in the database and
-     * performs an update on the conflicting row instead. This method
-     * can be used to implement an upsert operation.
-     *
-     * For example if a table has a field `name` that has a unique constraint
-     * and you try to insert a row with a `name` that already exists in the
-     * database, calling `onConfictUpdate('name', { species: 'hamster' })`
-     * will set the conflicting row's `species` field to value `'hamster'`.
-     * By default the query would throw.
-     *
-     * The second argument (updates) can be anything the {@link UpdateQueryBuilder.set | set}
-     * method accepts.
      *
-     * The `on conflict do update` statement is only implemented by some dialects
-     * like PostgreSQL and SQLite. On MySQL you should use the {@link onDuplicateKeyUpdate}
-     * method instead.
+     * The generated SQL (PostgreSQL):
      *
-     * Also see the {@link onConflictDoNothing} method.
+     * ```sql
+     * insert into "pet" ("name", "species")
+     * values ($1, $2)
+     * on conflict (lower(name))
+     * do update set "species" = $3
+     * ```
      *
-     * ### Examples
+     * You can add a filter for the update statement like this:
      *
      * ```ts
      * await db
      *   .insertInto('pet')
      *   .values({
-     *     id: db.generated,
      *     name: 'Catto',
      *     species: 'cat',
      *   })
-     *   .onConflictUpdate('name', { species: 'hamster' })
+     *   .onConflict((oc) => oc
+     *     .column('name')
+     *     .doUpdateSet({ species: 'hamster' })
+     *     .where('excluded.name', '!=', 'Catto'')
+     *   )
      *   .execute()
      * ```
      *
@@ -324,22 +314,23 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * ```sql
      * insert into "pet" ("name", "species")
      * values ($1, $2)
-     * on conflict ("name") do update set "species" = $3
+     * on conflict ("name")
+     * do update set "species" = $3
+     * where "excluded"."name" != $4
      * ```
      *
-     * You can provied the name of the constraint instead of a column name
+     * You can create an `on conflict do nothing` clauses like this:
      *
      * ```ts
      * await db
      *   .insertInto('pet')
      *   .values({
-     *     id: db.generated,
      *     name: 'Catto',
      *     species: 'cat',
      *   })
-     *   .onConflictUpdate(
-     *     { constraint: 'pet_name_key' },
-     *     { species: 'hamster' }
+     *   .onConflict((oc) => oc
+     *     .column('name')
+     *     .doNothing()
      *   )
      *   .execute()
      * ```
@@ -349,13 +340,10 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * ```sql
      * insert into "pet" ("name", "species")
      * values ($1, $2)
-     * on conflict on constraint "pet_name_key"
-     * do update set "species" = $3
+     * on conflict ("name") do nothing
      * ```
      */
-    onConflictUpdate(column: AnyColumn<DB, TB>, updates: MutationObject<DB, TB>): InsertQueryBuilder<DB, TB, O>;
-    onConflictUpdate(columns: ReadonlyArray<AnyColumn<DB, TB>>, updates: MutationObject<DB, TB>): InsertQueryBuilder<DB, TB, O>;
-    onConflictUpdate(constraint: OnConflictConstraintTarget, updates: MutationObject<DB, TB>): InsertQueryBuilder<DB, TB, O>;
+    onConflict(callback: (builder: OnConflictBuilder<DB, TB>) => OnConflictDoNothingBuilder<DB, TB> | OnConflictUpdateBuilder<DB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Adds `on duplicate key update` to the query.
      *
@@ -363,7 +351,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * a duplicate value in a unique index or primary key, an update of the old row occurs.
      *
      * This is only implemented by some dialects like MySQL. On most dialects you should
-     * use {@link onConflictUpdate} instead.
+     * use {@link onConflict} instead.
      *
      * ### Examples
      *
@@ -395,7 +383,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const { id } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -409,7 +396,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const { id, first_name } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -425,7 +411,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -443,7 +428,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
      */
-    returningAll(): InsertQueryBuilder<DB, TB, DB[TB]>;
+    returningAll(): InsertQueryBuilder<DB, TB, Selectable<DB[TB]>>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
@@ -456,9 +441,9 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .selectAll()
      *   .call((qb) => {
      *     if (something) {
-     *       return qb.onConflictDoNothing('something')
+     *       return qb.onConflict((oc) => oc.column('something').doNothing())
      *     } else {
-     *       return qb.onConflictDoNothing('something_else')
+     *       return qb.onConflict((oc) => oc.column('something_else').doNothing())
      *     }
      *   })
      *   .execute()