kysely 0.21.6 → 0.23.0

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

@@ -27,12 +27,19 @@ 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') || fileName.endsWith('.mjs')) &&
-                !fileName.endsWith('.d.ts')) {
+            if (fileName.endsWith('.js') ||
+                (fileName.endsWith('.ts') && !fileName.endsWith('.d.ts')) ||
+                fileName.endsWith('.mjs') ||
+                (fileName.endsWith('.mts') && !fileName.endsWith('.d.mts'))) {
                 const migration = await Promise.resolve().then(() => require(
                 /* webpackIgnore: true */ this.#props.path.join(this.#props.migrationFolder, fileName)));
-                if (isMigration(migration)) {
-                    migrations[fileName.substring(0, fileName.length - 3)] = migration;
+                const migrationKey = fileName.substring(0, fileName.lastIndexOf('.'));
+                // Handle esModuleInterop export's `default` prop...
+                if (isMigration(migration?.default)) {
+                    migrations[migrationKey] = migration.default;
+                }
+                else if (isMigration(migration)) {
+                    migrations[migrationKey] = migration;
                 }
             }
         }

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

@@ -0,0 +1,25 @@
+import { OperationNode } from './operation-node.js';
+import { OverNode } from './over-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 distinct?: boolean;
+    readonly filter?: WhereNode;
+    readonly over?: OverNode;
+}
+/**
+ * @internal
+ */
+export declare const AggregateFunctionNode: Readonly<{
+    is(node: OperationNode): node is AggregateFunctionNode;
+    create(aggregateFunction: AggregateFunction, column: SimpleReferenceExpressionNode): AggregateFunctionNode;
+    cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
+    cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
+    cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
+    cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): AggregateFunctionNode;
+}>;
+export {};

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateFunctionNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const where_node_js_1 = require("./where-node.js");
+/**
+ * @internal
+ */
+exports.AggregateFunctionNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'AggregateFunctionNode';
+    },
+    create(aggregateFunction, column) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'AggregateFunctionNode',
+            func: aggregateFunction,
+            column,
+        });
+    },
+    cloneWithDistinct(aggregateFunctionNode) {
+        return (0, object_utils_js_1.freeze)({
+            ...aggregateFunctionNode,
+            distinct: true,
+        });
+    },
+    cloneWithFilter(aggregateFunctionNode, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...aggregateFunctionNode,
+            filter: aggregateFunctionNode.filter
+                ? where_node_js_1.WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'And', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
+    cloneWithOrFilter(aggregateFunctionNode, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...aggregateFunctionNode,
+            filter: aggregateFunctionNode.filter
+                ? where_node_js_1.WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'Or', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
+    cloneWithOver(aggregateFunctionNode, over) {
+        return (0, object_utils_js_1.freeze)({
+            ...aggregateFunctionNode,
+            over,
+        });
+    },
+});

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

@@ -1,20 +1,13 @@
-import { ColumnNode } from './column-node.js';
-import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-import { ReferenceNode } from './reference-node.js';
-import { SelectQueryNode } from './select-query-node.js';
-import { TableNode } from './table-node.js';
-export declare type AliasNodeChild = ColumnNode | ReferenceNode | TableNode | SelectQueryNode | RawNode;
 export interface AliasNode extends OperationNode {
     readonly kind: 'AliasNode';
-    readonly node: AliasNodeChild;
-    readonly alias: IdentifierNode | RawNode;
+    readonly node: OperationNode;
+    readonly alias: OperationNode;
 }
 /**
  * @internal
  */
 export declare const AliasNode: Readonly<{
     is(node: OperationNode): node is AliasNode;
-    create(node: AliasNodeChild, alias: IdentifierNode | RawNode): AliasNode;
+    create(node: OperationNode, alias: OperationNode): AliasNode;
 }>;

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/group-by-node.d.ts

@@ -10,5 +10,5 @@ export interface GroupByNode extends OperationNode {
 export declare const GroupByNode: Readonly<{
     is(node: OperationNode): node is GroupByNode;
     create(items: ReadonlyArray<GroupByItemNode>): GroupByNode;
-    cloneWithItems(orderBy: GroupByNode, items: ReadonlyArray<GroupByItemNode>): GroupByNode;
+    cloneWithItems(groupBy: GroupByNode, items: ReadonlyArray<GroupByItemNode>): GroupByNode;
 }>;

package/dist/cjs/operation-node/group-by-node.js

@@ -15,10 +15,10 @@ exports.GroupByNode = (0, object_utils_js_1.freeze)({
             items: (0, object_utils_js_1.freeze)(items),
         });
     },
-    cloneWithItems(orderBy, items) {
+    cloneWithItems(groupBy, items) {
         return (0, object_utils_js_1.freeze)({
-            ...orderBy,
-            items: (0, object_utils_js_1.freeze)([...orderBy.items, ...items]),
+            ...groupBy,
+            items: (0, object_utils_js_1.freeze)([...groupBy.items, ...items]),
         });
     },
 });

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;
 }>;