kysely 0.28.8 → 0.28.9

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

@@ -1,8 +1,8 @@
-import { ColumnNode } from './column-node.js';
-import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
+import type { ColumnNode } from './column-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { RawNode } from './raw-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
-import { SelectQueryNode } from './select-query-node.js';
+import type { SelectQueryNode } from './select-query-node.js';
 export type CreateViewNodeParams = Omit<Partial<CreateViewNode>, 'kind' | 'name'>;
 export interface CreateViewNode extends OperationNode {
     readonly kind: 'CreateViewNode';
@@ -14,11 +14,13 @@ export interface CreateViewNode extends OperationNode {
     readonly columns?: ReadonlyArray<ColumnNode>;
     readonly as?: SelectQueryNode | RawNode;
 }
+type CreateViewNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateViewNode;
+    create(name: string): Readonly<CreateViewNode>;
+    cloneWith(createView: CreateViewNode, params: CreateViewNodeParams): Readonly<CreateViewNode>;
+}>;
 /**
  * @internal
  */
-export declare const CreateViewNode: Readonly<{
-    is(node: OperationNode): node is CreateViewNode;
-    create(name: string): CreateViewNode;
-    cloneWith(createView: CreateViewNode, params: CreateViewNodeParams): CreateViewNode;
-}>;
+export declare const CreateViewNode: CreateViewNodeFactory;
+export {};

package/dist/esm/operation-node/data-type-node.d.ts

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 declare const SIMPLE_COLUMN_DATA_TYPES: readonly ["varchar", "char", "text", "integer", "int2", "int4", "int8", "smallint", "bigint", "boolean", "real", "double precision", "float4", "float8", "decimal", "numeric", "binary", "bytea", "date", "datetime", "time", "timetz", "timestamp", "timestamptz", "serial", "bigserial", "uuid", "json", "jsonb", "blob", "varbinary", "int4range", "int4multirange", "int8range", "int8multirange", "numrange", "nummultirange", "tsrange", "tsmultirange", "tstzrange", "tstzmultirange", "daterange", "datemultirange"];
 type SimpleColumnDataType = (typeof SIMPLE_COLUMN_DATA_TYPES)[number];
 export type ColumnDataType = SimpleColumnDataType | `varchar(${number})` | `char(${number})` | `decimal(${number}, ${number})` | `numeric(${number}, ${number})` | `binary(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`;
@@ -7,12 +7,13 @@ export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';
     readonly dataType: ColumnDataType;
 }
+type DataTypeNodeFactory = Readonly<{
+    is(node: OperationNode): node is DataTypeNode;
+    create(dataType: ColumnDataType): Readonly<DataTypeNode>;
+}>;
 /**
  * @internal
  */
-export declare const DataTypeNode: Readonly<{
-    is(node: OperationNode): node is DataTypeNode;
-    create(dataType: ColumnDataType): DataTypeNode;
-}>;
+export declare const DataTypeNode: DataTypeNodeFactory;
 export declare function isColumnDataType(dataType: string): dataType is ColumnDataType;
 export {};

package/dist/esm/operation-node/default-insert-value-node.d.ts

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

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

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

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

@@ -1,16 +1,16 @@
 import { FromNode } from './from-node.js';
-import { JoinNode } from './join-node.js';
-import { OperationNode } from './operation-node.js';
-import { ReturningNode } from './returning-node.js';
-import { WhereNode } from './where-node.js';
-import { WithNode } from './with-node.js';
-import { LimitNode } from './limit-node.js';
-import { OrderByNode } from './order-by-node.js';
-import { OrderByItemNode } from './order-by-item-node.js';
-import { ExplainNode } from './explain-node.js';
+import type { JoinNode } from './join-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ReturningNode } from './returning-node.js';
+import type { WhereNode } from './where-node.js';
+import type { WithNode } from './with-node.js';
+import type { LimitNode } from './limit-node.js';
+import type { OrderByNode } from './order-by-node.js';
+import type { OrderByItemNode } from './order-by-item-node.js';
+import type { ExplainNode } from './explain-node.js';
 import { UsingNode } from './using-node.js';
-import { TopNode } from './top-node.js';
-import { OutputNode } from './output-node.js';
+import type { TopNode } from './top-node.js';
+import type { OutputNode } from './output-node.js';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
@@ -26,21 +26,17 @@ export interface DeleteQueryNode extends OperationNode {
     readonly top?: TopNode;
     readonly output?: OutputNode;
 }
+type DeleteQueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is DeleteQueryNode;
+    create(fromItems: OperationNode[], withNode?: WithNode): Readonly<DeleteQueryNode>;
+    cloneWithOrderByItems(node: DeleteQueryNode, items: ReadonlyArray<OrderByItemNode>): Readonly<DeleteQueryNode>;
+    cloneWithoutOrderBy(node: DeleteQueryNode): Readonly<DeleteQueryNode>;
+    cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): Readonly<DeleteQueryNode>;
+    cloneWithoutLimit(deleteNode: DeleteQueryNode): Readonly<DeleteQueryNode>;
+    cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): Readonly<DeleteQueryNode>;
+}>;
 /**
  * @internal
  */
-export declare const DeleteQueryNode: Readonly<{
-    is(node: OperationNode): node is DeleteQueryNode;
-    create(fromItems: OperationNode[], withNode?: WithNode): DeleteQueryNode;
-    /**
-     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
-     */
-    cloneWithOrderByItems: (node: DeleteQueryNode, items: ReadonlyArray<OrderByItemNode>) => DeleteQueryNode;
-    /**
-     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
-     */
-    cloneWithoutOrderBy: (node: DeleteQueryNode) => DeleteQueryNode;
-    cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
-    cloneWithoutLimit(deleteNode: DeleteQueryNode): DeleteQueryNode;
-    cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;
-}>;
+export declare const DeleteQueryNode: DeleteQueryNodeFactory;
+export {};

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

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

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

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

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

@@ -1,6 +1,6 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
-import { TableNode } from './table-node.js';
+import type { TableNode } from './table-node.js';
 export type DropIndexNodeProps = Omit<DropIndexNode, 'kind' | 'name'>;
 export interface DropIndexNode extends OperationNode {
     readonly kind: 'DropIndexNode';
@@ -9,11 +9,13 @@ export interface DropIndexNode extends OperationNode {
     readonly ifExists?: boolean;
     readonly cascade?: boolean;
 }
+type DropIndexNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropIndexNode;
+    create(name: string, params?: DropIndexNodeProps): Readonly<DropIndexNode>;
+    cloneWith(dropIndex: DropIndexNode, props: DropIndexNodeProps): Readonly<DropIndexNode>;
+}>;
 /**
  * @internal
  */
-export declare const DropIndexNode: Readonly<{
-    is(node: OperationNode): node is DropIndexNode;
-    create(name: string, params?: DropIndexNodeProps): DropIndexNode;
-    cloneWith(dropIndex: DropIndexNode, props: DropIndexNodeProps): DropIndexNode;
-}>;
+export declare const DropIndexNode: DropIndexNodeFactory;
+export {};

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

@@ -1,5 +1,5 @@
 import { IdentifierNode } from './identifier-node.js';
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export type DropSchemaNodeParams = Omit<Partial<DropSchemaNode>, 'kind' | 'schema'>;
 export interface DropSchemaNode extends OperationNode {
     readonly kind: 'DropSchemaNode';
@@ -7,11 +7,13 @@ export interface DropSchemaNode extends OperationNode {
     readonly ifExists?: boolean;
     readonly cascade?: boolean;
 }
+type DropSchemaNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropSchemaNode;
+    create(schema: string, params?: DropSchemaNodeParams): Readonly<DropSchemaNode>;
+    cloneWith(dropSchema: DropSchemaNode, params: DropSchemaNodeParams): Readonly<DropSchemaNode>;
+}>;
 /**
  * @internal
  */
-export declare const DropSchemaNode: Readonly<{
-    is(node: OperationNode): node is DropSchemaNode;
-    create(schema: string, params?: DropSchemaNodeParams): DropSchemaNode;
-    cloneWith(dropSchema: DropSchemaNode, params: DropSchemaNodeParams): DropSchemaNode;
-}>;
+export declare const DropSchemaNode: DropSchemaNodeFactory;
+export {};

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

@@ -1,5 +1,5 @@
-import { OperationNode } from './operation-node.js';
-import { TableNode } from './table-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { TableNode } from './table-node.js';
 export type DropTablexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
 export interface DropTableNode extends OperationNode {
     readonly kind: 'DropTableNode';
@@ -7,11 +7,13 @@ export interface DropTableNode extends OperationNode {
     readonly ifExists?: boolean;
     readonly cascade?: boolean;
 }
+type DropTableNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropTableNode;
+    create(table: TableNode, params?: DropTablexNodeParams): Readonly<DropTableNode>;
+    cloneWith(dropIndex: DropTableNode, params: DropTablexNodeParams): Readonly<DropTableNode>;
+}>;
 /**
  * @internal
  */
-export declare const DropTableNode: Readonly<{
-    is(node: OperationNode): node is DropTableNode;
-    create(table: TableNode, params?: DropTablexNodeParams): DropTableNode;
-    cloneWith(dropIndex: DropTableNode, params: DropTablexNodeParams): DropTableNode;
-}>;
+export declare const DropTableNode: DropTableNodeFactory;
+export {};

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

@@ -1,16 +1,18 @@
-import { OperationNode } from './operation-node.js';
-import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { SchemableIdentifierNode } from './schemable-identifier-node.js';
 export type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name'>;
 export interface DropTypeNode extends OperationNode {
     readonly kind: 'DropTypeNode';
     readonly name: SchemableIdentifierNode;
     readonly ifExists?: boolean;
 }
+type DropTypeNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropTypeNode;
+    create(name: SchemableIdentifierNode): Readonly<DropTypeNode>;
+    cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): Readonly<DropTypeNode>;
+}>;
 /**
  * @internal
  */
-export declare const DropTypeNode: Readonly<{
-    is(node: OperationNode): node is DropTypeNode;
-    create(name: SchemableIdentifierNode): DropTypeNode;
-    cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): DropTypeNode;
-}>;
+export declare const DropTypeNode: DropTypeNodeFactory;
+export {};

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

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 export type DropViewNodeParams = Omit<Partial<DropViewNode>, 'kind' | 'name'>;
 export interface DropViewNode extends OperationNode {
@@ -8,11 +8,13 @@ export interface DropViewNode extends OperationNode {
     readonly materialized?: boolean;
     readonly cascade?: boolean;
 }
+type DropViewNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropViewNode;
+    create(name: string): Readonly<DropViewNode>;
+    cloneWith(dropView: DropViewNode, params: DropViewNodeParams): Readonly<DropViewNode>;
+}>;
 /**
  * @internal
  */
-export declare const DropViewNode: Readonly<{
-    is(node: OperationNode): node is DropViewNode;
-    create(name: string): DropViewNode;
-    cloneWith(dropView: DropViewNode, params: DropViewNodeParams): DropViewNode;
-}>;
+export declare const DropViewNode: DropViewNodeFactory;
+export {};

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

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

package/dist/esm/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/esm/operation-node/fetch-node.js

@@ -1,9 +1,10 @@
 /// <reference types="./fetch-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
 import { ValueNode } from './value-node.js';
 /**
  * @internal
  */
-export const FetchNode = {
+export const FetchNode = freeze({
     is(node) {
         return node.kind === 'FetchNode';
     },
@@ -14,4 +15,4 @@ export const FetchNode = {
             modifier,
         };
     },
-};
+});

package/dist/esm/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/esm/operation-node/foreign-key-constraint-node.js

@@ -1,7 +1,7 @@
 /// <reference types="./foreign-key-constraint-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 import { IdentifierNode } from './identifier-node.js';
-import { ReferencesNode } from './references-node.js';
+import { ReferencesNode, } from './references-node.js';
 /**
  * @internal
  */
@@ -14,7 +14,9 @@ export const ForeignKeyConstraintNode = freeze({
             kind: 'ForeignKeyConstraintNode',
             columns: sourceColumns,
             references: ReferencesNode.create(targetTable, targetColumns),
-            name: constraintName ? IdentifierNode.create(constraintName) : undefined,
+            name: constraintName
+                ? IdentifierNode.create(constraintName)
+                : undefined,
         });
     },
     cloneWith(node, props) {

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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 {};