kysely 0.19.2 → 0.19.5

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

@@ -2,12 +2,12 @@ import { AliasNode } from '../operation-node/alias-node.js';
 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, TableExpressionDatabase, TableExpressionTables, LeftJoinTableExpressionDatabase, RightJoinTableExpressionDatabase, FullJoinTableExpressionDatabase } from '../parser/table-parser.js';
+import { TableExpression } from '../parser/table-parser.js';
 import { SelectExpression, QueryBuilderWithSelection, SelectAllQueryBuilder } from '../parser/select-parser.js';
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper, HavingGrouper } from '../parser/filter-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
 import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
@@ -15,10 +15,10 @@ import { QueryId } from '../util/query-id.js';
 import { UnionExpression } from '../parser/union-parser.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
-import { JoinInterface } from './join-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { HavingInterface } from './having-interface.js';
-export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, HavingInterface<DB, TB>, JoinInterface<DB, TB>, OperationNodeSource, Compilable {
+import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
+export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, HavingInterface<DB, TB>, OperationNodeSource, Compilable {
     #private;
     constructor(props: SelectQueryBuilderProps);
     /**
@@ -856,23 +856,33 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * on "doggos"."owner_id" = "person"."id"
      * ```
      */
-    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
+    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
     /**
-     * Just like {@link innerJoin} but adds a left join nstead of an inner join.
+     * Just like {@link innerJoin} but adds a left join instead of an inner join.
      */
-    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
+    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
     /**
      * Just like {@link innerJoin} but adds a right join instead of an inner join.
      */
-    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithRightJoin<DB, TB, O, TE>;
+    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithRightJoin<DB, TB, O, TE>;
     /**
      * Just like {@link innerJoin} but adds a full join instead of an inner join.
      */
-    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>;
+    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>;
+    /**
+     * Just like {@link innerJoin} but adds a lateral join instead of an inner join.
+     */
+    innerJoinLateral<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
+    innerJoinLateral<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
+    /**
+     * Just like {@link innerJoin} but adds a lateral left join instead of an inner join.
+     */
+    leftJoinLateral<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
+    leftJoinLateral<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
     /**
      * Adds an `order by` clause to the query.
      *
@@ -1282,3 +1292,24 @@ export declare class AliasedQueryBuilder<DB, TB extends keyof DB, O = undefined,
     protected get alias(): A;
     toOperationNode(): AliasNode;
 }
+export declare type SelectQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? SelectQueryBuilder<DB, TB | TE, O> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, TB, O, RA, RO> : never;
+declare type InnerJoinedBuilder<DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? SelectQueryBuilder<InnerJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & Record<A, R>, TB | A, O>;
+declare type InnerJoinedDB<DB, A extends string, R> = {
+    [C in keyof DB | A]: C extends A ? R : C extends keyof DB ? DB[C] : never;
+};
+export declare type SelectQueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, TB, O, RA, RO> : never;
+declare type LeftJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? SelectQueryBuilder<LeftJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & Record<A, Nullable<R>>, TB | A, O>;
+declare type LeftJoinedDB<DB, A extends keyof any, R> = {
+    [C in keyof DB | A]: C extends A ? Nullable<R> : C extends keyof DB ? DB[C] : never;
+};
+export declare type SelectQueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, TB, O, RA, RO> : never;
+declare type RightJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<RightJoinedDB<DB, TB, A, R>, TB | A, O>;
+declare type RightJoinedDB<DB, TB extends keyof DB, A extends keyof any, R> = {
+    [C in keyof DB | A]: C extends A ? R : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
+};
+export declare type SelectQueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, TB, O, RA, RO> : never;
+declare type OuterJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<OuterJoinedBuilderDB<DB, TB, A, R>, TB | A, O>;
+declare type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = {
+    [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
+};
+export {};

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

@@ -237,6 +237,18 @@ class SelectQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('FullJoin', args)),
         });
     }
+    innerJoinLateral(...args) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('LateralInnerJoin', args)),
+        });
+    }
+    leftJoinLateral(...args) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('LateralLeftJoin', args)),
+        });
+    }
     /**
      * Adds an `order by` clause to the query.
      *

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

@@ -1,12 +1,12 @@
 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, TableExpressionDatabase, TableExpressionTables, LeftJoinTableExpressionDatabase, RightJoinTableExpressionDatabase, FullJoinTableExpressionDatabase } from '../parser/table-parser.js';
+import { TableExpression, From, FromTables } from '../parser/table-parser.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, 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 { Compilable } from '../util/compilable.js';
@@ -15,11 +15,12 @@ import { QueryId } from '../util/query-id.js';
 import { UpdateResult } from './update-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
-import { JoinInterface } from './join-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { Selectable } from '../util/column-type.js';
-export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
+import { AliasedQueryBuilder } from './select-query-builder.js';
+import { AliasedRawBuilder } from '../raw-builder/raw-builder.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 {
     #private;
     constructor(props: UpdateQueryBuilderProps);
     /**
@@ -433,8 +434,8 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * where "pet"."owner_id" = "person"."id"
      * ```
      */
-    from<TE extends TableExpression<DB, TB>>(table: TE): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    from<TE extends TableExpression<DB, TB>>(table: TE[]): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    from<TE extends TableExpression<DB, TB>>(table: TE): UpdateQueryBuilder<From<DB, TE>, UT, FromTables<DB, TB, TE>, O>;
+    from<TE extends TableExpression<DB, TB>>(table: TE[]): UpdateQueryBuilder<From<DB, TE>, UT, FromTables<DB, TB, TE>, O>;
     /**
      * Joins another table to the query using an inner join.
      *
@@ -544,23 +545,23 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * on "doggos"."owner_id" = "person"."id"
      * ```
      */
-    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilderWithInnerJoin<DB, UT, TB, O, TE>;
+    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilderWithInnerJoin<DB, UT, TB, O, TE>;
     /**
-     * Just like {@link innerJoin} but adds a left join nstead of an inner join.
+     * Just like {@link innerJoin} but adds a left join instead of an inner join.
      */
-    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilderWithLeftJoin<DB, UT, TB, O, TE>;
+    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilderWithLeftJoin<DB, UT, TB, O, TE>;
     /**
      * Just like {@link innerJoin} but adds a right join instead of an inner join.
      */
-    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilderWithRightJoin<DB, UT, TB, O, TE>;
+    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilderWithRightJoin<DB, UT, TB, O, TE>;
     /**
      * Just like {@link innerJoin} but adds a full join instead of an inner join.
      */
-    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilderWithFullJoin<DB, UT, TB, O, TE>;
+    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilderWithFullJoin<DB, UT, TB, O, TE>;
     /**
      * Sets the values to update for an {@link Kysely.updateTable | update} query.
      *
@@ -814,3 +815,24 @@ export interface UpdateQueryBuilderProps {
     readonly queryNode: UpdateQueryNode;
     readonly executor: QueryExecutor;
 }
+export declare type UpdateQueryBuilderWithInnerJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? UpdateQueryBuilder<DB, UT, TB | TE, O> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+declare type InnerJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? UpdateQueryBuilder<InnerJoinedDB<DB, A, R>, UT, TB | A, O> : UpdateQueryBuilder<DB & Record<A, R>, UT, TB | A, O>;
+declare type InnerJoinedDB<DB, A extends string, R> = {
+    [C in keyof DB | A]: C extends A ? R : C extends keyof DB ? DB[C] : never;
+};
+export declare type UpdateQueryBuilderWithLeftJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+declare type LeftJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? UpdateQueryBuilder<LeftJoinedDB<DB, A, R>, UT, TB | A, O> : UpdateQueryBuilder<DB & Record<A, Nullable<R>>, UT, TB | A, O>;
+declare type LeftJoinedDB<DB, A extends keyof any, R> = {
+    [C in keyof DB | A]: C extends A ? Nullable<R> : C extends keyof DB ? DB[C] : never;
+};
+export declare type UpdateQueryBuilderWithRightJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+declare type RightJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = UpdateQueryBuilder<RightJoinedDB<DB, TB, A, R>, UT, TB | A, O>;
+declare type RightJoinedDB<DB, TB extends keyof DB, A extends keyof any, R> = {
+    [C in keyof DB | A]: C extends A ? R : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
+};
+export declare type UpdateQueryBuilderWithFullJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+declare type OuterJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = UpdateQueryBuilder<OuterJoinedBuilderDB<DB, TB, A, R>, UT, TB | A, O>;
+declare type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = {
+    [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
+};
+export {};

package/dist/cjs/query-compiler/default-query-compiler.js

@@ -704,7 +704,16 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     }
     visitDropConstraint(node) {
         this.append('drop constraint ');
+        if (node.ifExists) {
+            this.append('if exists ');
+        }
         this.visitNode(node.constraintName);
+        if (node.modifier === 'cascade') {
+            this.append(' cascade');
+        }
+        else if (node.modifier === 'restrict') {
+            this.append(' restrict');
+        }
     }
     visitUnion(node) {
         this.append('union ');
@@ -830,4 +839,6 @@ const JOIN_TYPE_SQL = (0, object_utils_js_1.freeze)({
     LeftJoin: 'left join',
     RightJoin: 'right join',
     FullJoin: 'full join',
+    LateralInnerJoin: 'inner join lateral',
+    LateralLeftJoin: 'left join lateral',
 });

package/dist/cjs/query-creator.d.ts

@@ -2,7 +2,7 @@ import { SelectQueryBuilder } from './query-builder/select-query-builder.js';
 import { InsertQueryBuilder } from './query-builder/insert-query-builder.js';
 import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
 import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
-import { TableExpression, TableExpressionDatabase, TableExpressionTables, TableReference } from './parser/table-parser.js';
+import { TableExpression, From, FromTables, TableReference } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression, RecursiveCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
@@ -120,8 +120,8 @@ export declare class QueryCreator<DB> {
      *   (select 1 as one) as "q"
      * ```
      */
-    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
     /**
      * Creates an insert query.
      *
@@ -180,7 +180,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numDeletedRows)
      * ```
      */
-    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, DeleteResult>;
+    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
     /**
      * Creates an update query.
      *
@@ -204,7 +204,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
-    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
+    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, FromTables<DB, never, TR>, UpdateResult>;
     /**
      * Creates a `with` query (Common Table Expression).
      *

package/dist/cjs/schema/alter-table-builder.d.ts

@@ -49,6 +49,7 @@ export declare class AlterTableBuilder {
      * is because you can only add one column per `ALTER TABLE` query.
      */
     addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
+    dropConstraint(constraintName: string): AlterTableDropConstraintBuilder;
 }
 export interface AlterTableBuilderProps {
     readonly queryId: QueryId;
@@ -419,3 +420,15 @@ export declare class AlterTableAddForeignKeyConstraintBuilder implements Foreign
 export interface AlterTableAddForeignKeyConstraintBuilderProps extends AlterTableBuilderProps {
     readonly constraintBuilder: ForeignKeyConstraintBuilder;
 }
+export declare class AlterTableDropConstraintBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableDropConstraintBuilderProps);
+    ifExists(): AlterTableDropConstraintBuilder;
+    cascade(): AlterTableDropConstraintBuilder;
+    restrict(): AlterTableDropConstraintBuilder;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface AlterTableDropConstraintBuilderProps extends AlterTableBuilderProps {
+}

package/dist/cjs/schema/alter-table-builder.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AlterTableAddForeignKeyConstraintBuilder = exports.AlterTableModifyColumnBuilder = exports.AlterTableAddColumnBuilder = exports.AlterTableExecutor = exports.AlterColumnBuilder = exports.AlterTableBuilder = void 0;
+exports.AlterTableDropConstraintBuilder = exports.AlterTableAddForeignKeyConstraintBuilder = exports.AlterTableModifyColumnBuilder = exports.AlterTableAddColumnBuilder = exports.AlterTableExecutor = exports.AlterColumnBuilder = exports.AlterTableBuilder = void 0;
 const add_column_node_js_1 = require("../operation-node/add-column-node.js");
 const alter_column_node_js_1 = require("../operation-node/alter-column-node.js");
 const alter_table_node_js_1 = require("../operation-node/alter-table-node.js");
@@ -22,6 +22,7 @@ const foreign_key_constraint_node_js_1 = require("../operation-node/foreign-key-
 const column_node_js_1 = require("../operation-node/column-node.js");
 const default_value_parser_js_1 = require("../parser/default-value-parser.js");
 const table_parser_js_1 = require("../parser/table-parser.js");
+const drop_constraint_node_js_1 = require("../operation-node/drop-constraint-node.js");
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -123,6 +124,14 @@ class AlterTableBuilder {
             constraintBuilder: new foreign_key_constraint_builder_js_1.ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.create(columns.map(column_node_js_1.ColumnNode.create), (0, table_parser_js_1.parseTable)(targetTable), targetColumns.map(column_node_js_1.ColumnNode.create), constraintName)),
         });
     }
+    dropConstraint(constraintName) {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            alterTableNode: alter_table_node_js_1.AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                dropConstraint: drop_constraint_node_js_1.DropConstraintNode.create(constraintName),
+            }),
+        });
+    }
 }
 exports.AlterTableBuilder = AlterTableBuilder;
 class AlterColumnBuilder {
@@ -432,9 +441,56 @@ class AlterTableAddForeignKeyConstraintBuilder {
     }
 }
 exports.AlterTableAddForeignKeyConstraintBuilder = AlterTableAddForeignKeyConstraintBuilder;
+class AlterTableDropConstraintBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    ifExists() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            alterTableNode: alter_table_node_js_1.AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                dropConstraint: drop_constraint_node_js_1.DropConstraintNode.cloneWith(this.#props.alterTableNode.dropConstraint, {
+                    ifExists: true,
+                }),
+            }),
+        });
+    }
+    cascade() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            alterTableNode: alter_table_node_js_1.AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                dropConstraint: drop_constraint_node_js_1.DropConstraintNode.cloneWith(this.#props.alterTableNode.dropConstraint, {
+                    modifier: 'cascade',
+                }),
+            }),
+        });
+    }
+    restrict() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            alterTableNode: alter_table_node_js_1.AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                dropConstraint: drop_constraint_node_js_1.DropConstraintNode.cloneWith(this.#props.alterTableNode.dropConstraint, {
+                    modifier: 'restrict',
+                }),
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.alterTableNode, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+exports.AlterTableDropConstraintBuilder = AlterTableDropConstraintBuilder;
 (0, prevent_await_js_1.preventAwait)(AlterTableBuilder, "don't await AlterTableBuilder instances");
 (0, prevent_await_js_1.preventAwait)(AlterColumnBuilder, "don't await AlterColumnBuilder instances");
 (0, prevent_await_js_1.preventAwait)(AlterTableExecutor, "don't await AlterTableExecutor instances directly. To execute the query you need to call `execute`");
 (0, prevent_await_js_1.preventAwait)(AlterTableAddColumnBuilder, "don't await AlterTableAddColumnBuilder instances directly. To execute the query you need to call `execute`");
 (0, prevent_await_js_1.preventAwait)(AlterTableModifyColumnBuilder, "don't await AlterTableModifyColumnBuilder instances directly. To execute the query you need to call `execute`");
 (0, prevent_await_js_1.preventAwait)(AlterTableAddForeignKeyConstraintBuilder, "don't await AlterTableAddForeignKeyConstraintBuilder instances directly. To execute the query you need to call `execute`");
+(0, prevent_await_js_1.preventAwait)(AlterTableDropConstraintBuilder, "don't await AlterTableDropConstraintBuilder instances directly. To execute the query you need to call `execute`");

package/dist/cjs/util/type-utils.d.ts

@@ -111,6 +111,9 @@ export declare type UnknownRow = Record<string, unknown>;
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
+export declare type NullableValues<T> = {
+    [P in keyof T]: Nullable<T[P]>;
+};
 /**
  * Takes all properties from T1 and merges all properties from T2
  * that don't exist in T1 as optional properties.

package/dist/esm/dialect/mysql/mysql-driver.d.ts

@@ -11,11 +11,6 @@ export declare class MysqlDriver implements Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/esm/dialect/postgres/postgres-driver.d.ts

@@ -11,11 +11,6 @@ export declare class PostgresDriver implements Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/esm/dialect/sqlite/sqlite-driver.d.ts

@@ -9,11 +9,6 @@ export declare class SqliteDriver implements Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -35,7 +35,6 @@ export class SqliteIntrospector {
         const columns = await db
             .selectFrom(sql `PRAGMA_TABLE_INFO(${table})`.as('table_info'))
             .select(['name', 'type', 'notnull'])
-            .castTo()
             .execute();
         return {
             name: table,

package/dist/esm/driver/driver.d.ts

@@ -10,11 +10,6 @@ export interface Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/esm/driver/dummy-driver.d.ts

@@ -42,11 +42,6 @@ export declare class DummyDriver implements Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/esm/driver/runtime-driver.d.ts

@@ -14,11 +14,6 @@ export declare class RuntimeDriver implements Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/esm/index.d.ts

@@ -1,7 +1,6 @@
 export * from './kysely.js';
 export * from './query-creator.js';
 export * from './query-builder/where-interface.js';
-export * from './query-builder/join-interface.js';
 export * from './query-builder/returning-interface.js';
 export * from './query-builder/having-interface.js';
 export * from './query-builder/select-query-builder.js';

package/dist/esm/index.js

@@ -2,7 +2,6 @@
 export * from './kysely.js';
 export * from './query-creator.js';
 export * from './query-builder/where-interface.js';
-export * from './query-builder/join-interface.js';
 export * from './query-builder/returning-interface.js';
 export * from './query-builder/having-interface.js';
 export * from './query-builder/select-query-builder.js';

package/dist/esm/migration/file-migration-provider.js

@@ -25,9 +25,10 @@ export class FileMigrationProvider {
         const migrations = {};
         const files = await this.#props.fs.readdir(this.#props.migrationFolder);
         for (const fileName of files) {
-            if ((fileName.endsWith('.js') || fileName.endsWith('.ts')) &&
+            if ((fileName.endsWith('.js') || fileName.endsWith('.ts') || fileName.endsWith('.mjs')) &&
                 !fileName.endsWith('.d.ts')) {
-                const migration = await import(this.#props.path.join(this.#props.migrationFolder, fileName));
+                const migration = await import(
+                /* webpackIgnore: true */ this.#props.path.join(this.#props.migrationFolder, fileName));
                 if (isMigration(migration)) {
                     migrations[fileName.substring(0, fileName.length - 3)] = migration;
                 }

package/dist/esm/operation-node/check-constraint-node.d.ts

@@ -11,5 +11,5 @@ export interface CheckConstraintNode extends OperationNode {
  */
 export declare const CheckConstraintNode: Readonly<{
     is(node: OperationNode): node is CheckConstraintNode;
-    create(expression: RawNode, constraintName?: string | undefined): CheckConstraintNode;
+    create(expression: RawNode, constraintName?: string): CheckConstraintNode;
 }>;

package/dist/esm/operation-node/common-table-expression-name-node.d.ts

@@ -11,5 +11,5 @@ export interface CommonTableExpressionNameNode extends OperationNode {
  */
 export declare const CommonTableExpressionNameNode: Readonly<{
     is(node: OperationNode): node is CommonTableExpressionNameNode;
-    create(tableName: string, columnNames?: readonly string[] | undefined): CommonTableExpressionNameNode;
+    create(tableName: string, columnNames?: ReadonlyArray<string>): CommonTableExpressionNameNode;
 }>;

package/dist/esm/operation-node/create-schema-node.d.ts

@@ -11,6 +11,6 @@ export interface CreateSchemaNode extends OperationNode {
  */
 export declare const CreateSchemaNode: Readonly<{
     is(node: OperationNode): node is CreateSchemaNode;
-    create(schema: string, params?: CreateSchemaNodeParams | undefined): CreateSchemaNode;
+    create(schema: string, params?: CreateSchemaNodeParams): CreateSchemaNode;
     cloneWith(createSchema: CreateSchemaNode, params: CreateSchemaNodeParams): CreateSchemaNode;
 }>;

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

@@ -23,7 +23,7 @@ export interface DeleteQueryNode extends OperationNode {
  */
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
-    create(fromItem: TableExpressionNode, withNode?: WithNode | undefined): DeleteQueryNode;
+    create(fromItem: TableExpressionNode, withNode?: WithNode): DeleteQueryNode;
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
 }>;

package/dist/esm/operation-node/drop-constraint-node.d.ts

@@ -1,8 +1,11 @@
 import { OperationNode } from './operation-node.js';
 import { IdentifierNode } from './identifier-node.js';
+export declare type DropConstraintNodeProps = Omit<DropConstraintNode, 'kind' | 'constraintName'>;
 export interface DropConstraintNode extends OperationNode {
     readonly kind: 'DropConstraintNode';
     readonly constraintName: IdentifierNode;
+    readonly ifExists?: boolean;
+    readonly modifier?: 'cascade' | 'restrict';
 }
 /**
  * @internal
@@ -10,4 +13,5 @@ export interface DropConstraintNode extends OperationNode {
 export declare const DropConstraintNode: Readonly<{
     is(node: OperationNode): node is DropConstraintNode;
     create(constraintName: string): DropConstraintNode;
+    cloneWith(dropConstraint: DropConstraintNode, props: DropConstraintNodeProps): DropConstraintNode;
 }>;

package/dist/esm/operation-node/drop-constraint-node.js

@@ -14,4 +14,10 @@ export const DropConstraintNode = freeze({
             constraintName: IdentifierNode.create(constraintName),
         });
     },
+    cloneWith(dropConstraint, props) {
+        return freeze({
+            ...dropConstraint,
+            ...props,
+        });
+    },
 });

package/dist/esm/operation-node/drop-index-node.d.ts

@@ -13,6 +13,6 @@ export interface DropIndexNode extends OperationNode {
  */
 export declare const DropIndexNode: Readonly<{
     is(node: OperationNode): node is DropIndexNode;
-    create(name: string, params?: DropIndexNodeProps | undefined): DropIndexNode;
+    create(name: string, params?: DropIndexNodeProps): DropIndexNode;
     cloneWith(dropIndex: DropIndexNode, props: DropIndexNodeProps): DropIndexNode;
 }>;