kysely 0.28.7 → 0.28.9

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

@@ -1,14 +1,16 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export type TopModifier = 'percent' | 'with ties' | 'percent with ties';
 export interface TopNode extends OperationNode {
     readonly kind: 'TopNode';
     readonly expression: number | bigint;
     readonly modifiers?: TopModifier;
 }
+type TopNodeFactory = Readonly<{
+    is(node: OperationNode): node is TopNode;
+    create(expression: number | bigint, modifiers?: TopModifier): Readonly<TopNode>;
+}>;
 /**
  * @internal
  */
-export declare const TopNode: Readonly<{
-    is(node: OperationNode): node is TopNode;
-    create(expression: number | bigint, modifiers?: TopModifier): TopNode;
-}>;
+export declare const TopNode: TopNodeFactory;
+export {};

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

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

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

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

package/dist/cjs/operation-node/unique-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 UniqueConstraintNode extends OperationNode {
     readonly kind: 'UniqueConstraintNode';
     readonly columns: ReadonlyArray<ColumnNode>;
@@ -10,11 +10,13 @@ export interface UniqueConstraintNode extends OperationNode {
     readonly initiallyDeferred?: boolean;
 }
 export type UniqueConstraintNodeProps = Omit<Partial<UniqueConstraintNode>, 'kind'>;
+type UniqueConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is UniqueConstraintNode;
+    create(columns: string[], constraintName?: string, nullsNotDistinct?: boolean): Readonly<UniqueConstraintNode>;
+    cloneWith(node: UniqueConstraintNode, props: UniqueConstraintNodeProps): Readonly<UniqueConstraintNode>;
+}>;
 /**
  * @internal
  */
-export declare const UniqueConstraintNode: Readonly<{
-    is(node: OperationNode): node is UniqueConstraintNode;
-    create(columns: string[], constraintName?: string, nullsNotDistinct?: boolean): UniqueConstraintNode;
-    cloneWith(node: UniqueConstraintNode, props: UniqueConstraintNodeProps): UniqueConstraintNode;
-}>;
+export declare const UniqueConstraintNode: UniqueConstraintNodeFactory;
+export {};

package/dist/cjs/operation-node/unique-constraint-node.js

@@ -15,7 +15,9 @@ exports.UniqueConstraintNode = (0, object_utils_js_1.freeze)({
         return (0, object_utils_js_1.freeze)({
             kind: 'UniqueConstraintNode',
             columns: (0, object_utils_js_1.freeze)(columns.map(column_node_js_1.ColumnNode.create)),
-            name: constraintName ? identifier_node_js_1.IdentifierNode.create(constraintName) : undefined,
+            name: constraintName
+                ? identifier_node_js_1.IdentifierNode.create(constraintName)
+                : undefined,
             nullsNotDistinct,
         });
     },

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

@@ -1,15 +1,15 @@
-import { ColumnUpdateNode } from './column-update-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 type { ColumnUpdateNode } from './column-update-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 { FromNode } from './from-node.js';
-import { ExplainNode } from './explain-node.js';
-import { LimitNode } from './limit-node.js';
-import { TopNode } from './top-node.js';
-import { OutputNode } from './output-node.js';
-import { OrderByNode } from './order-by-node.js';
+import type { ExplainNode } from './explain-node.js';
+import type { LimitNode } from './limit-node.js';
+import type { TopNode } from './top-node.js';
+import type { OutputNode } from './output-node.js';
+import type { OrderByNode } from './order-by-node.js';
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
     readonly table?: OperationNode;
@@ -26,14 +26,16 @@ export interface UpdateQueryNode extends OperationNode {
     readonly output?: OutputNode;
     readonly orderBy?: OrderByNode;
 }
+type UpdateQueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is UpdateQueryNode;
+    create(tables: ReadonlyArray<OperationNode>, withNode?: WithNode): Readonly<UpdateQueryNode>;
+    createWithoutTable(): Readonly<UpdateQueryNode>;
+    cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<OperationNode>): Readonly<UpdateQueryNode>;
+    cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): Readonly<UpdateQueryNode>;
+    cloneWithLimit(updateQuery: UpdateQueryNode, limit: LimitNode): Readonly<UpdateQueryNode>;
+}>;
 /**
  * @internal
  */
-export declare const UpdateQueryNode: Readonly<{
-    is(node: OperationNode): node is UpdateQueryNode;
-    create(tables: ReadonlyArray<OperationNode>, withNode?: WithNode): UpdateQueryNode;
-    createWithoutTable(): UpdateQueryNode;
-    cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<OperationNode>): UpdateQueryNode;
-    cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
-    cloneWithLimit(updateQuery: UpdateQueryNode, limit: LimitNode): UpdateQueryNode;
-}>;
+export declare const UpdateQueryNode: UpdateQueryNodeFactory;
+export {};

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

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

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

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

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

@@ -1,14 +1,16 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface ValueNode extends OperationNode {
     readonly kind: 'ValueNode';
     readonly value: unknown;
     readonly immediate?: boolean;
 }
+type ValueNodeFactory = Readonly<{
+    is(node: OperationNode): node is ValueNode;
+    create(value: unknown): Readonly<ValueNode>;
+    createImmediate(value: unknown): Readonly<ValueNode>;
+}>;
 /**
  * @internal
  */
-export declare const ValueNode: Readonly<{
-    is(node: OperationNode): node is ValueNode;
-    create(value: unknown): ValueNode;
-    createImmediate(value: unknown): ValueNode;
-}>;
+export declare const ValueNode: ValueNodeFactory;
+export {};

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

@@ -1,15 +1,17 @@
-import { OperationNode } from './operation-node.js';
-import { PrimitiveValueListNode } from './primitive-value-list-node.js';
-import { ValueListNode } from './value-list-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { PrimitiveValueListNode } from './primitive-value-list-node.js';
+import type { ValueListNode } from './value-list-node.js';
 export type ValuesItemNode = ValueListNode | PrimitiveValueListNode;
 export interface ValuesNode extends OperationNode {
     readonly kind: 'ValuesNode';
     readonly values: ReadonlyArray<ValuesItemNode>;
 }
+type ValuesNodeFactory = Readonly<{
+    is(node: OperationNode): node is ValuesNode;
+    create(values: ReadonlyArray<ValuesItemNode>): Readonly<ValuesNode>;
+}>;
 /**
  * @internal
  */
-export declare const ValuesNode: Readonly<{
-    is(node: OperationNode): node is ValuesNode;
-    create(values: ReadonlyArray<ValuesItemNode>): ValuesNode;
-}>;
+export declare const ValuesNode: ValuesNodeFactory;
+export {};

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

@@ -1,14 +1,16 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface WhenNode extends OperationNode {
     readonly kind: 'WhenNode';
     readonly condition: OperationNode;
     readonly result?: OperationNode;
 }
+type WhenNodeFactory = Readonly<{
+    is(node: OperationNode): node is WhenNode;
+    create(condition: OperationNode): Readonly<WhenNode>;
+    cloneWithResult(whenNode: WhenNode, result: OperationNode): Readonly<WhenNode>;
+}>;
 /**
  * @internal
  */
-export declare const WhenNode: Readonly<{
-    is(node: OperationNode): node is WhenNode;
-    create(condition: OperationNode): WhenNode;
-    cloneWithResult(whenNode: WhenNode, result: OperationNode): WhenNode;
-}>;
+export declare const WhenNode: WhenNodeFactory;
+export {};

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

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

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

@@ -1,16 +1,18 @@
-import { OperationNode } from './operation-node.js';
-import { CommonTableExpressionNode } from './common-table-expression-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { CommonTableExpressionNode } from './common-table-expression-node.js';
 export type WithNodeParams = Omit<WithNode, 'kind' | 'expressions'>;
 export interface WithNode extends OperationNode {
     readonly kind: 'WithNode';
     readonly expressions: ReadonlyArray<CommonTableExpressionNode>;
     readonly recursive?: boolean;
 }
+type WithNodeFactory = Readonly<{
+    is(node: OperationNode): node is WithNode;
+    create(expression: CommonTableExpressionNode, params?: WithNodeParams): Readonly<WithNode>;
+    cloneWithExpression(withNode: WithNode, expression: CommonTableExpressionNode): Readonly<WithNode>;
+}>;
 /**
  * @internal
  */
-export declare const WithNode: Readonly<{
-    is(node: OperationNode): node is WithNode;
-    create(expression: CommonTableExpressionNode, params?: WithNodeParams): WithNode;
-    cloneWithExpression(withNode: WithNode, expression: CommonTableExpressionNode): WithNode;
-}>;
+export declare const WithNode: WithNodeFactory;
+export {};

package/dist/cjs/parser/binary-operation-parser.d.ts

@@ -1,11 +1,11 @@
 import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
-import { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { ComparisonOperator, BinaryOperator, Operator } from '../operation-node/operator-node.js';
-import { ExtractTypeFromReferenceExpression, ExtractTypeFromStringReference, ReferenceExpression, StringReference } from './reference-parser.js';
-import { ValueExpression, ValueExpressionOrList } from './value-parser.js';
-import { OperationNode } from '../operation-node/operation-node.js';
-import { Expression } from '../expression/expression.js';
-import { SelectType } from '../util/column-type.js';
+import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { type ComparisonOperator, type BinaryOperator, type Operator } from '../operation-node/operator-node.js';
+import { type ExtractTypeFromReferenceExpression, type ExtractTypeFromStringReference, type ReferenceExpression, type StringReference } from './reference-parser.js';
+import { type ValueExpression, type ValueExpressionOrList } from './value-parser.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+import type { Expression } from '../expression/expression.js';
+import type { SelectType } from '../util/column-type.js';
 export type OperandValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
 export type OperandValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE> | null>;
 export type OperatorExpression = Operator | Expression<unknown>;

package/dist/cjs/parser/coalesce-parser.d.ts

@@ -1,4 +1,4 @@
-import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+import type { ExtractTypeFromReferenceExpression } from './reference-parser.js';
 export type ExtractTypeFromCoalesce1<DB, TB extends keyof DB, R1> = ExtractTypeFromReferenceExpression<DB, TB, R1>;
 export type ExtractTypeFromCoalesce2<DB, TB extends keyof DB, R1, R2> = ExtractTypeFromCoalesceValues2<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>>;
 type ExtractTypeFromCoalesceValues2<V1, V2> = null extends V1 ? null extends V2 ? V1 | V2 : NotNull<V1 | V2> : NotNull<V1>;

package/dist/cjs/parser/data-type-parser.d.ts

@@ -1,5 +1,5 @@
-import { Expression } from '../expression/expression.js';
-import { ColumnDataType } from '../operation-node/data-type-node.js';
-import { OperationNode } from '../operation-node/operation-node.js';
+import type { Expression } from '../expression/expression.js';
+import { type ColumnDataType } from '../operation-node/data-type-node.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
 export type DataTypeExpression = ColumnDataType | Expression<any>;
 export declare function parseDataTypeExpression(dataType: DataTypeExpression): OperationNode;

package/dist/cjs/parser/default-value-parser.d.ts

@@ -1,4 +1,4 @@
-import { Expression } from '../expression/expression.js';
-import { OperationNode } from '../operation-node/operation-node.js';
+import type { Expression } from '../expression/expression.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
 export type DefaultValueExpression = unknown | Expression<unknown>;
 export declare function parseDefaultValueExpression(value: DefaultValueExpression): OperationNode;

package/dist/cjs/parser/expression-parser.d.ts

@@ -1,8 +1,8 @@
-import { AliasedExpression, Expression } from '../expression/expression.js';
-import { AliasNode } from '../operation-node/alias-node.js';
-import { OperationNode } from '../operation-node/operation-node.js';
-import { ExpressionBuilder } from '../expression/expression-builder.js';
-import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
+import { type AliasedExpression, type Expression } from '../expression/expression.js';
+import type { AliasNode } from '../operation-node/alias-node.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+import { type ExpressionBuilder } from '../expression/expression-builder.js';
+import type { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 /**
  * Like `Expression<V>` but also accepts a select query with an output
  * type extending `Record<string, V>`. This type is useful because SQL

package/dist/cjs/parser/fetch-parser.d.ts

@@ -1,2 +1,2 @@
-import { FetchModifier, FetchNode } from '../operation-node/fetch-node.js';
+import { type FetchModifier, FetchNode } from '../operation-node/fetch-node.js';
 export declare function parseFetch(rowCount: number | bigint, modifier: FetchModifier): FetchNode;

package/dist/cjs/parser/group-by-parser.d.ts

@@ -1,6 +1,6 @@
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
-import { ExpressionBuilder } from '../expression/expression-builder.js';
-import { ReferenceExpression } from './reference-parser.js';
+import { type ExpressionBuilder } from '../expression/expression-builder.js';
+import { type ReferenceExpression } from './reference-parser.js';
 export type GroupByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
 export type GroupByArg<DB, TB extends keyof DB, O> = GroupByExpression<DB, TB, O> | ReadonlyArray<GroupByExpression<DB, TB, O>> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<GroupByExpression<DB, TB, O>>);
 export declare function parseGroupBy(groupBy: GroupByArg<any, any, any>): GroupByItemNode[];

package/dist/cjs/parser/insert-values-parser.d.ts

@@ -1,8 +1,8 @@
 import { ColumnNode } from '../operation-node/column-node.js';
-import { ValueExpression } from './value-parser.js';
+import { type ValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
-import { NonNullableInsertKeys, NullableInsertKeys, InsertType } from '../util/column-type.js';
-import { ExpressionBuilder } from '../expression/expression-builder.js';
+import type { NonNullableInsertKeys, NullableInsertKeys, InsertType } from '../util/column-type.js';
+import { type ExpressionBuilder } from '../expression/expression-builder.js';
 export type InsertObject<DB, TB extends keyof DB> = {
     [C in NonNullableInsertKeys<DB[TB]>]: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
 } & {

package/dist/cjs/parser/join-parser.d.ts

@@ -1,7 +1,7 @@
-import { JoinNode, JoinType } from '../operation-node/join-node.js';
-import { JoinBuilder } from '../query-builder/join-builder.js';
-import { AnyColumn, AnyColumnWithTable, DrainOuterGeneric } from '../util/type-utils.js';
-import { From, FromTables } from './table-parser.js';
+import { JoinNode, type JoinType } from '../operation-node/join-node.js';
+import type { JoinBuilder } from '../query-builder/join-builder.js';
+import type { AnyColumn, AnyColumnWithTable, DrainOuterGeneric } from '../util/type-utils.js';
+import { type From, type FromTables } from './table-parser.js';
 export type JoinReferenceExpression<DB, TB extends keyof DB, TE> = DrainOuterGeneric<AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>>;
 export type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
 type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;

package/dist/cjs/parser/merge-parser.d.ts

@@ -1,6 +1,6 @@
-import { InsertQueryNode } from '../operation-node/insert-query-node.js';
-import { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { OperationNode } from '../operation-node/operation-node.js';
+import type { InsertQueryNode } from '../operation-node/insert-query-node.js';
+import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
 import { WhenNode } from '../operation-node/when-node.js';
 export declare function parseMergeWhen(type: {
     isMatched: boolean;

package/dist/cjs/parser/on-commit-action-parse.d.ts

@@ -1,2 +1,2 @@
-import { OnCommitAction } from '../operation-node/create-table-node.js';
+import { type OnCommitAction } from '../operation-node/create-table-node.js';
 export declare function parseOnCommitAction(action: OnCommitAction): OnCommitAction;

package/dist/cjs/parser/on-modify-action-parser.d.ts

@@ -1,2 +1,2 @@
-import { OnModifyForeignAction } from '../operation-node/references-node.js';
+import { type OnModifyForeignAction } from '../operation-node/references-node.js';
 export declare function parseOnModifyForeignAction(action: OnModifyForeignAction): OnModifyForeignAction;

package/dist/cjs/parser/order-by-parser.d.ts

@@ -1,9 +1,9 @@
-import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-import { Expression } from '../expression/expression.js';
+import { type DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { type Expression } from '../expression/expression.js';
 import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { OrderByItemBuilder } from '../query-builder/order-by-item-builder.js';
-import { ExpressionOrFactory } from './expression-parser.js';
-import { ReferenceExpression, StringReference } from './reference-parser.js';
+import { type ExpressionOrFactory } from './expression-parser.js';
+import { type ReferenceExpression, type StringReference } from './reference-parser.js';
 export type OrderByExpression<DB, TB extends keyof DB, O> = StringReference<DB, TB> | (keyof O & string) | ExpressionOrFactory<DB, TB, any> | DynamicReferenceBuilder<any>;
 export type OrderByModifiers = OrderByDirection | OrderByModifiersCallbackExpression;
 export type OrderByDirection = 'asc' | 'desc';

package/dist/cjs/parser/parse-utils.d.ts

@@ -1,9 +1,9 @@
-import { JoinType } from '../operation-node/join-node.js';
+import { type JoinType } from '../operation-node/join-node.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { OverBuilder } from '../query-builder/over-builder.js';
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { type SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { QueryCreator } from '../query-creator.js';
-import { TableExpression } from './table-parser.js';
+import { type TableExpression } from './table-parser.js';
 export declare function createSelectQueryBuilder(): SelectQueryBuilder<any, any, any>;
 export declare function createQueryCreator(): QueryCreator<any>;
 export declare function createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;

package/dist/cjs/parser/partition-by-parser.d.ts

@@ -1,6 +1,6 @@
-import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import type { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
-import { StringReference } from './reference-parser.js';
+import { type StringReference } from './reference-parser.js';
 export type PartitionByExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
 export type PartitionByExpressionOrList<DB, TB extends keyof DB> = ReadonlyArray<PartitionByExpression<DB, TB>> | PartitionByExpression<DB, TB>;
 export declare function parsePartitionBy(partitionBy: PartitionByExpressionOrList<any, any>): PartitionByItemNode[];

package/dist/cjs/parser/reference-parser.d.ts

@@ -1,16 +1,16 @@
 import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
-import { AnyColumn, AnyColumnWithTable, ExtractColumnType } from '../util/type-utils.js';
-import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
-import { ExpressionOrFactory } from './expression-parser.js';
-import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-import { SelectType } from '../util/column-type.js';
-import { OperationNode } from '../operation-node/operation-node.js';
-import { Expression } from '../expression/expression.js';
-import { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js';
-import { OrderByDirection } from './order-by-parser.js';
-import { JSONOperatorWith$ } from '../operation-node/operator-node.js';
+import type { AnyColumn, AnyColumnWithTable, ExtractColumnType } from '../util/type-utils.js';
+import type { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
+import { type ExpressionOrFactory } from './expression-parser.js';
+import type { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import type { SelectType } from '../util/column-type.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+import type { Expression } from '../expression/expression.js';
+import type { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js';
+import { type OrderByDirection } from './order-by-parser.js';
+import { type JSONOperatorWith$ } from '../operation-node/operator-node.js';
 import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
 export type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
 export type SimpleReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;

package/dist/cjs/parser/returning-parser.d.ts

@@ -1,8 +1,8 @@
-import { DeleteResult } from '../query-builder/delete-result.js';
-import { InsertResult } from '../query-builder/insert-result.js';
-import { MergeResult } from '../query-builder/merge-result.js';
-import { UpdateResult } from '../query-builder/update-result.js';
-import { Selection, AllSelection, CallbackSelection } from './select-parser.js';
+import type { DeleteResult } from '../query-builder/delete-result.js';
+import type { InsertResult } from '../query-builder/insert-result.js';
+import type { MergeResult } from '../query-builder/merge-result.js';
+import type { UpdateResult } from '../query-builder/update-result.js';
+import type { Selection, AllSelection, CallbackSelection } from './select-parser.js';
 export type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
 export type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? CallbackSelection<DB, TB, CB> : O & CallbackSelection<DB, TB, CB>;
 export type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;

package/dist/cjs/parser/select-parser.d.ts

@@ -1,11 +1,11 @@
-import { AliasedSelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import type { AliasedSelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, DrainOuterGeneric, ExtractColumnType } from '../util/type-utils.js';
-import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-import { AliasedExpressionOrFactory } from './expression-parser.js';
-import { SelectType } from '../util/column-type.js';
-import { AliasedExpression } from '../expression/expression.js';
-import { ExpressionBuilder } from '../expression/expression-builder.js';
+import type { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, DrainOuterGeneric, ExtractColumnType } from '../util/type-utils.js';
+import { type DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { type AliasedExpressionOrFactory } from './expression-parser.js';
+import type { SelectType } from '../util/column-type.js';
+import type { AliasedExpression } from '../expression/expression.js';
+import { type ExpressionBuilder } from '../expression/expression-builder.js';
 export type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedExpressionOrFactory<DB, TB>;
 export type SelectCallback<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SelectExpression<DB, TB>>;
 /**

package/dist/cjs/parser/set-operation-parser.d.ts

@@ -1,5 +1,5 @@
-import { ExpressionBuilder } from '../expression/expression-builder.js';
-import { Expression } from '../expression/expression.js';
-import { SetOperator, SetOperationNode } from '../operation-node/set-operation-node.js';
+import { type ExpressionBuilder } from '../expression/expression-builder.js';
+import type { Expression } from '../expression/expression.js';
+import { type SetOperator, SetOperationNode } from '../operation-node/set-operation-node.js';
 export type SetOperandExpression<DB, O> = Expression<O> | ReadonlyArray<Expression<O>> | ((eb: ExpressionBuilder<DB, never>) => Expression<O> | ReadonlyArray<Expression<O>>);
-export declare function parseSetOperations(operator: SetOperator, expression: SetOperandExpression<any, any>, all: boolean): SetOperationNode[];
+export declare function parseSetOperations(operator: SetOperator, expression: SetOperandExpression<any, any>, all: boolean): Readonly<SetOperationNode>[];

package/dist/cjs/parser/table-parser.d.ts

@@ -1,10 +1,10 @@
 import { AliasNode } from '../operation-node/alias-node.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { AliasedExpressionOrFactory } from './expression-parser.js';
-import { OperationNode } from '../operation-node/operation-node.js';
-import { AliasedExpression } from '../expression/expression.js';
-import { DrainOuterGeneric } from '../util/type-utils.js';
-import { AliasedDynamicTableBuilder } from '../dynamic/dynamic-table-builder.js';
+import { type AliasedExpressionOrFactory } from './expression-parser.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+import type { AliasedExpression } from '../expression/expression.js';
+import type { DrainOuterGeneric } from '../util/type-utils.js';
+import { type AliasedDynamicTableBuilder } from '../dynamic/dynamic-table-builder.js';
 export type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB> | AliasedDynamicTableBuilder<any, any>;
 export type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export type SimpleTableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB>;

package/dist/cjs/parser/top-parser.d.ts

@@ -1,2 +1,2 @@
-import { TopModifier, TopNode } from '../operation-node/top-node.js';
+import { type TopModifier, TopNode } from '../operation-node/top-node.js';
 export declare function parseTop(expression: number | bigint, modifiers?: TopModifier): TopNode;

package/dist/cjs/parser/tuple-parser.d.ts

@@ -1,6 +1,6 @@
-import { DrainOuterGeneric } from '../util/type-utils.js';
-import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
-import { ExtractTypeFromValueExpression } from './value-parser.js';
+import type { DrainOuterGeneric } from '../util/type-utils.js';
+import type { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+import type { ExtractTypeFromValueExpression } from './value-parser.js';
 export type RefTuple2<DB, TB extends keyof DB, R1, R2> = DrainOuterGeneric<[
     ExtractTypeFromReferenceExpression<DB, TB, R1>,
     ExtractTypeFromReferenceExpression<DB, TB, R2>