kysely 0.28.7 → 0.28.9

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

@@ -1,16 +1,18 @@
 import { IdentifierNode } from './identifier-node.js';
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export type CreateSchemaNodeParams = Omit<Partial<CreateSchemaNode>, 'kind' | 'schema'>;
 export interface CreateSchemaNode extends OperationNode {
     readonly kind: 'CreateSchemaNode';
     readonly schema: IdentifierNode;
     readonly ifNotExists?: boolean;
 }
+type CreateSchemaNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateSchemaNode;
+    create(schema: string, params?: CreateSchemaNodeParams): Readonly<CreateSchemaNode>;
+    cloneWith(createSchema: CreateSchemaNode, params: CreateSchemaNodeParams): Readonly<CreateSchemaNode>;
+}>;
 /**
  * @internal
  */
-export declare const CreateSchemaNode: Readonly<{
-    is(node: OperationNode): node is CreateSchemaNode;
-    create(schema: string, params?: CreateSchemaNodeParams): CreateSchemaNode;
-    cloneWith(createSchema: CreateSchemaNode, params: CreateSchemaNodeParams): CreateSchemaNode;
-}>;
+export declare const CreateSchemaNode: CreateSchemaNodeFactory;
+export {};

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

@@ -1,8 +1,8 @@
-import { OperationNode } from './operation-node.js';
-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 type { OperationNode } from './operation-node.js';
+import type { TableNode } from './table-node.js';
+import type { ConstraintNode } from './constraint-node.js';
+import type { ColumnDefinitionNode } from './column-definition-node.js';
+import type { ArrayItemType } from '../util/type-utils.js';
 export declare const ON_COMMIT_ACTIONS: string[];
 export type OnCommitAction = ArrayItemType<typeof ON_COMMIT_ACTIONS>;
 export type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints' | 'frontModifiers' | 'endModifiers'>;
@@ -18,15 +18,17 @@ export interface CreateTableNode extends OperationNode {
     readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly selectQuery?: OperationNode;
 }
+type CreateTableNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateTableNode;
+    create(table: TableNode): Readonly<CreateTableNode>;
+    cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): Readonly<CreateTableNode>;
+    cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): Readonly<CreateTableNode>;
+    cloneWithFrontModifier(createTable: CreateTableNode, modifier: OperationNode): Readonly<CreateTableNode>;
+    cloneWithEndModifier(createTable: CreateTableNode, modifier: OperationNode): Readonly<CreateTableNode>;
+    cloneWith(createTable: CreateTableNode, params: CreateTableNodeParams): Readonly<CreateTableNode>;
+}>;
 /**
  * @internal
  */
-export declare const CreateTableNode: Readonly<{
-    is(node: OperationNode): node is CreateTableNode;
-    create(table: TableNode): CreateTableNode;
-    cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
-    cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): CreateTableNode;
-    cloneWithFrontModifier(createTable: CreateTableNode, modifier: OperationNode): CreateTableNode;
-    cloneWithEndModifier(createTable: CreateTableNode, modifier: OperationNode): CreateTableNode;
-    cloneWith(createTable: CreateTableNode, params: CreateTableNodeParams): CreateTableNode;
-}>;
+export declare const CreateTableNode: CreateTableNodeFactory;
+export {};

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

@@ -1,5 +1,5 @@
-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';
 import { ValueListNode } from './value-list-node.js';
 export type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
 export interface CreateTypeNode extends OperationNode {
@@ -7,11 +7,13 @@ export interface CreateTypeNode extends OperationNode {
     readonly name: SchemableIdentifierNode;
     readonly enum?: ValueListNode;
 }
+type CreateTypeNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateTypeNode;
+    create(name: SchemableIdentifierNode): Readonly<CreateTypeNode>;
+    cloneWithEnum(createType: CreateTypeNode, values: readonly string[]): Readonly<CreateTypeNode>;
+}>;
 /**
  * @internal
  */
-export declare const CreateTypeNode: Readonly<{
-    is(node: OperationNode): node is CreateTypeNode;
-    create(name: SchemableIdentifierNode): CreateTypeNode;
-    cloneWithEnum(createType: CreateTypeNode, values: readonly string[]): CreateTypeNode;
-}>;
+export declare const CreateTypeNode: CreateTypeNodeFactory;
+export {};

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