kysely 0.23.3 → 0.23.5

package/dist/cjs/operation-node/aggregate-function-node.d.ts

@@ -1,12 +1,13 @@
 import { OperationNode } from './operation-node.js';
 import { OverNode } from './over-node.js';
+import { SelectAllNode } from './select-all-node.js';
 import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
 import { WhereNode } from './where-node.js';
 declare type AggregateFunction = 'avg' | 'count' | 'max' | 'min' | 'sum';
 export interface AggregateFunctionNode extends OperationNode {
     readonly kind: 'AggregateFunctionNode';
     readonly func: AggregateFunction;
-    readonly column: SimpleReferenceExpressionNode;
+    readonly aggregated: SimpleReferenceExpressionNode | SelectAllNode;
     readonly distinct?: boolean;
     readonly filter?: WhereNode;
     readonly over?: OverNode;
@@ -16,7 +17,7 @@ export interface AggregateFunctionNode extends OperationNode {
  */
 export declare const AggregateFunctionNode: Readonly<{
     is(node: OperationNode): node is AggregateFunctionNode;
-    create(aggregateFunction: AggregateFunction, column: SimpleReferenceExpressionNode): AggregateFunctionNode;
+    create(aggregateFunction: AggregateFunction, aggregated: SimpleReferenceExpressionNode | SelectAllNode): AggregateFunctionNode;
     cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
     cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;

package/dist/cjs/operation-node/aggregate-function-node.js

@@ -10,11 +10,11 @@ exports.AggregateFunctionNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'AggregateFunctionNode';
     },
-    create(aggregateFunction, column) {
+    create(aggregateFunction, aggregated) {
         return (0, object_utils_js_1.freeze)({
             kind: 'AggregateFunctionNode',
             func: aggregateFunction,
-            column,
+            aggregated,
         });
     },
     cloneWithDistinct(aggregateFunctionNode) {

package/dist/cjs/operation-node/create-index-node.d.ts

@@ -11,6 +11,7 @@ export interface CreateIndexNode extends OperationNode {
     readonly expression?: OperationNode;
     readonly unique?: boolean;
     readonly using?: RawNode;
+    readonly ifNotExists?: boolean;
 }
 /**
  * @internal

package/dist/cjs/operation-node/delete-query-node.d.ts

@@ -8,9 +8,11 @@ import { LimitNode } from './limit-node.js';
 import { OrderByNode } from './order-by-node.js';
 import { OrderByItemNode } from './order-by-item-node.js';
 import { ExplainNode } from './explain-node.js';
+import { UsingNode } from './using-node.js';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
+    readonly using?: UsingNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
     readonly returning?: ReturningNode;
@@ -24,8 +26,9 @@ export interface DeleteQueryNode extends OperationNode {
  */
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
-    create(fromItem: OperationNode, withNode?: WithNode): DeleteQueryNode;
+    create(fromItems: OperationNode[], withNode?: WithNode): DeleteQueryNode;
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
     cloneWithExplain(deleteNode: DeleteQueryNode, explain: ExplainNode): DeleteQueryNode;
+    cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;
 }>;

package/dist/cjs/operation-node/delete-query-node.js

@@ -4,6 +4,7 @@ exports.DeleteQueryNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 const from_node_js_1 = require("./from-node.js");
 const order_by_node_js_1 = require("./order-by-node.js");
+const using_node_js_1 = require("./using-node.js");
 /**
  * @internal
  */
@@ -11,10 +12,10 @@ exports.DeleteQueryNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'DeleteQueryNode';
     },
-    create(fromItem, withNode) {
+    create(fromItems, withNode) {
         return (0, object_utils_js_1.freeze)({
             kind: 'DeleteQueryNode',
-            from: from_node_js_1.FromNode.create([fromItem]),
+            from: from_node_js_1.FromNode.create(fromItems),
             ...(withNode && { with: withNode }),
         });
     },
@@ -38,4 +39,12 @@ exports.DeleteQueryNode = (0, object_utils_js_1.freeze)({
             explain,
         });
     },
+    cloneWithUsing(deleteNode, tables) {
+        return (0, object_utils_js_1.freeze)({
+            ...deleteNode,
+            using: deleteNode.using !== undefined
+                ? using_node_js_1.UsingNode.cloneWithTables(deleteNode.using, tables)
+                : using_node_js_1.UsingNode.create(tables),
+        });
+    },
 });

package/dist/cjs/operation-node/operation-node-transformer.d.ts

@@ -76,6 +76,7 @@ import { PartitionByItemNode } from './partition-by-item-node.js';
 import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
+import { UsingNode } from './using-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -181,6 +182,7 @@ export declare class OperationNodeTransformer {
     protected transformPartitionByItem(node: PartitionByItemNode): PartitionByItemNode;
     protected transformBinaryOperation(node: BinaryOperationNode): BinaryOperationNode;
     protected transformUnaryOperation(node: UnaryOperationNode): UnaryOperationNode;
+    protected transformUsing(node: UsingNode): UsingNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -112,6 +112,7 @@ class OperationNodeTransformer {
         SetOperationNode: this.transformSetOperation.bind(this),
         BinaryOperationNode: this.transformBinaryOperation.bind(this),
         UnaryOperationNode: this.transformUnaryOperation.bind(this),
+        UsingNode: this.transformUsing.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -261,6 +262,7 @@ class OperationNodeTransformer {
         return (0, require_all_props_js_1.requireAllProps)({
             kind: 'DeleteQueryNode',
             from: this.transformNode(node.from),
+            using: this.transformNode(node.using),
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             returning: this.transformNode(node.returning),
@@ -404,6 +406,7 @@ class OperationNodeTransformer {
             expression: this.transformNode(node.expression),
             unique: node.unique,
             using: this.transformNode(node.using),
+            ifNotExists: node.ifNotExists,
         });
     }
     transformList(node) {
@@ -648,7 +651,7 @@ class OperationNodeTransformer {
     transformAggregateFunction(node) {
         return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AggregateFunctionNode',
-            column: this.transformNode(node.column),
+            aggregated: this.transformNode(node.aggregated),
             distinct: node.distinct,
             filter: this.transformNode(node.filter),
             func: node.func,
@@ -689,6 +692,12 @@ class OperationNodeTransformer {
             operand: this.transformNode(node.operand),
         });
     }
+    transformUsing(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'UsingNode',
+            tables: this.transformNodeList(node.tables),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/cjs/operation-node/operation-node-visitor.d.ts

@@ -76,6 +76,7 @@ import { PartitionByItemNode } from './partition-by-item-node.js';
 import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
+import { UsingNode } from './using-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -158,4 +159,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitSetOperation(node: SetOperationNode): void;
     protected abstract visitBinaryOperation(node: BinaryOperationNode): void;
     protected abstract visitUnaryOperation(node: UnaryOperationNode): void;
+    protected abstract visitUsing(node: UsingNode): void;
 }

package/dist/cjs/operation-node/operation-node-visitor.js

@@ -85,6 +85,7 @@ class OperationNodeVisitor {
         SetOperationNode: this.visitSetOperation.bind(this),
         BinaryOperationNode: this.visitBinaryOperation.bind(this),
         UnaryOperationNode: this.visitUnaryOperation.bind(this),
+        UsingNode: this.visitUsing.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/cjs/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/cjs/operation-node/operator-node.d.ts

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "&&", "||", "@@", "@@@", "!!", "<->"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "&&", "||", "@@", "@@@", "!!", "<->"];
 export declare const UNARY_FILTER_OPERATORS: readonly ["exists", "not exists"];
 export declare type ComparisonOperator = typeof COMPARISON_OPERATORS[number];
 export declare type UnaryFilterOperator = typeof UNARY_FILTER_OPERATORS[number];

package/dist/cjs/operation-node/operator-node.js

@@ -17,6 +17,7 @@ exports.COMPARISON_OPERATORS = [
     'is not',
     'like',
     'not like',
+    'match',
     'ilike',
     'not ilike',
     '@>',

package/dist/cjs/operation-node/using-node.d.ts

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+export interface UsingNode extends OperationNode {
+    readonly kind: 'UsingNode';
+    readonly tables: ReadonlyArray<OperationNode>;
+}
+/**
+ * @internal
+ */
+export declare const UsingNode: Readonly<{
+    is(node: OperationNode): node is UsingNode;
+    create(tables: ReadonlyArray<OperationNode>): UsingNode;
+    cloneWithTables(using: UsingNode, tables: ReadonlyArray<OperationNode>): UsingNode;
+}>;

package/dist/cjs/operation-node/using-node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsingNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.UsingNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'UsingNode';
+    },
+    create(tables) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'UsingNode',
+            tables: (0, object_utils_js_1.freeze)(tables),
+        });
+    },
+    cloneWithTables(using, tables) {
+        return (0, object_utils_js_1.freeze)({
+            ...using,
+            tables: (0, object_utils_js_1.freeze)([...using.tables, ...tables]),
+        });
+    },
+});

package/dist/cjs/parser/expression-parser.js

@@ -26,6 +26,6 @@ function parseAliasedExpression(exp) {
 }
 exports.parseAliasedExpression = parseAliasedExpression;
 function isExpressionOrFactory(obj) {
-    return (0, expression_js_1.isExpression)(obj) || (0, object_utils_js_1.isFunction)(obj);
+    return (0, expression_js_1.isExpression)(obj) || (0, expression_js_1.isAliasedExpression)(obj) || (0, object_utils_js_1.isFunction)(obj);
 }
 exports.isExpressionOrFactory = isExpressionOrFactory;

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

@@ -6,6 +6,7 @@ import { AliasedExpression } from '../expression/expression.js';
 export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedExpressionOrFactory<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpression<any, any>;
+export declare type TableReferenceOrList<DB> = TableReference<DB> | ReadonlyArray<TableReference<DB>>;
 export declare type From<DB, TE> = {
     [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };

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

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

package/dist/cjs/plugin/camel-case/camel-case-plugin.d.ts

@@ -26,6 +26,12 @@ export interface CamelCasePluginOptions {
      * Defaults to false.
      */
     underscoreBetweenUppercaseLetters?: boolean;
+    /**
+     * If true, nested object's keys will not be converted to camel case.
+     *
+     * Defaults to false.
+     */
+    maintainNestedObjectKeys?: boolean;
 }
 /**
  * A plugin that converts snake_case identifiers in the database into
@@ -93,6 +99,7 @@ export interface CamelCasePluginOptions {
  */
 export declare class CamelCasePlugin implements KyselyPlugin {
     #private;
+    readonly opt: CamelCasePluginOptions;
     constructor(opt?: CamelCasePluginOptions);
     /**
      * This is called for each query before it is executed. You can modify the query by

package/dist/cjs/plugin/camel-case/camel-case-plugin.js

@@ -69,10 +69,12 @@ const camel_case_js_1 = require("./camel-case.js");
  * ```
  */
 class CamelCasePlugin {
+    opt;
     #camelCase;
     #snakeCase;
     #snakeCaseTransformer;
     constructor(opt = {}) {
+        this.opt = opt;
         this.#camelCase = (0, camel_case_js_1.createCamelCaseMapper)(opt);
         this.#snakeCase = (0, camel_case_js_1.createSnakeCaseMapper)(opt);
         this.#snakeCaseTransformer = new camel_case_transformer_js_1.SnakeCaseTransformer(this.snakeCase.bind(this));
@@ -93,9 +95,9 @@ class CamelCasePlugin {
         return Object.keys(row).reduce((obj, key) => {
             let value = row[key];
             if (Array.isArray(value)) {
-                value = value.map((it) => (canMap(it) ? this.mapRow(it) : it));
+                value = value.map((it) => (canMap(it, this.opt) ? this.mapRow(it) : it));
             }
-            else if (canMap(value)) {
+            else if (canMap(value, this.opt)) {
                 value = this.mapRow(value);
             }
             obj[this.camelCase(key)] = value;
@@ -110,6 +112,10 @@ class CamelCasePlugin {
     }
 }
 exports.CamelCasePlugin = CamelCasePlugin;
-function canMap(obj) {
-    return ((0, object_utils_js_1.isObject)(obj) && !(0, object_utils_js_1.isDate)(obj) && !(0, object_utils_js_1.isBuffer)(obj) && !(0, object_utils_js_1.isArrayBufferOrView)(obj));
+function canMap(obj, opt) {
+    return ((0, object_utils_js_1.isObject)(obj) &&
+        !(0, object_utils_js_1.isDate)(obj) &&
+        !(0, object_utils_js_1.isBuffer)(obj) &&
+        !(0, object_utils_js_1.isArrayBufferOrView)(obj) &&
+        !opt?.maintainNestedObjectKeys);
 }

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

@@ -1,11 +1,11 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
-import { TableExpression } from '../parser/table-parser.js';
+import { From, FromTables, TableExpression } from '../parser/table-parser.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
+import { MergePartial, Nullable, SimplifyResult, SimplifySingleResult } from '../util/type-utils.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
@@ -428,6 +428,82 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     clearWhere(): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Adds a `using` clause to the query.
+     *
+     * This clause allows adding additional tables to the query for filtering/returning
+     * only. Usually a non-standard syntactic-sugar alternative to a `where` with a sub-query.
+     *
+     * ### Examples:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('pet')
+     *   .using('person')
+     *   .whereRef('pet.owner_id', '=', 'person.id')
+     *   .where('person.first_name', '=', 'Bob')
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet"
+     * using "person"
+     * where "pet"."owner_id" = "person"."id"
+     *   and "person"."first_name" = $1
+     * ```
+     *
+     * On supported databases such as MySQL, this clause allows using joins, but requires
+     * at least one of the tables after the `from` keyword to be also named after
+     * the `using` keyword. See also {@link innerJoin}, {@link leftJoin}, {@link rightJoin}
+     * and {@link fullJoin}.
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('pet')
+     *   .using('pet')
+     *   .leftJoin('person', 'person.id', 'pet.owner_id')
+     *   .where('person.first_name', '=', 'Bob')
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * delete from `pet`
+     * using `pet`
+     * left join `person` on `person`.`id` = `pet`.`owner_id`
+     * where `person`.`first_name` = ?
+     * ```
+     *
+     * You can also chain multiple invocations of this method, or pass an array to
+     * a single invocation to name multiple tables.
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('toy')
+     *   .using(['pet', 'person'])
+     *   .whereRef('toy.pet_id', '=', 'pet.id')
+     *   .whereRef('pet.owner_id', '=', 'person.id')
+     *   .where('person.first_name', '=', 'Bob')
+     *   .returning('pet.name')
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * delete from "toy"
+     * using "pet", "person"
+     * where "toy"."pet_id" = "pet"."id"
+     *   and "pet"."owner_id" = "person"."id"
+     *   and "person"."first_name" = $1
+     * returning "pet"."name"
+     * ```
+     */
+    using<TE extends TableExpression<DB, keyof DB>>(tables: TE[]): DeleteQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, O>;
+    using<TE extends TableExpression<DB, keyof DB>>(table: TE): DeleteQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, O>;
     /**
      * Joins another table to the query using an inner join.
      *
@@ -678,7 +754,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * Simply calls the given function passing `this` as the only argument.
      *
      * If you want to conditionally call a method on `this`, see
-     * the {@link if} method.
+     * the {@link $if} method.
      *
      * ### Examples
      *
@@ -691,10 +767,14 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * }
      *
      * db.deleteFrom('person')
-     *   .call(log)
+     *   .$call(log)
      *   .execute()
      * ```
      */
+    $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.
@@ -714,7 +794,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *     .deleteFrom('person')
      *     .where('id', '=', id)
      *     .returning(['id', 'first_name'])
-     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .$if(returnLastName, (qb) => qb.returning('last_name'))
      *     .executeTakeFirstOrThrow()
      * }
      * ```
@@ -731,6 +811,10 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * }
      * ```
      */
+    $if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<DB, TB, O2>): DeleteQueryBuilder<DB, TB, O2 extends DeleteResult ? DeleteResult : O extends DeleteResult ? Partial<O2> : MergePartial<O, O2>>;
+    /**
+     * @deprecated Use `$if` instead
+     */
     if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<DB, TB, O2>): DeleteQueryBuilder<DB, TB, O2 extends DeleteResult ? DeleteResult : O extends DeleteResult ? Partial<O2> : MergePartial<O, O2>>;
     /**
      * Change the output type of the query.
@@ -738,6 +822,10 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * You should only use this method as the last resort if the types
      * don't support your use case.
      */
+    $castTo<T>(): DeleteQueryBuilder<DB, TB, T>;
+    /**
+     * @deprecated Use `$castTo` instead.
+     */
     castTo<T>(): DeleteQueryBuilder<DB, TB, T>;
     /**
      * Asserts that query's output row type equals the given type `T`.
@@ -767,37 +855,41 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *     .deleteFrom('person')
      *     .where('id', '=', person.id)
      *     .returning('first_name')
-     *     .assertType<{ first_name: string }>()
+     *     .$assertType<{ first_name: string }>()
      *   )
      *   .with('deleted_pet', (qb) => qb
      *     .deleteFrom('pet')
      *     .where('owner_id', '=', person.id)
      *     .returning(['name as pet_name', 'species'])
-     *     .assertType<{ pet_name: string, species: Species }>()
+     *     .$assertType<{ pet_name: string, species: Species }>()
      *   )
      *   .selectFrom(['deleted_person', 'deleted_pet'])
      *   .selectAll()
      *   .executeTakeFirstOrThrow()
      * ```
      */
+    $assertType<T extends O>(): O extends T ? DeleteQueryBuilder<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 ? DeleteQueryBuilder<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 DeleteQueryBuilder instance with the given plugin installed.
      */
     withPlugin(plugin: KyselyPlugin): DeleteQueryBuilder<DB, TB, O>;
     toOperationNode(): DeleteQueryNode;
-    compile(): CompiledQuery<O>;
+    compile(): CompiledQuery<SimplifyResult<O>>;
     /**
      * Executes the query and returns an array of rows.
      *
      * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
      */
-    execute(): Promise<O[]>;
+    execute(): Promise<SimplifyResult<O>[]>;
     /**
      * Executes the query and returns the first result or undefined if
      * the query returned no result.
      */
-    executeTakeFirst(): Promise<SingleResultType<O>>;
+    executeTakeFirst(): Promise<SimplifySingleResult<O>>;
     /**
      * Executes the query and returns the first result or throws if
      * the query returned no result.
@@ -806,7 +898,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * provide a custom error class as the only argument to throw a different
      * error.
      */
-    executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<O>;
+    executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<SimplifyResult<O>>;
     /**
      * Executes query with `explain` statement before `delete` keyword.
      *