kysely 0.28.8 → 0.28.10

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

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { ValueNode } from './value-node.js';
 export type FetchModifier = 'only' | 'with ties';
 export interface FetchNode extends OperationNode {
@@ -6,10 +6,12 @@ export interface FetchNode extends OperationNode {
     readonly rowCount: ValueNode;
     readonly modifier: FetchModifier;
 }
+type FetchNodeFactory = Readonly<{
+    is(node: OperationNode): node is FetchNode;
+    create(rowCount: number | bigint, modifier: FetchModifier): Readonly<FetchNode>;
+}>;
 /**
  * @internal
  */
-export declare const FetchNode: {
-    is(node: OperationNode): node is FetchNode;
-    create(rowCount: number | bigint, modifier: FetchModifier): FetchNode;
-};
+export declare const FetchNode: FetchNodeFactory;
+export {};

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

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FetchNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
 const value_node_js_1 = require("./value-node.js");
 /**
  * @internal
  */
-exports.FetchNode = {
+exports.FetchNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'FetchNode';
     },
@@ -16,4 +17,4 @@ exports.FetchNode = {
             modifier,
         };
     },
-};
+});

package/dist/cjs/operation-node/foreign-key-constraint-node.d.ts

@@ -1,8 +1,8 @@
-import { ColumnNode } from './column-node.js';
+import type { ColumnNode } from './column-node.js';
 import { IdentifierNode } from './identifier-node.js';
-import { OperationNode } from './operation-node.js';
-import { OnModifyForeignAction, ReferencesNode } from './references-node.js';
-import { TableNode } from './table-node.js';
+import type { OperationNode } from './operation-node.js';
+import { type OnModifyForeignAction, ReferencesNode } from './references-node.js';
+import type { TableNode } from './table-node.js';
 export type ForeignKeyConstraintNodeProps = Omit<ForeignKeyConstraintNode, 'kind' | 'columns' | 'references'>;
 export interface ForeignKeyConstraintNode extends OperationNode {
     readonly kind: 'ForeignKeyConstraintNode';
@@ -14,20 +14,13 @@ export interface ForeignKeyConstraintNode extends OperationNode {
     readonly deferrable?: boolean;
     readonly initiallyDeferred?: boolean;
 }
+type ForeignKeyConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is ForeignKeyConstraintNode;
+    create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string): Readonly<ForeignKeyConstraintNode>;
+    cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<ForeignKeyConstraintNode>;
+}>;
 /**
  * @internal
  */
-export declare const ForeignKeyConstraintNode: Readonly<{
-    is(node: OperationNode): node is ForeignKeyConstraintNode;
-    create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string): ForeignKeyConstraintNode;
-    cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<{
-        name?: IdentifierNode;
-        onDelete?: OnModifyForeignAction;
-        onUpdate?: OnModifyForeignAction;
-        deferrable?: boolean;
-        initiallyDeferred?: boolean;
-        kind: "ForeignKeyConstraintNode";
-        columns: ReadonlyArray<ColumnNode>;
-        references: ReferencesNode;
-    }>;
-}>;
+export declare const ForeignKeyConstraintNode: ForeignKeyConstraintNodeFactory;
+export {};

package/dist/cjs/operation-node/foreign-key-constraint-node.js

@@ -16,7 +16,9 @@ exports.ForeignKeyConstraintNode = (0, object_utils_js_1.freeze)({
             kind: 'ForeignKeyConstraintNode',
             columns: sourceColumns,
             references: references_node_js_1.ReferencesNode.create(targetTable, targetColumns),
-            name: constraintName ? identifier_node_js_1.IdentifierNode.create(constraintName) : undefined,
+            name: constraintName
+                ? identifier_node_js_1.IdentifierNode.create(constraintName)
+                : undefined,
         });
     },
     cloneWith(node, props) {

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

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

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

@@ -1,13 +1,15 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface FunctionNode extends OperationNode {
     readonly kind: 'FunctionNode';
     readonly func: string;
     readonly arguments: ReadonlyArray<OperationNode>;
 }
+type FunctionNodeFactory = Readonly<{
+    is(node: OperationNode): node is FunctionNode;
+    create(func: string, args: ReadonlyArray<OperationNode>): Readonly<FunctionNode>;
+}>;
 /**
  * @internal
  */
-export declare const FunctionNode: Readonly<{
-    is(node: OperationNode): node is FunctionNode;
-    create(func: string, args: ReadonlyArray<OperationNode>): FunctionNode;
-}>;
+export declare const FunctionNode: FunctionNodeFactory;
+export {};

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

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

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

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

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

@@ -1,14 +1,16 @@
-import { OperationNode } from './operation-node.js';
-import { GroupByItemNode } from './group-by-item-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { GroupByItemNode } from './group-by-item-node.js';
 export interface GroupByNode extends OperationNode {
     readonly kind: 'GroupByNode';
     readonly items: ReadonlyArray<GroupByItemNode>;
 }
+type GroupByNodeFactory = Readonly<{
+    is(node: OperationNode): node is GroupByNode;
+    create(items: ReadonlyArray<GroupByItemNode>): Readonly<GroupByNode>;
+    cloneWithItems(groupBy: GroupByNode, items: ReadonlyArray<GroupByItemNode>): Readonly<GroupByNode>;
+}>;
 /**
  * @internal
  */
-export declare const GroupByNode: Readonly<{
-    is(node: OperationNode): node is GroupByNode;
-    create(items: ReadonlyArray<GroupByItemNode>): GroupByNode;
-    cloneWithItems(groupBy: GroupByNode, items: ReadonlyArray<GroupByItemNode>): GroupByNode;
-}>;
+export declare const GroupByNode: GroupByNodeFactory;
+export {};

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

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

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

@@ -1,12 +1,14 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface IdentifierNode extends OperationNode {
     readonly kind: 'IdentifierNode';
     readonly name: string;
 }
+type IdentifierNodeFactory = Readonly<{
+    is(node: OperationNode): node is IdentifierNode;
+    create(name: string): Readonly<IdentifierNode>;
+}>;
 /**
  * @internal
  */
-export declare const IdentifierNode: Readonly<{
-    is(node: OperationNode): node is IdentifierNode;
-    create(name: string): IdentifierNode;
-}>;
+export declare const IdentifierNode: IdentifierNodeFactory;
+export {};

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

@@ -1,14 +1,14 @@
-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 { OrActionNode } from './or-action-node.js';
-import { OutputNode } from './output-node.js';
-import { ReturningNode } from './returning-node.js';
-import { TableNode } from './table-node.js';
-import { TopNode } from './top-node.js';
-import { WithNode } from './with-node.js';
+import type { ColumnNode } from './column-node.js';
+import type { ExplainNode } from './explain-node.js';
+import type { OnConflictNode } from './on-conflict-node.js';
+import type { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { OrActionNode } from './or-action-node.js';
+import type { OutputNode } from './output-node.js';
+import type { ReturningNode } from './returning-node.js';
+import type { TableNode } from './table-node.js';
+import type { TopNode } from './top-node.js';
+import type { WithNode } from './with-node.js';
 export type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
 export interface InsertQueryNode extends OperationNode {
     readonly kind: 'InsertQueryNode';
@@ -29,12 +29,14 @@ export interface InsertQueryNode extends OperationNode {
     readonly top?: TopNode;
     readonly output?: OutputNode;
 }
+type InsertQueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is InsertQueryNode;
+    create(into: TableNode, withNode?: WithNode, replace?: boolean): Readonly<InsertQueryNode>;
+    createWithoutInto(): Readonly<InsertQueryNode>;
+    cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): Readonly<InsertQueryNode>;
+}>;
 /**
  * @internal
  */
-export declare const InsertQueryNode: Readonly<{
-    is(node: OperationNode): node is InsertQueryNode;
-    create(into: TableNode, withNode?: WithNode, replace?: boolean): InsertQueryNode;
-    createWithoutInto(): InsertQueryNode;
-    cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): InsertQueryNode;
-}>;
+export declare const InsertQueryNode: InsertQueryNodeFactory;
+export {};

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

@@ -1,5 +1,5 @@
 import { OnNode } from './on-node.js';
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'CrossJoin' | 'LateralInnerJoin' | 'LateralLeftJoin' | 'LateralCrossJoin' | 'Using' | 'OuterApply' | 'CrossApply';
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
@@ -7,12 +7,14 @@ export interface JoinNode extends OperationNode {
     readonly table: OperationNode;
     readonly on?: OnNode;
 }
+type JoinNodeFactory = Readonly<{
+    is(node: OperationNode): node is JoinNode;
+    create(joinType: JoinType, table: OperationNode): Readonly<JoinNode>;
+    createWithOn(joinType: JoinType, table: OperationNode, on: OperationNode): Readonly<JoinNode>;
+    cloneWithOn(joinNode: JoinNode, operation: OperationNode): Readonly<JoinNode>;
+}>;
 /**
  * @internal
  */
-export declare const JoinNode: Readonly<{
-    is(node: OperationNode): node is JoinNode;
-    create(joinType: JoinType, table: OperationNode): JoinNode;
-    createWithOn(joinType: JoinType, table: OperationNode, on: OperationNode): JoinNode;
-    cloneWithOn(joinNode: JoinNode, operation: OperationNode): JoinNode;
-}>;
+export declare const JoinNode: JoinNodeFactory;
+export {};

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

@@ -1,16 +1,18 @@
-import { OperationNode } from './operation-node.js';
-import { OperatorNode } from './operator-node.js';
-import { ValueNode } from './value-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { OperatorNode } from './operator-node.js';
+import type { ValueNode } from './value-node.js';
 export interface JSONOperatorChainNode extends OperationNode {
     readonly kind: 'JSONOperatorChainNode';
     readonly operator: OperatorNode;
     readonly values: readonly ValueNode[];
 }
+type JSONOperatorChainNodeFactory = Readonly<{
+    is(node: OperationNode): node is JSONOperatorChainNode;
+    create(operator: OperatorNode): Readonly<JSONOperatorChainNode>;
+    cloneWithValue(node: JSONOperatorChainNode, value: ValueNode): Readonly<JSONOperatorChainNode>;
+}>;
 /**
  * @internal
  */
-export declare const JSONOperatorChainNode: Readonly<{
-    is(node: OperationNode): node is JSONOperatorChainNode;
-    create(operator: OperatorNode): JSONOperatorChainNode;
-    cloneWithValue(node: JSONOperatorChainNode, value: ValueNode): JSONOperatorChainNode;
-}>;
+export declare const JSONOperatorChainNode: JSONOperatorChainNodeFactory;
+export {};

package/dist/cjs/operation-node/json-path-leg-node.d.ts

@@ -1,14 +1,16 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export type JSONPathLegType = 'Member' | 'ArrayLocation';
 export interface JSONPathLegNode extends OperationNode {
     readonly kind: 'JSONPathLegNode';
     readonly type: JSONPathLegType;
     readonly value: string | number;
 }
+type JSONPathLegNodeFactory = Readonly<{
+    is(node: OperationNode): node is JSONPathLegNode;
+    create(type: JSONPathLegType, value: string | number): Readonly<JSONPathLegNode>;
+}>;
 /**
  * @internal
  */
-export declare const JSONPathLegNode: Readonly<{
-    is(node: OperationNode): node is JSONPathLegNode;
-    create(type: JSONPathLegType, value: string | number): JSONPathLegNode;
-}>;
+export declare const JSONPathLegNode: JSONPathLegNodeFactory;
+export {};

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

@@ -1,16 +1,18 @@
-import { JSONPathLegNode } from './json-path-leg-node.js';
-import { OperationNode } from './operation-node.js';
-import { OperatorNode } from './operator-node.js';
+import type { JSONPathLegNode } from './json-path-leg-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { OperatorNode } from './operator-node.js';
 export interface JSONPathNode extends OperationNode {
     readonly kind: 'JSONPathNode';
     readonly inOperator?: OperatorNode;
     readonly pathLegs: ReadonlyArray<JSONPathLegNode>;
 }
+type JSONPathNodeFactory = Readonly<{
+    is(node: OperationNode): node is JSONPathNode;
+    create(inOperator?: OperatorNode): Readonly<JSONPathNode>;
+    cloneWithLeg(jsonPathNode: JSONPathNode, pathLeg: JSONPathLegNode): Readonly<JSONPathNode>;
+}>;
 /**
  * @internal
  */
-export declare const JSONPathNode: Readonly<{
-    is(node: OperationNode): node is JSONPathNode;
-    create(inOperator?: OperatorNode): JSONPathNode;
-    cloneWithLeg(jsonPathNode: JSONPathNode, pathLeg: JSONPathLegNode): JSONPathNode;
-}>;
+export declare const JSONPathNode: JSONPathNodeFactory;
+export {};

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

@@ -1,17 +1,19 @@
-import { JSONOperatorChainNode } from './json-operator-chain-node.js';
-import { JSONPathNode } from './json-path-node.js';
-import { OperationNode } from './operation-node.js';
-import { ReferenceNode } from './reference-node.js';
+import type { JSONOperatorChainNode } from './json-operator-chain-node.js';
+import type { JSONPathNode } from './json-path-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ReferenceNode } from './reference-node.js';
 export interface JSONReferenceNode extends OperationNode {
     readonly kind: 'JSONReferenceNode';
     readonly reference: ReferenceNode;
     readonly traversal: JSONPathNode | JSONOperatorChainNode;
 }
+type JSONReferenceNodeFactory = Readonly<{
+    is(node: OperationNode): node is JSONReferenceNode;
+    create(reference: ReferenceNode, traversal: JSONPathNode | JSONOperatorChainNode): Readonly<JSONReferenceNode>;
+    cloneWithTraversal(node: JSONReferenceNode, traversal: JSONPathNode | JSONOperatorChainNode): Readonly<JSONReferenceNode>;
+}>;
 /**
  * @internal
  */
-export declare const JSONReferenceNode: Readonly<{
-    is(node: OperationNode): node is JSONReferenceNode;
-    create(reference: ReferenceNode, traversal: JSONPathNode | JSONOperatorChainNode): JSONReferenceNode;
-    cloneWithTraversal(node: JSONReferenceNode, traversal: JSONPathNode | JSONOperatorChainNode): JSONReferenceNode;
-}>;
+export declare const JSONReferenceNode: JSONReferenceNodeFactory;
+export {};

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

@@ -1,12 +1,14 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface LimitNode extends OperationNode {
     readonly kind: 'LimitNode';
     readonly limit: OperationNode;
 }
+type LimitNodeFactory = Readonly<{
+    is(node: OperationNode): node is LimitNode;
+    create(limit: OperationNode): Readonly<LimitNode>;
+}>;
 /**
  * @internal
  */
-export declare const LimitNode: Readonly<{
-    is(node: OperationNode): node is LimitNode;
-    create(limit: OperationNode): LimitNode;
-}>;
+export declare const LimitNode: LimitNodeFactory;
+export {};

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

@@ -1,12 +1,14 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface ListNode extends OperationNode {
     readonly kind: 'ListNode';
     readonly items: ReadonlyArray<OperationNode>;
 }
+type ListNodeFactory = Readonly<{
+    is(node: OperationNode): node is ListNode;
+    create(items: ReadonlyArray<OperationNode>): Readonly<ListNode>;
+}>;
 /**
  * @internal
  */
-export declare const ListNode: Readonly<{
-    is(node: OperationNode): node is ListNode;
-    create(items: ReadonlyArray<OperationNode>): ListNode;
-}>;
+export declare const ListNode: ListNodeFactory;
+export {};

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

@@ -1,13 +1,15 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface MatchedNode extends OperationNode {
     readonly kind: 'MatchedNode';
     readonly not: boolean;
     readonly bySource: boolean;
 }
+type MatchedNodeFactory = Readonly<{
+    is(node: OperationNode): node is MatchedNode;
+    create(not: boolean, bySource?: boolean): Readonly<MatchedNode>;
+}>;
 /**
  * @internal
  */
-export declare const MatchedNode: Readonly<{
-    is(node: OperationNode): node is MatchedNode;
-    create(not: boolean, bySource?: boolean): MatchedNode;
-}>;
+export declare const MatchedNode: MatchedNodeFactory;
+export {};

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

@@ -1,12 +1,12 @@
-import { AliasNode } from './alias-node.js';
-import { JoinNode } from './join-node.js';
-import { OperationNode } from './operation-node.js';
-import { OutputNode } from './output-node.js';
-import { ReturningNode } from './returning-node.js';
-import { TableNode } from './table-node.js';
-import { TopNode } from './top-node.js';
+import type { AliasNode } from './alias-node.js';
+import type { JoinNode } from './join-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { OutputNode } from './output-node.js';
+import type { ReturningNode } from './returning-node.js';
+import type { TableNode } from './table-node.js';
+import type { TopNode } from './top-node.js';
 import { WhenNode } from './when-node.js';
-import { WithNode } from './with-node.js';
+import type { WithNode } from './with-node.js';
 export interface MergeQueryNode extends OperationNode {
     readonly kind: 'MergeQueryNode';
     readonly into: TableNode | AliasNode;
@@ -18,13 +18,15 @@ export interface MergeQueryNode extends OperationNode {
     readonly output?: OutputNode;
     readonly endModifiers?: ReadonlyArray<OperationNode>;
 }
+type MergeQueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is MergeQueryNode;
+    create(into: TableNode | AliasNode, withNode?: WithNode): Readonly<MergeQueryNode>;
+    cloneWithUsing(mergeNode: MergeQueryNode, using: JoinNode): Readonly<MergeQueryNode>;
+    cloneWithWhen(mergeNode: MergeQueryNode, when: WhenNode): Readonly<MergeQueryNode>;
+    cloneWithThen(mergeNode: MergeQueryNode, then: OperationNode): Readonly<MergeQueryNode>;
+}>;
 /**
  * @internal
  */
-export declare const MergeQueryNode: Readonly<{
-    is(node: OperationNode): node is MergeQueryNode;
-    create(into: TableNode | AliasNode, withNode?: WithNode): MergeQueryNode;
-    cloneWithUsing(mergeNode: MergeQueryNode, using: JoinNode): MergeQueryNode;
-    cloneWithWhen(mergeNode: MergeQueryNode, when: WhenNode): MergeQueryNode;
-    cloneWithThen(mergeNode: MergeQueryNode, then: OperationNode): MergeQueryNode;
-}>;
+export declare const MergeQueryNode: MergeQueryNodeFactory;
+export {};

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

@@ -1,13 +1,15 @@
-import { ColumnDefinitionNode } from './column-definition-node.js';
-import { OperationNode } from './operation-node.js';
+import type { ColumnDefinitionNode } from './column-definition-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface ModifyColumnNode extends OperationNode {
     readonly kind: 'ModifyColumnNode';
     readonly column: ColumnDefinitionNode;
 }
+type ModifyColumnNodeFactory = Readonly<{
+    is(node: OperationNode): node is ModifyColumnNode;
+    create(column: ColumnDefinitionNode): Readonly<ModifyColumnNode>;
+}>;
 /**
  * @internal
  */
-export declare const ModifyColumnNode: Readonly<{
-    is(node: OperationNode): node is ModifyColumnNode;
-    create(column: ColumnDefinitionNode): ModifyColumnNode;
-}>;
+export declare const ModifyColumnNode: ModifyColumnNodeFactory;
+export {};

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

@@ -1,12 +1,14 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface OffsetNode extends OperationNode {
     readonly kind: 'OffsetNode';
     readonly offset: OperationNode;
 }
+type OffsetNodeFactory = Readonly<{
+    is(node: OperationNode): node is OffsetNode;
+    create(offset: OperationNode): Readonly<OffsetNode>;
+}>;
 /**
  * @internal
  */
-export declare const OffsetNode: Readonly<{
-    is(node: OperationNode): node is OffsetNode;
-    create(offset: OperationNode): OffsetNode;
-}>;
+export declare const OffsetNode: OffsetNodeFactory;
+export {};

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

@@ -1,7 +1,7 @@
-import { ColumnNode } from './column-node.js';
-import { ColumnUpdateNode } from './column-update-node.js';
-import { IdentifierNode } from './identifier-node.js';
-import { OperationNode } from './operation-node.js';
+import type { ColumnNode } from './column-node.js';
+import type { ColumnUpdateNode } from './column-update-node.js';
+import type { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
 import { WhereNode } from './where-node.js';
 export type OnConflictNodeProps = Omit<OnConflictNode, 'kind' | 'indexWhere' | 'updateWhere'>;
 export interface OnConflictNode extends OperationNode {
@@ -14,17 +14,19 @@ export interface OnConflictNode extends OperationNode {
     readonly updateWhere?: WhereNode;
     readonly doNothing?: boolean;
 }
+type OnConflictNodeFactory = Readonly<{
+    is(node: OperationNode): node is OnConflictNode;
+    create(): Readonly<OnConflictNode>;
+    cloneWith(node: OnConflictNode, props: OnConflictNodeProps): Readonly<OnConflictNode>;
+    cloneWithIndexWhere(node: OnConflictNode, operation: OperationNode): Readonly<OnConflictNode>;
+    cloneWithIndexOrWhere(node: OnConflictNode, operation: OperationNode): Readonly<OnConflictNode>;
+    cloneWithUpdateWhere(node: OnConflictNode, operation: OperationNode): Readonly<OnConflictNode>;
+    cloneWithUpdateOrWhere(node: OnConflictNode, operation: OperationNode): Readonly<OnConflictNode>;
+    cloneWithoutIndexWhere(node: OnConflictNode): Readonly<OnConflictNode>;
+    cloneWithoutUpdateWhere(node: OnConflictNode): Readonly<OnConflictNode>;
+}>;
 /**
  * @internal
  */
-export declare const OnConflictNode: Readonly<{
-    is(node: OperationNode): node is OnConflictNode;
-    create(): OnConflictNode;
-    cloneWith(node: OnConflictNode, props: OnConflictNodeProps): 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;
-    cloneWithoutIndexWhere(node: OnConflictNode): OnConflictNode;
-    cloneWithoutUpdateWhere(node: OnConflictNode): OnConflictNode;
-}>;
+export declare const OnConflictNode: OnConflictNodeFactory;
+export {};