kysely 0.28.8 → 0.28.9

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

package/dist/cjs/operation-node/on-duplicate-key-node.d.ts

@@ -1,14 +1,16 @@
-import { ColumnUpdateNode } from './column-update-node.js';
-import { OperationNode } from './operation-node.js';
+import type { ColumnUpdateNode } from './column-update-node.js';
+import type { OperationNode } from './operation-node.js';
 export type OnDuplicateKeyNodeProps = Omit<OnDuplicateKeyNode, 'kind'>;
 export interface OnDuplicateKeyNode extends OperationNode {
     readonly kind: 'OnDuplicateKeyNode';
     readonly updates: ReadonlyArray<ColumnUpdateNode>;
 }
+type OnDuplicateKeyNodeFactory = Readonly<{
+    is(node: OperationNode): node is OnDuplicateKeyNode;
+    create(updates: ReadonlyArray<ColumnUpdateNode>): Readonly<OnDuplicateKeyNode>;
+}>;
 /**
  * @internal
  */
-export declare const OnDuplicateKeyNode: Readonly<{
-    is(node: OperationNode): node is OnDuplicateKeyNode;
-    create(updates: ReadonlyArray<ColumnUpdateNode>): OnDuplicateKeyNode;
-}>;
+export declare const OnDuplicateKeyNode: OnDuplicateKeyNodeFactory;
+export {};

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

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

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

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface OperationNodeSource {
     toOperationNode(): OperationNode;
 }