kysely 0.22.0 → 0.23.1

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

@@ -1,7 +1,6 @@
 import { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
 import { DataTypeNode } from './data-type-node.js';
-import { ValueNode } from './value-node.js';
 import { RawNode } from './raw-node.js';
 export declare type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>;
 export interface AlterColumnNode extends OperationNode {
@@ -9,7 +8,7 @@ export interface AlterColumnNode extends OperationNode {
     readonly column: ColumnNode;
     readonly dataType?: DataTypeNode;
     readonly dataTypeExpression?: RawNode;
-    readonly setDefault?: ValueNode | RawNode;
+    readonly setDefault?: OperationNode;
     readonly dropDefault?: true;
     readonly setNotNull?: true;
     readonly dropNotNull?: true;

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

@@ -8,17 +8,14 @@ import { AlterColumnNode } from './alter-column-node.js';
 import { AddConstraintNode } from './add-constraint-node.js';
 import { DropConstraintNode } from './drop-constraint-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
-export declare type AlterTableNodeProps = Omit<AlterTableNode, 'kind' | 'table'>;
+export declare type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint'>;
+export declare type AlterTableColumnAlterationNode = RenameColumnNode | AddColumnNode | DropColumnNode | AlterColumnNode | ModifyColumnNode;
 export interface AlterTableNode extends OperationNode {
     readonly kind: 'AlterTableNode';
     readonly table: TableNode;
     readonly renameTo?: TableNode;
     readonly setSchema?: IdentifierNode;
-    readonly renameColumn?: RenameColumnNode;
-    readonly addColumn?: AddColumnNode;
-    readonly dropColumn?: DropColumnNode;
-    readonly alterColumn?: AlterColumnNode;
-    readonly modifyColumn?: ModifyColumnNode;
+    readonly columnAlterations?: ReadonlyArray<AlterTableColumnAlterationNode>;
     readonly addConstraint?: AddConstraintNode;
     readonly dropConstraint?: DropConstraintNode;
 }
@@ -28,5 +25,6 @@ export interface AlterTableNode extends OperationNode {
 export declare const AlterTableNode: Readonly<{
     is(node: OperationNode): node is AlterTableNode;
     create(table: string): AlterTableNode;
-    cloneWith(node: AlterTableNode, props: AlterTableNodeProps): AlterTableNode;
+    cloneWithTableProps(node: AlterTableNode, props: AlterTableNodeTableProps): AlterTableNode;
+    cloneWithColumnAlteration(node: AlterTableNode, columnAlteration: AlterTableColumnAlterationNode): AlterTableNode;
 }>;

package/dist/cjs/operation-node/alter-table-node.js

@@ -16,10 +16,18 @@ exports.AlterTableNode = (0, object_utils_js_1.freeze)({
             table: table_node_js_1.TableNode.create(table),
         });
     },
-    cloneWith(node, props) {
+    cloneWithTableProps(node, props) {
         return (0, object_utils_js_1.freeze)({
             ...node,
             ...props,
         });
     },
+    cloneWithColumnAlteration(node, columnAlteration) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            columnAlterations: node.columnAlterations
+                ? [...node.columnAlterations, columnAlteration]
+                : [columnAlteration],
+        });
+    },
 });

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

@@ -1,14 +1,13 @@
 import { OperationNode } from './operation-node.js';
-import { FilterExpressionNode } from './operation-node-utils.js';
 export interface AndNode extends OperationNode {
     readonly kind: 'AndNode';
-    readonly left: FilterExpressionNode;
-    readonly right: FilterExpressionNode;
+    readonly left: OperationNode;
+    readonly right: OperationNode;
 }
 /**
  * @internal
  */
 export declare const AndNode: Readonly<{
     is(node: OperationNode): node is AndNode;
-    create(left: FilterExpressionNode, right: FilterExpressionNode): AndNode;
+    create(left: OperationNode, right: OperationNode): AndNode;
 }>;

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

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+export interface BinaryOperationNode extends OperationNode {
+    readonly kind: 'BinaryOperationNode';
+    readonly leftOperand: OperationNode;
+    readonly operator: OperationNode;
+    readonly rightOperand: OperationNode;
+}
+/**
+ * @internal
+ */
+export declare const BinaryOperationNode: Readonly<{
+    is(node: OperationNode): node is BinaryOperationNode;
+    create(leftOperand: OperationNode, operator: OperationNode, rightOperand: OperationNode): BinaryOperationNode;
+}>;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryOperationNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.BinaryOperationNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'BinaryOperationNode';
+    },
+    create(leftOperand, operator, rightOperand) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'BinaryOperationNode',
+            leftOperand,
+            operator,
+            rightOperand,
+        });
+    },
+});

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

@@ -1,9 +1,8 @@
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 import { IdentifierNode } from './identifier-node.js';
 export interface CheckConstraintNode extends OperationNode {
     readonly kind: 'CheckConstraintNode';
-    readonly expression: RawNode;
+    readonly expression: OperationNode;
     readonly name?: IdentifierNode;
 }
 /**
@@ -11,5 +10,5 @@ export interface CheckConstraintNode extends OperationNode {
  */
 export declare const CheckConstraintNode: Readonly<{
     is(node: OperationNode): node is CheckConstraintNode;
-    create(expression: RawNode, constraintName?: string): CheckConstraintNode;
+    create(expression: OperationNode, constraintName?: string): CheckConstraintNode;
 }>;

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

@@ -1,17 +1,14 @@
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { ColumnNode } from './column-node.js';
-import { DataTypeNode } from './data-type-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { GeneratedNode } from './generated-node.js';
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 import { ReferencesNode } from './references-node.js';
 export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind' | 'dataType'>;
-export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
 export interface ColumnDefinitionNode extends OperationNode {
     readonly kind: 'ColumnDefinitionNode';
     readonly column: ColumnNode;
-    readonly dataType: ColumnDataTypeNode;
+    readonly dataType: OperationNode;
     readonly references?: ReferencesNode;
     readonly primaryKey?: boolean;
     readonly autoIncrement?: boolean;
@@ -21,12 +18,16 @@ export interface ColumnDefinitionNode extends OperationNode {
     readonly check?: CheckConstraintNode;
     readonly generated?: GeneratedNode;
     readonly unsigned?: boolean;
+    readonly frontModifiers?: ReadonlyArray<OperationNode>;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal
  */
 export declare const ColumnDefinitionNode: Readonly<{
     is(node: OperationNode): node is ColumnDefinitionNode;
-    create(column: string, dataType: ColumnDataTypeNode): ColumnDefinitionNode;
+    create(column: string, dataType: OperationNode): ColumnDefinitionNode;
+    cloneWithFrontModifier(node: ColumnDefinitionNode, modifier: OperationNode): ColumnDefinitionNode;
+    cloneWithEndModifier(node: ColumnDefinitionNode, modifier: OperationNode): ColumnDefinitionNode;
     cloneWith(node: ColumnDefinitionNode, props: ColumnDefinitionNodeProps): ColumnDefinitionNode;
 }>;

package/dist/cjs/operation-node/column-definition-node.js

@@ -17,6 +17,22 @@ exports.ColumnDefinitionNode = (0, object_utils_js_1.freeze)({
             dataType,
         });
     },
+    cloneWithFrontModifier(node, modifier) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            frontModifiers: node.frontModifiers
+                ? (0, object_utils_js_1.freeze)([...node.frontModifiers, modifier])
+                : [modifier],
+        });
+    },
+    cloneWithEndModifier(node, modifier) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            endModifiers: node.endModifiers
+                ? (0, object_utils_js_1.freeze)([...node.endModifiers, modifier])
+                : [modifier],
+        });
+    },
     cloneWith(node, props) {
         return (0, object_utils_js_1.freeze)({
             ...node,

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

@@ -1,15 +1,14 @@
 import { ColumnNode } from './column-node.js';
 import { OperationNode } from './operation-node.js';
-import { ValueExpressionNode } from './operation-node-utils.js';
 export interface ColumnUpdateNode extends OperationNode {
     readonly kind: 'ColumnUpdateNode';
     readonly column: ColumnNode;
-    readonly value: ValueExpressionNode;
+    readonly value: OperationNode;
 }
 /**
  * @internal
  */
 export declare const ColumnUpdateNode: Readonly<{
     is(node: OperationNode): node is ColumnUpdateNode;
-    create(column: ColumnNode, value: ValueExpressionNode): ColumnUpdateNode;
+    create(column: ColumnNode, value: OperationNode): ColumnUpdateNode;
 }>;

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

@@ -1,16 +1,14 @@
 import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { OperationNode } from './operation-node.js';
-import { QueryNode } from './query-node.js';
-import { RawNode } from './raw-node.js';
 export interface CommonTableExpressionNode extends OperationNode {
     readonly kind: 'CommonTableExpressionNode';
     readonly name: CommonTableExpressionNameNode;
-    readonly expression: QueryNode | RawNode;
+    readonly expression: OperationNode;
 }
 /**
  * @internal
  */
 export declare const CommonTableExpressionNode: Readonly<{
     is(node: OperationNode): node is CommonTableExpressionNode;
-    create(name: CommonTableExpressionNameNode, expression: QueryNode | RawNode): CommonTableExpressionNode;
+    create(name: CommonTableExpressionNameNode, expression: OperationNode): CommonTableExpressionNode;
 }>;

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

@@ -1,6 +1,4 @@
-import { ColumnNode } from './column-node.js';
 import { IdentifierNode } from './identifier-node.js';
-import { ListNode } from './list-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { TableNode } from './table-node.js';
@@ -10,7 +8,7 @@ export interface CreateIndexNode extends OperationNode {
     readonly kind: 'CreateIndexNode';
     readonly name: IdentifierNode;
     readonly table?: TableNode;
-    readonly expression?: ColumnNode | ListNode | RawNode;
+    readonly expression?: OperationNode;
     readonly unique?: boolean;
     readonly using?: RawNode;
 }

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

@@ -3,7 +3,6 @@ import { TableNode } from './table-node.js';
 import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ArrayItemType } from '../util/type-utils.js';
-import { RawNode } from './raw-node.js';
 export declare const ON_COMMIT_ACTIONS: string[];
 export declare type OnCommitAction = ArrayItemType<typeof ON_COMMIT_ACTIONS>;
 export declare type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints' | 'frontModifiers' | 'endModifiers'>;
@@ -15,8 +14,8 @@ export interface CreateTableNode extends OperationNode {
     readonly temporary?: boolean;
     readonly ifNotExists?: boolean;
     readonly onCommit?: OnCommitAction;
-    readonly frontModifiers?: ReadonlyArray<RawNode>;
-    readonly endModifiers?: ReadonlyArray<RawNode>;
+    readonly frontModifiers?: ReadonlyArray<OperationNode>;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal
@@ -26,7 +25,7 @@ export declare const CreateTableNode: Readonly<{
     create(table: TableNode): CreateTableNode;
     cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
     cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): CreateTableNode;
-    cloneWithFrontModifier(createTable: CreateTableNode, modifier: RawNode): CreateTableNode;
-    cloneWithEndModifier(createTable: CreateTableNode, modifier: RawNode): CreateTableNode;
+    cloneWithFrontModifier(createTable: CreateTableNode, modifier: OperationNode): CreateTableNode;
+    cloneWithEndModifier(createTable: CreateTableNode, modifier: OperationNode): CreateTableNode;
     cloneWith(createTable: CreateTableNode, params: CreateTableNodeParams): CreateTableNode;
 }>;

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

@@ -12,6 +12,6 @@ export interface CreateTypeNode extends OperationNode {
  */
 export declare const CreateTypeNode: Readonly<{
     is(node: OperationNode): node is CreateTypeNode;
-    create(name: string): CreateTypeNode;
+    create(name: SchemableIdentifierNode): CreateTypeNode;
     cloneWithEnum(createType: CreateTypeNode, values: string[]): CreateTypeNode;
 }>;

package/dist/cjs/operation-node/create-type-node.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateTypeNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const schemable_identifier_node_js_1 = require("./schemable-identifier-node.js");
 const value_list_node_js_1 = require("./value-list-node.js");
 const value_node_js_1 = require("./value-node.js");
 /**
@@ -15,7 +14,7 @@ exports.CreateTypeNode = (0, object_utils_js_1.freeze)({
     create(name) {
         return (0, object_utils_js_1.freeze)({
             kind: 'CreateTypeNode',
-            name: schemable_identifier_node_js_1.SchemableIdentifierNode.create(name),
+            name,
         });
     },
     cloneWithEnum(createType, values) {

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

@@ -1,14 +1,12 @@
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-import { ValueNode } from './value-node.js';
 export interface DefaultValueNode extends OperationNode {
     readonly kind: 'DefaultValueNode';
-    readonly defaultValue: ValueNode | RawNode;
+    readonly defaultValue: OperationNode;
 }
 /**
  * @internal
  */
 export declare const DefaultValueNode: Readonly<{
     is(node: OperationNode): node is DefaultValueNode;
-    create(defaultValue: ValueNode | RawNode): DefaultValueNode;
+    create(defaultValue: OperationNode): DefaultValueNode;
 }>;

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

@@ -1,7 +1,6 @@
 import { FromNode } from './from-node.js';
 import { JoinNode } from './join-node.js';
 import { OperationNode } from './operation-node.js';
-import { TableExpressionNode } from './operation-node-utils.js';
 import { ReturningNode } from './returning-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
@@ -25,7 +24,7 @@ export interface DeleteQueryNode extends OperationNode {
  */
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
-    create(fromItem: TableExpressionNode, withNode?: WithNode): DeleteQueryNode;
+    create(fromItem: OperationNode, withNode?: WithNode): DeleteQueryNode;
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
     cloneWithExplain(deleteNode: DeleteQueryNode, explain: ExplainNode): DeleteQueryNode;

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

@@ -11,6 +11,6 @@ export interface DropTypeNode extends OperationNode {
  */
 export declare const DropTypeNode: Readonly<{
     is(node: OperationNode): node is DropTypeNode;
-    create(name: string): DropTypeNode;
+    create(name: SchemableIdentifierNode): DropTypeNode;
     cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): DropTypeNode;
 }>;

package/dist/cjs/operation-node/drop-type-node.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DropTypeNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const schemable_identifier_node_js_1 = require("./schemable-identifier-node.js");
 /**
  * @internal
  */
@@ -13,7 +12,7 @@ exports.DropTypeNode = (0, object_utils_js_1.freeze)({
     create(name) {
         return (0, object_utils_js_1.freeze)({
             kind: 'DropTypeNode',
-            name: schemable_identifier_node_js_1.SchemableIdentifierNode.create(name),
+            name,
         });
     },
     cloneWith(dropType, params) {

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

@@ -1,16 +1,14 @@
 import { ExplainFormat } from '../util/explainable.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 export interface ExplainNode extends OperationNode {
     readonly kind: 'ExplainNode';
     readonly format?: ExplainFormat;
-    readonly options?: RawNode;
+    readonly options?: OperationNode;
 }
 /**
  * @internal
  */
 export declare const ExplainNode: Readonly<{
     is(node: OperationNode): node is ExplainNode;
-    create(format?: ExplainFormat, options?: AnyRawBuilder): ExplainNode;
+    create(format?: ExplainFormat, options?: OperationNode): ExplainNode;
 }>;

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

@@ -13,7 +13,7 @@ exports.ExplainNode = (0, object_utils_js_1.freeze)({
         return (0, object_utils_js_1.freeze)({
             kind: 'ExplainNode',
             format,
-            options: options?.toOperationNode(),
+            options,
         });
     },
 });

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

@@ -1,14 +1,13 @@
 import { OperationNode } from './operation-node.js';
-import { TableExpressionNode } from './operation-node-utils.js';
 export interface FromNode extends OperationNode {
     readonly kind: 'FromNode';
-    readonly froms: ReadonlyArray<TableExpressionNode>;
+    readonly froms: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal
  */
 export declare const FromNode: Readonly<{
     is(node: OperationNode): node is FromNode;
-    create(froms: ReadonlyArray<TableExpressionNode>): FromNode;
-    cloneWithFroms(from: FromNode, froms: ReadonlyArray<TableExpressionNode>): FromNode;
+    create(froms: ReadonlyArray<OperationNode>): FromNode;
+    cloneWithFroms(from: FromNode, froms: ReadonlyArray<OperationNode>): FromNode;
 }>;

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

@@ -1,5 +1,4 @@
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 export declare type GeneratedNodeParams = Omit<GeneratedNode, 'kind' | 'expression'>;
 export interface GeneratedNode extends OperationNode {
     readonly kind: 'GeneratedNode';
@@ -7,7 +6,7 @@ export interface GeneratedNode extends OperationNode {
     readonly always?: boolean;
     readonly identity?: boolean;
     readonly stored?: boolean;
-    readonly expression?: RawNode;
+    readonly expression?: OperationNode;
 }
 /**
  * @internal
@@ -15,6 +14,6 @@ export interface GeneratedNode extends OperationNode {
 export declare const GeneratedNode: Readonly<{
     is(node: OperationNode): node is GeneratedNode;
     create(params: GeneratedNodeParams): GeneratedNode;
-    createWithExpression(expression: RawNode): GeneratedNode;
+    createWithExpression(expression: OperationNode): GeneratedNode;
     cloneWith(node: GeneratedNode, params: GeneratedNodeParams): GeneratedNode;
 }>;

package/dist/cjs/operation-node/group-by-item-node.d.ts

@@ -1,13 +1,12 @@
 import { OperationNode } from './operation-node.js';
-import { ReferenceExpressionNode } from './operation-node-utils.js';
 export interface GroupByItemNode extends OperationNode {
     readonly kind: 'GroupByItemNode';
-    readonly groupBy: ReferenceExpressionNode;
+    readonly groupBy: OperationNode;
 }
 /**
  * @internal
  */
 export declare const GroupByItemNode: Readonly<{
     is(node: OperationNode): node is GroupByItemNode;
-    create(groupBy: ReferenceExpressionNode): GroupByItemNode;
+    create(groupBy: OperationNode): GroupByItemNode;
 }>;

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

@@ -1,14 +1,13 @@
-import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
 export interface HavingNode extends OperationNode {
     readonly kind: 'HavingNode';
-    readonly having: FilterExpressionNode;
+    readonly having: OperationNode;
 }
 /**
  * @internal
  */
 export declare const HavingNode: Readonly<{
     is(node: OperationNode): node is HavingNode;
-    create(filter: FilterExpressionNode): HavingNode;
-    cloneWithFilter(havingNode: HavingNode, op: 'And' | 'Or', filter: FilterExpressionNode): HavingNode;
+    create(filter: OperationNode): HavingNode;
+    cloneWithOperation(havingNode: HavingNode, operator: 'And' | 'Or', operation: OperationNode): HavingNode;
 }>;

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

@@ -17,12 +17,12 @@ exports.HavingNode = (0, object_utils_js_1.freeze)({
             having: filter,
         });
     },
-    cloneWithFilter(havingNode, op, filter) {
+    cloneWithOperation(havingNode, operator, operation) {
         return (0, object_utils_js_1.freeze)({
             ...havingNode,
-            having: op === 'And'
-                ? and_node_js_1.AndNode.create(havingNode.having, filter)
-                : or_node_js_1.OrNode.create(havingNode.having, filter),
+            having: operator === 'And'
+                ? and_node_js_1.AndNode.create(havingNode.having, operation)
+                : or_node_js_1.OrNode.create(havingNode.having, operation),
         });
     },
 });

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

@@ -1,21 +1,17 @@
-import { AggregateFunctionNode } from './aggregate-function-node.js';
 import { ColumnNode } from './column-node.js';
 import { ExplainNode } from './explain-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 import { ReturningNode } from './returning-node.js';
-import { SelectQueryNode } from './select-query-node.js';
 import { TableNode } from './table-node.js';
-import { ValuesNode } from './values-node.js';
 import { WithNode } from './with-node.js';
 export declare type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
 export interface InsertQueryNode extends OperationNode {
     readonly kind: 'InsertQueryNode';
     readonly into: TableNode;
     readonly columns?: ReadonlyArray<ColumnNode>;
-    readonly values?: ValuesNode | SelectQueryNode | RawNode | AggregateFunctionNode;
+    readonly values?: OperationNode;
     readonly returning?: ReturningNode;
     readonly onConflict?: OnConflictNode;
     readonly onDuplicateKey?: OnDuplicateKeyNode;

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

@@ -1,14 +1,10 @@
-import { AliasNode } from './alias-node.js';
 import { OnNode } from './on-node.js';
-import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-import { TableNode } from './table-node.js';
-export declare type JoinTableNode = TableNode | AliasNode;
 export declare type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'LateralInnerJoin' | 'LateralLeftJoin';
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
     readonly joinType: JoinType;
-    readonly table: JoinTableNode;
+    readonly table: OperationNode;
     readonly on?: OnNode;
 }
 /**
@@ -16,8 +12,8 @@ export interface JoinNode extends OperationNode {
  */
 export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
-    create(joinType: JoinType, table: JoinTableNode): JoinNode;
-    createWithOn(joinType: JoinType, table: JoinTableNode, on: FilterExpressionNode): JoinNode;
-    cloneWithOn(joinNode: JoinNode, filter: FilterExpressionNode): JoinNode;
-    cloneWithOrOn(joinNode: JoinNode, filter: FilterExpressionNode): JoinNode;
+    create(joinType: JoinType, table: OperationNode): JoinNode;
+    createWithOn(joinType: JoinType, table: OperationNode, on: OperationNode): JoinNode;
+    cloneWithOn(joinNode: JoinNode, operation: OperationNode): JoinNode;
+    cloneWithOrOn(joinNode: JoinNode, operation: OperationNode): JoinNode;
 }>;

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

@@ -26,20 +26,20 @@ exports.JoinNode = (0, object_utils_js_1.freeze)({
             on: on_node_js_1.OnNode.create(on),
         });
     },
-    cloneWithOn(joinNode, filter) {
+    cloneWithOn(joinNode, operation) {
         return (0, object_utils_js_1.freeze)({
             ...joinNode,
             on: joinNode.on
-                ? on_node_js_1.OnNode.cloneWithFilter(joinNode.on, 'And', filter)
-                : on_node_js_1.OnNode.create(filter),
+                ? on_node_js_1.OnNode.cloneWithOperation(joinNode.on, 'And', operation)
+                : on_node_js_1.OnNode.create(operation),
         });
     },
-    cloneWithOrOn(joinNode, filter) {
+    cloneWithOrOn(joinNode, operation) {
         return (0, object_utils_js_1.freeze)({
             ...joinNode,
             on: joinNode.on
-                ? on_node_js_1.OnNode.cloneWithFilter(joinNode.on, 'Or', filter)
-                : on_node_js_1.OnNode.create(filter),
+                ? on_node_js_1.OnNode.cloneWithOperation(joinNode.on, 'Or', operation)
+                : on_node_js_1.OnNode.create(operation),
         });
     },
 });

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

@@ -1,16 +1,14 @@
 import { ColumnNode } from './column-node.js';
 import { ColumnUpdateNode } from './column-update-node.js';
 import { IdentifierNode } from './identifier-node.js';
-import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 import { WhereNode } from './where-node.js';
 export declare type OnConflictNodeProps = Omit<OnConflictNode, 'kind' | 'indexWhere' | 'updateWhere'>;
 export interface OnConflictNode extends OperationNode {
     readonly kind: 'OnConflictNode';
     readonly columns?: ReadonlyArray<ColumnNode>;
     readonly constraint?: IdentifierNode;
-    readonly indexExpression?: RawNode;
+    readonly indexExpression?: OperationNode;
     readonly indexWhere?: WhereNode;
     readonly updates?: ReadonlyArray<ColumnUpdateNode>;
     readonly updateWhere?: WhereNode;
@@ -23,8 +21,8 @@ export declare const OnConflictNode: Readonly<{
     is(node: OperationNode): node is OnConflictNode;
     create(): OnConflictNode;
     cloneWith(node: OnConflictNode, props: OnConflictNodeProps): OnConflictNode;
-    cloneWithIndexWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
-    cloneWithIndexOrWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
-    cloneWithUpdateWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
-    cloneWithUpdateOrWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
+    cloneWithIndexWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithIndexOrWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithUpdateWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithUpdateOrWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
 }>;