kysely 0.28.7 → 0.28.9

package/dist/esm/operation-node/partition-by-item-node.d.ts

@@ -1,13 +1,15 @@
-import { OperationNode } from './operation-node.js';
-import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
 export interface PartitionByItemNode extends OperationNode {
     readonly kind: 'PartitionByItemNode';
     readonly partitionBy: SimpleReferenceExpressionNode;
 }
+type PartitionByItemNodeFactory = Readonly<{
+    is(node: OperationNode): node is PartitionByItemNode;
+    create(partitionBy: SimpleReferenceExpressionNode): Readonly<PartitionByItemNode>;
+}>;
 /**
  * @internal
  */
-export declare const PartitionByItemNode: Readonly<{
-    is(node: OperationNode): node is PartitionByItemNode;
-    create(partitionBy: SimpleReferenceExpressionNode): PartitionByItemNode;
-}>;
+export declare const PartitionByItemNode: PartitionByItemNodeFactory;
+export {};

package/dist/esm/operation-node/partition-by-node.d.ts

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

package/dist/esm/operation-node/primary-key-constraint-node.d.ts

@@ -1,6 +1,6 @@
 import { ColumnNode } from './column-node.js';
 import { IdentifierNode } from './identifier-node.js';
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface PrimaryKeyConstraintNode extends OperationNode {
     readonly kind: 'PrimaryKeyConstraintNode';
     readonly columns: ReadonlyArray<ColumnNode>;
@@ -9,14 +9,15 @@ export interface PrimaryKeyConstraintNode extends OperationNode {
     readonly initiallyDeferred?: boolean;
 }
 export type PrimaryKeyConstraintNodeProps = Omit<Partial<PrimaryKeyConstraintNode>, 'kind'>;
+type PrimaryKeyConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is PrimaryKeyConstraintNode;
+    create(columns: string[], constraintName?: string): Readonly<PrimaryKeyConstraintNode>;
+    cloneWith(node: PrimaryKeyConstraintNode, props: PrimaryKeyConstraintNodeProps): Readonly<PrimaryKeyConstraintNode>;
+}>;
 /**
  * @internal
  */
-export declare const PrimaryKeyConstraintNode: Readonly<{
-    is(node: OperationNode): node is PrimaryKeyConstraintNode;
-    create(columns: string[], constraintName?: string): PrimaryKeyConstraintNode;
-    cloneWith(node: PrimaryKeyConstraintNode, props: PrimaryKeyConstraintNodeProps): PrimaryKeyConstraintNode;
-}>;
+export declare const PrimaryKeyConstraintNode: PrimaryKeyConstraintNodeFactory;
 /**
  * Backwards compatibility for a typo in the codebase.
  *
@@ -24,6 +25,7 @@ export declare const PrimaryKeyConstraintNode: Readonly<{
  */
 export declare const PrimaryConstraintNode: Readonly<{
     is(node: OperationNode): node is PrimaryKeyConstraintNode;
-    create(columns: string[], constraintName?: string): PrimaryKeyConstraintNode;
-    cloneWith(node: PrimaryKeyConstraintNode, props: PrimaryKeyConstraintNodeProps): PrimaryKeyConstraintNode;
+    create(columns: string[], constraintName?: string): Readonly<PrimaryKeyConstraintNode>;
+    cloneWith(node: PrimaryKeyConstraintNode, props: PrimaryKeyConstraintNodeProps): Readonly<PrimaryKeyConstraintNode>;
 }>;
+export {};

package/dist/esm/operation-node/primary-key-constraint-node.js

@@ -13,7 +13,9 @@ export const PrimaryKeyConstraintNode = freeze({
         return freeze({
             kind: 'PrimaryKeyConstraintNode',
             columns: freeze(columns.map(ColumnNode.create)),
-            name: constraintName ? IdentifierNode.create(constraintName) : undefined,
+            name: constraintName
+                ? IdentifierNode.create(constraintName)
+                : undefined,
         });
     },
     cloneWith(node, props) {

package/dist/esm/operation-node/primitive-value-list-node.d.ts

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 /**
  * This node is basically just a performance optimization over the normal ValueListNode.
  * The queries often contain large arrays of primitive values (for example in a `where in` list)
@@ -8,10 +8,12 @@ export interface PrimitiveValueListNode extends OperationNode {
     readonly kind: 'PrimitiveValueListNode';
     readonly values: ReadonlyArray<unknown>;
 }
+type PrimitiveValueListNodeFactory = Readonly<{
+    is(node: OperationNode): node is PrimitiveValueListNode;
+    create(values: ReadonlyArray<unknown>): Readonly<PrimitiveValueListNode>;
+}>;
 /**
  * @internal
  */
-export declare const PrimitiveValueListNode: Readonly<{
-    is(node: OperationNode): node is PrimitiveValueListNode;
-    create(values: ReadonlyArray<unknown>): PrimitiveValueListNode;
-}>;
+export declare const PrimitiveValueListNode: PrimitiveValueListNodeFactory;
+export {};

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

@@ -3,18 +3,18 @@ import { SelectQueryNode } from './select-query-node.js';
 import { UpdateQueryNode } from './update-query-node.js';
 import { DeleteQueryNode } from './delete-query-node.js';
 import { WhereNode } from './where-node.js';
-import { JoinNode } from './join-node.js';
-import { SelectionNode } from './selection-node.js';
+import type { JoinNode } from './join-node.js';
+import type { SelectionNode } from './selection-node.js';
 import { ReturningNode } from './returning-node.js';
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { ExplainNode } from './explain-node.js';
-import { ExplainFormat } from '../util/explainable.js';
-import { Expression } from '../expression/expression.js';
+import type { ExplainFormat } from '../util/explainable.js';
+import type { Expression } from '../expression/expression.js';
 import { MergeQueryNode } from './merge-query-node.js';
-import { TopNode } from './top-node.js';
+import type { TopNode } from './top-node.js';
 import { OutputNode } from './output-node.js';
 import { OrderByNode } from './order-by-node.js';
-import { OrderByItemNode } from './order-by-item-node.js';
+import type { OrderByItemNode } from './order-by-item-node.js';
 export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode | MergeQueryNode;
 type HasJoins = {
     joins?: ReadonlyArray<JoinNode>;
@@ -40,21 +40,22 @@ type HasEndModifiers = {
 type HasOrderBy = {
     orderBy?: OrderByNode;
 };
+type QueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is QueryNode;
+    cloneWithEndModifier<T extends HasEndModifiers>(node: T, modifier: OperationNode): Readonly<T>;
+    cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): Readonly<T>;
+    cloneWithJoin<T extends HasJoins>(node: T, join: JoinNode): Readonly<T>;
+    cloneWithReturning<T extends HasReturning>(node: T, selections: ReadonlyArray<SelectionNode>): Readonly<T>;
+    cloneWithoutReturning<T extends HasReturning>(node: T): Readonly<T>;
+    cloneWithoutWhere<T extends HasWhere>(node: T): Readonly<T>;
+    cloneWithExplain<T extends HasExplain>(node: T, format: ExplainFormat | undefined, options: Expression<any> | undefined): Readonly<T>;
+    cloneWithTop<T extends HasTop>(node: T, top: TopNode): Readonly<T>;
+    cloneWithOutput<T extends HasOutput>(node: T, selections: ReadonlyArray<SelectionNode>): Readonly<T>;
+    cloneWithOrderByItems<T extends HasOrderBy>(node: T, items: ReadonlyArray<OrderByItemNode>): Readonly<T>;
+    cloneWithoutOrderBy<T extends HasOrderBy>(node: T): Readonly<T>;
+}>;
 /**
  * @internal
  */
-export declare const QueryNode: Readonly<{
-    is(node: OperationNode): node is QueryNode;
-    cloneWithEndModifier<T extends HasEndModifiers>(node: T, modifier: OperationNode): T;
-    cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): T;
-    cloneWithJoin<T extends HasJoins>(node: T, join: JoinNode): T;
-    cloneWithReturning<T extends HasReturning>(node: T, selections: ReadonlyArray<SelectionNode>): T;
-    cloneWithoutReturning<T extends HasReturning>(node: T): T;
-    cloneWithoutWhere<T extends HasWhere>(node: T): T;
-    cloneWithExplain<T extends HasExplain>(node: T, format: ExplainFormat | undefined, options: Expression<any> | undefined): T;
-    cloneWithTop<T extends HasTop>(node: T, top: TopNode): T;
-    cloneWithOutput<T extends HasOutput>(node: T, selections: ReadonlyArray<SelectionNode>): T;
-    cloneWithOrderByItems<T extends HasOrderBy>(node: T, items: ReadonlyArray<OrderByItemNode>): T;
-    cloneWithoutOrderBy<T extends HasOrderBy>(node: T): T;
-}>;
+export declare const QueryNode: QueryNodeFactory;
 export {};

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

@@ -1,16 +1,18 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface RawNode extends OperationNode {
     readonly kind: 'RawNode';
     readonly sqlFragments: ReadonlyArray<string>;
     readonly parameters: ReadonlyArray<OperationNode>;
 }
+type RawNodeFactory = Readonly<{
+    is(node: OperationNode): node is RawNode;
+    create(sqlFragments: ReadonlyArray<string>, parameters: ReadonlyArray<OperationNode>): Readonly<RawNode>;
+    createWithSql(sql: string): Readonly<RawNode>;
+    createWithChild(child: OperationNode): Readonly<RawNode>;
+    createWithChildren(children: ReadonlyArray<OperationNode>): Readonly<RawNode>;
+}>;
 /**
  * @internal
  */
-export declare const RawNode: Readonly<{
-    is(node: OperationNode): node is RawNode;
-    create(sqlFragments: ReadonlyArray<string>, parameters: ReadonlyArray<OperationNode>): RawNode;
-    createWithSql(sql: string): RawNode;
-    createWithChild(child: OperationNode): RawNode;
-    createWithChildren(children: ReadonlyArray<OperationNode>): RawNode;
-}>;
+export declare const RawNode: RawNodeFactory;
+export {};

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

@@ -1,17 +1,19 @@
-import { OperationNode } from './operation-node.js';
-import { ColumnNode } from './column-node.js';
-import { TableNode } from './table-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ColumnNode } from './column-node.js';
+import type { TableNode } from './table-node.js';
 import { SelectAllNode } from './select-all-node.js';
 export interface ReferenceNode extends OperationNode {
     readonly kind: 'ReferenceNode';
     readonly column: ColumnNode | SelectAllNode;
     readonly table?: TableNode;
 }
+type ReferenceNodeFactory = Readonly<{
+    is(node: OperationNode): node is ReferenceNode;
+    create(column: ColumnNode, table?: TableNode): Readonly<ReferenceNode>;
+    createSelectAll(table: TableNode): Readonly<ReferenceNode>;
+}>;
 /**
  * @internal
  */
-export declare const ReferenceNode: Readonly<{
-    is(node: OperationNode): node is ReferenceNode;
-    create(column: ColumnNode, table?: TableNode): ReferenceNode;
-    createSelectAll(table: TableNode): ReferenceNode;
-}>;
+export declare const ReferenceNode: ReferenceNodeFactory;
+export {};

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

@@ -1,7 +1,7 @@
-import { OperationNode } from './operation-node.js';
-import { ColumnNode } from './column-node.js';
-import { TableNode } from './table-node.js';
-import { ArrayItemType } from '../util/type-utils.js';
+import type { OperationNode } from './operation-node.js';
+import type { ColumnNode } from './column-node.js';
+import type { TableNode } from './table-node.js';
+import type { ArrayItemType } from '../util/type-utils.js';
 export declare const ON_MODIFY_FOREIGN_ACTIONS: readonly ["no action", "restrict", "cascade", "set null", "set default"];
 export type OnModifyForeignAction = ArrayItemType<typeof ON_MODIFY_FOREIGN_ACTIONS>;
 export interface ReferencesNode extends OperationNode {
@@ -11,12 +11,14 @@ export interface ReferencesNode extends OperationNode {
     readonly onDelete?: OnModifyForeignAction;
     readonly onUpdate?: OnModifyForeignAction;
 }
+type ReferencesNodeFactory = Readonly<{
+    is(node: OperationNode): node is ReferencesNode;
+    create(table: TableNode, columns: ReadonlyArray<ColumnNode>): Readonly<ReferencesNode>;
+    cloneWithOnDelete(references: ReferencesNode, onDelete: OnModifyForeignAction): Readonly<ReferencesNode>;
+    cloneWithOnUpdate(references: ReferencesNode, onUpdate: OnModifyForeignAction): Readonly<ReferencesNode>;
+}>;
 /**
  * @internal
  */
-export declare const ReferencesNode: Readonly<{
-    is(node: OperationNode): node is ReferencesNode;
-    create(table: TableNode, columns: ReadonlyArray<ColumnNode>): ReferencesNode;
-    cloneWithOnDelete(references: ReferencesNode, onDelete: OnModifyForeignAction): ReferencesNode;
-    cloneWithOnUpdate(references: ReferencesNode, onUpdate: OnModifyForeignAction): ReferencesNode;
-}>;
+export declare const ReferencesNode: ReferencesNodeFactory;
+export {};

package/dist/esm/operation-node/refresh-materialized-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 RefreshMaterializedViewNodeParams = Omit<Partial<RefreshMaterializedViewNode>, 'kind' | 'name'>;
 export interface RefreshMaterializedViewNode extends OperationNode {
@@ -7,11 +7,13 @@ export interface RefreshMaterializedViewNode extends OperationNode {
     readonly concurrently?: boolean;
     readonly withNoData?: boolean;
 }
+type RefreshMaterializedViewNodeFactory = Readonly<{
+    is(node: OperationNode): node is RefreshMaterializedViewNode;
+    create(name: string): Readonly<RefreshMaterializedViewNode>;
+    cloneWith(createView: RefreshMaterializedViewNode, params: RefreshMaterializedViewNodeParams): Readonly<RefreshMaterializedViewNode>;
+}>;
 /**
  * @internal
  */
-export declare const RefreshMaterializedViewNode: Readonly<{
-    is(node: OperationNode): node is RefreshMaterializedViewNode;
-    create(name: string): RefreshMaterializedViewNode;
-    cloneWith(createView: RefreshMaterializedViewNode, params: RefreshMaterializedViewNodeParams): RefreshMaterializedViewNode;
-}>;
+export declare const RefreshMaterializedViewNode: RefreshMaterializedViewNodeFactory;
+export {};

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

@@ -1,14 +1,16 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
 export interface RenameColumnNode extends OperationNode {
     readonly kind: 'RenameColumnNode';
     readonly column: ColumnNode;
     readonly renameTo: ColumnNode;
 }
+type RenameColumnNodeFactory = Readonly<{
+    is(node: OperationNode): node is RenameColumnNode;
+    create(column: string, newColumn: string): Readonly<RenameColumnNode>;
+}>;
 /**
  * @internal
  */
-export declare const RenameColumnNode: Readonly<{
-    is(node: OperationNode): node is RenameColumnNode;
-    create(column: string, newColumn: string): RenameColumnNode;
-}>;
+export declare const RenameColumnNode: RenameColumnNodeFactory;
+export {};

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

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

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

@@ -1,14 +1,16 @@
-import { OperationNode } from './operation-node.js';
-import { SelectionNode } from './selection-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { SelectionNode } from './selection-node.js';
 export interface ReturningNode extends OperationNode {
     readonly kind: 'ReturningNode';
     readonly selections: ReadonlyArray<SelectionNode>;
 }
+type ReturningNodeFactory = Readonly<{
+    is(node: OperationNode): node is ReturningNode;
+    create(selections: ReadonlyArray<SelectionNode>): Readonly<ReturningNode>;
+    cloneWithSelections(returning: ReturningNode, selections: ReadonlyArray<SelectionNode>): Readonly<ReturningNode>;
+}>;
 /**
  * @internal
  */
-export declare const ReturningNode: Readonly<{
-    is(node: OperationNode): node is ReturningNode;
-    create(selections: ReadonlyArray<SelectionNode>): ReturningNode;
-    cloneWithSelections(returning: ReturningNode, selections: ReadonlyArray<SelectionNode>): ReturningNode;
-}>;
+export declare const ReturningNode: ReturningNodeFactory;
+export {};

package/dist/esm/operation-node/schemable-identifier-node.d.ts

@@ -1,15 +1,17 @@
 import { IdentifierNode } from './identifier-node.js';
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface SchemableIdentifierNode extends OperationNode {
     readonly kind: 'SchemableIdentifierNode';
     readonly schema?: IdentifierNode;
     readonly identifier: IdentifierNode;
 }
+type SchemableIdentifierNodeFactory = Readonly<{
+    is(node: OperationNode): node is SchemableIdentifierNode;
+    create(identifier: string): Readonly<SchemableIdentifierNode>;
+    createWithSchema(schema: string, identifier: string): Readonly<SchemableIdentifierNode>;
+}>;
 /**
  * @internal
  */
-export declare const SchemableIdentifierNode: Readonly<{
-    is(node: OperationNode): node is SchemableIdentifierNode;
-    create(identifier: string): SchemableIdentifierNode;
-    createWithSchema(schema: string, identifier: string): SchemableIdentifierNode;
-}>;
+export declare const SchemableIdentifierNode: SchemableIdentifierNodeFactory;
+export {};

package/dist/esm/operation-node/select-all-node.d.ts

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

package/dist/esm/operation-node/select-modifier-node.d.ts

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked' | 'Distinct';
 export interface SelectModifierNode extends OperationNode {
     readonly kind: 'SelectModifierNode';
@@ -6,11 +6,13 @@ export interface SelectModifierNode extends OperationNode {
     readonly rawModifier?: OperationNode;
     readonly of?: ReadonlyArray<OperationNode>;
 }
+type SelectModifierNodeFactory = Readonly<{
+    is(node: OperationNode): node is SelectModifierNode;
+    create(modifier: SelectModifier, of?: ReadonlyArray<OperationNode>): Readonly<SelectModifierNode>;
+    createWithExpression(modifier: OperationNode): Readonly<SelectModifierNode>;
+}>;
 /**
  * @internal
  */
-export declare const SelectModifierNode: Readonly<{
-    is(node: OperationNode): node is SelectModifierNode;
-    create(modifier: SelectModifier, of?: ReadonlyArray<OperationNode>): SelectModifierNode;
-    createWithExpression(modifier: OperationNode): SelectModifierNode;
-}>;
+export declare const SelectModifierNode: SelectModifierNodeFactory;
+export {};

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

@@ -1,21 +1,21 @@
 import { FromNode } from './from-node.js';
-import { GroupByItemNode } from './group-by-item-node.js';
+import type { GroupByItemNode } from './group-by-item-node.js';
 import { GroupByNode } from './group-by-node.js';
 import { HavingNode } from './having-node.js';
-import { JoinNode } from './join-node.js';
-import { LimitNode } from './limit-node.js';
-import { OffsetNode } from './offset-node.js';
-import { OperationNode } from './operation-node.js';
-import { OrderByItemNode } from './order-by-item-node.js';
-import { OrderByNode } from './order-by-node.js';
-import { SelectionNode } from './selection-node.js';
-import { WhereNode } from './where-node.js';
-import { WithNode } from './with-node.js';
-import { SelectModifierNode } from './select-modifier-node.js';
-import { ExplainNode } from './explain-node.js';
-import { SetOperationNode } from './set-operation-node.js';
-import { FetchNode } from './fetch-node.js';
-import { TopNode } from './top-node.js';
+import type { JoinNode } from './join-node.js';
+import type { LimitNode } from './limit-node.js';
+import type { OffsetNode } from './offset-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { OrderByItemNode } from './order-by-item-node.js';
+import type { OrderByNode } from './order-by-node.js';
+import type { SelectionNode } from './selection-node.js';
+import type { WhereNode } from './where-node.js';
+import type { WithNode } from './with-node.js';
+import type { SelectModifierNode } from './select-modifier-node.js';
+import type { ExplainNode } from './explain-node.js';
+import type { SetOperationNode } from './set-operation-node.js';
+import type { FetchNode } from './fetch-node.js';
+import type { TopNode } from './top-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from?: FromNode;
@@ -36,32 +36,28 @@ export interface SelectQueryNode extends OperationNode {
     readonly fetch?: FetchNode;
     readonly top?: TopNode;
 }
+type SelectQueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is SelectQueryNode;
+    create(withNode?: WithNode): Readonly<SelectQueryNode>;
+    createFrom(fromItems: ReadonlyArray<OperationNode>, withNode?: WithNode): Readonly<SelectQueryNode>;
+    cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): Readonly<SelectQueryNode>;
+    cloneWithDistinctOn(select: SelectQueryNode, expressions: ReadonlyArray<OperationNode>): Readonly<SelectQueryNode>;
+    cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): Readonly<SelectQueryNode>;
+    cloneWithOrderByItems(node: SelectQueryNode, items: ReadonlyArray<OrderByItemNode>): Readonly<SelectQueryNode>;
+    cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): Readonly<SelectQueryNode>;
+    cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): Readonly<SelectQueryNode>;
+    cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): Readonly<SelectQueryNode>;
+    cloneWithFetch(selectNode: SelectQueryNode, fetch: FetchNode): Readonly<SelectQueryNode>;
+    cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): Readonly<SelectQueryNode>;
+    cloneWithSetOperations(selectNode: SelectQueryNode, setOperations: ReadonlyArray<SetOperationNode>): Readonly<SelectQueryNode>;
+    cloneWithoutSelections(select: SelectQueryNode): Readonly<SelectQueryNode>;
+    cloneWithoutLimit(select: SelectQueryNode): Readonly<SelectQueryNode>;
+    cloneWithoutOffset(select: SelectQueryNode): Readonly<SelectQueryNode>;
+    cloneWithoutOrderBy(node: SelectQueryNode): Readonly<SelectQueryNode>;
+    cloneWithoutGroupBy(select: SelectQueryNode): Readonly<SelectQueryNode>;
+}>;
 /**
  * @internal
  */
-export declare const SelectQueryNode: Readonly<{
-    is(node: OperationNode): node is SelectQueryNode;
-    create(withNode?: WithNode): SelectQueryNode;
-    createFrom(fromItems: ReadonlyArray<OperationNode>, withNode?: WithNode): SelectQueryNode;
-    cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
-    cloneWithDistinctOn(select: SelectQueryNode, expressions: ReadonlyArray<OperationNode>): SelectQueryNode;
-    cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
-    /**
-     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
-     */
-    cloneWithOrderByItems: (node: SelectQueryNode, items: ReadonlyArray<OrderByItemNode>) => SelectQueryNode;
-    cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
-    cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
-    cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
-    cloneWithFetch(selectNode: SelectQueryNode, fetch: FetchNode): SelectQueryNode;
-    cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
-    cloneWithSetOperations(selectNode: SelectQueryNode, setOperations: ReadonlyArray<SetOperationNode>): SelectQueryNode;
-    cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;
-    cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
-    cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;
-    /**
-     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
-     */
-    cloneWithoutOrderBy: (node: SelectQueryNode) => SelectQueryNode;
-    cloneWithoutGroupBy(select: SelectQueryNode): SelectQueryNode;
-}>;
+export declare const SelectQueryNode: SelectQueryNodeFactory;
+export {};

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

@@ -1,20 +1,21 @@
-import { AliasNode } from './alias-node.js';
-import { OperationNode } from './operation-node.js';
+import type { AliasNode } from './alias-node.js';
+import type { OperationNode } from './operation-node.js';
 import { SelectAllNode } from './select-all-node.js';
-import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
-import { TableNode } from './table-node.js';
+import type { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
+import type { TableNode } from './table-node.js';
 type SelectionNodeChild = SimpleReferenceExpressionNode | AliasNode | SelectAllNode;
 export interface SelectionNode extends OperationNode {
     readonly kind: 'SelectionNode';
     readonly selection: SelectionNodeChild;
 }
+type SelectionNodeFactory = Readonly<{
+    is(node: OperationNode): node is SelectionNode;
+    create(selection: SelectionNodeChild): Readonly<SelectionNode>;
+    createSelectAll(): Readonly<SelectionNode>;
+    createSelectAllFromTable(table: TableNode): Readonly<SelectionNode>;
+}>;
 /**
  * @internal
  */
-export declare const SelectionNode: Readonly<{
-    is(node: OperationNode): node is SelectionNode;
-    create(selection: SelectionNodeChild): SelectionNode;
-    createSelectAll(): SelectionNode;
-    createSelectAllFromTable(table: TableNode): SelectionNode;
-}>;
+export declare const SelectionNode: SelectionNodeFactory;
 export {};

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

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export type SetOperator = 'union' | 'intersect' | 'except';
 export interface SetOperationNode extends OperationNode {
     kind: 'SetOperationNode';
@@ -6,10 +6,12 @@ export interface SetOperationNode extends OperationNode {
     expression: OperationNode;
     all: boolean;
 }
+type SetOperationNodeFactory = Readonly<{
+    is(node: OperationNode): node is SetOperationNode;
+    create(operator: SetOperator, expression: OperationNode, all: boolean): Readonly<SetOperationNode>;
+}>;
 /**
  * @internal
  */
-export declare const SetOperationNode: Readonly<{
-    is(node: OperationNode): node is SetOperationNode;
-    create(operator: SetOperator, expression: OperationNode, all: boolean): SetOperationNode;
-}>;
+export declare const SetOperationNode: SetOperationNodeFactory;
+export {};

package/dist/esm/operation-node/simple-reference-expression-node.d.ts

@@ -1,3 +1,3 @@
-import { ColumnNode } from './column-node.js';
-import { ReferenceNode } from './reference-node.js';
+import type { ColumnNode } from './column-node.js';
+import type { ReferenceNode } from './reference-node.js';
 export type SimpleReferenceExpressionNode = ColumnNode | ReferenceNode;

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

@@ -1,14 +1,16 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 export interface TableNode extends OperationNode {
     readonly kind: 'TableNode';
     readonly table: SchemableIdentifierNode;
 }
+type TableNodeFactory = Readonly<{
+    is(node: OperationNode): node is TableNode;
+    create(table: string): Readonly<TableNode>;
+    createWithSchema(schema: string, table: string): Readonly<TableNode>;
+}>;
 /**
  * @internal
  */
-export declare const TableNode: Readonly<{
-    is(node: OperationNode): node is TableNode;
-    create(table: string): TableNode;
-    createWithSchema(schema: string, table: string): TableNode;
-}>;
+export declare const TableNode: TableNodeFactory;
+export {};