kysely 0.28.7 → 0.28.9

package/dist/esm/index.d.ts

@@ -1,7 +1,7 @@
 export * from './kysely.js';
 export * from './query-creator.js';
 export * from './expression/expression.js';
-export { ExpressionBuilder, expressionBuilder, } from './expression/expression-builder.js';
+export { type ExpressionBuilder, expressionBuilder, } from './expression/expression-builder.js';
 export * from './expression/expression-wrapper.js';
 export * from './query-builder/where-interface.js';
 export * from './query-builder/returning-interface.js';
@@ -206,19 +206,19 @@ export * from './util/compilable.js';
 export * from './util/explainable.js';
 export * from './util/streamable.js';
 export * from './util/log.js';
-export { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, Equals, UnknownRow, Simplify, SqlBool, Nullable, NumbersWhenDataTypeNotAvailable, NotNull, NumericString, ShallowDehydrateObject, ShallowDehydrateValue, StringsWhenDataTypeNotAvailable, } from './util/type-utils.js';
+export type { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, Equals, UnknownRow, Simplify, SqlBool, Nullable, NumbersWhenDataTypeNotAvailable, NotNull, NumericString, ShallowDehydrateObject, ShallowDehydrateValue, StringsWhenDataTypeNotAvailable, } from './util/type-utils.js';
 export * from './util/infer-result.js';
 export { logOnce } from './util/log-once.js';
-export { createQueryId, QueryId } from './util/query-id.js';
-export { SelectExpression, SelectCallback, SelectArg, Selection, CallbackSelection, } from './parser/select-parser.js';
-export { ReferenceExpression, ReferenceExpressionOrList, SimpleReferenceExpression, StringReference, ExtractTypeFromStringReference, ExtractTypeFromReferenceExpression, } from './parser/reference-parser.js';
-export { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';
-export { SimpleTableReference, TableExpression, TableExpressionOrList, } from './parser/table-parser.js';
-export { JoinReferenceExpression, JoinCallbackExpression, } from './parser/join-parser.js';
-export { InsertObject } from './parser/insert-values-parser.js';
-export { UpdateObject } from './parser/update-set-parser.js';
-export { OrderByExpression, OrderByDirectionExpression, OrderByModifiers, OrderByDirection, OrderByModifiersCallbackExpression, } from './parser/order-by-parser.js';
-export { ComparisonOperatorExpression, OperandValueExpression, OperandValueExpressionOrList, FilterObject, } from './parser/binary-operation-parser.js';
-export { ExistsExpression } from './parser/unary-operation-parser.js';
-export { OperandExpression, ExpressionOrFactory, } from './parser/expression-parser.js';
-export { Collation } from './parser/collate-parser.js';
+export { createQueryId, type QueryId } from './util/query-id.js';
+export type { SelectExpression, SelectCallback, SelectArg, Selection, CallbackSelection, } from './parser/select-parser.js';
+export type { ReferenceExpression, ReferenceExpressionOrList, SimpleReferenceExpression, StringReference, ExtractTypeFromStringReference, ExtractTypeFromReferenceExpression, } from './parser/reference-parser.js';
+export type { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';
+export type { SimpleTableReference, TableExpression, TableExpressionOrList, } from './parser/table-parser.js';
+export type { JoinReferenceExpression, JoinCallbackExpression, } from './parser/join-parser.js';
+export type { InsertObject } from './parser/insert-values-parser.js';
+export type { UpdateObject } from './parser/update-set-parser.js';
+export type { OrderByExpression, OrderByDirectionExpression, OrderByModifiers, OrderByDirection, OrderByModifiersCallbackExpression, } from './parser/order-by-parser.js';
+export type { ComparisonOperatorExpression, OperandValueExpression, OperandValueExpressionOrList, FilterObject, } from './parser/binary-operation-parser.js';
+export type { ExistsExpression } from './parser/unary-operation-parser.js';
+export type { OperandExpression, ExpressionOrFactory, } from './parser/expression-parser.js';
+export type { Collation } from './parser/collate-parser.js';

package/dist/esm/kysely.d.ts

@@ -1,23 +1,23 @@
-import { Dialect } from './dialect/dialect.js';
+import type { Dialect } from './dialect/dialect.js';
 import { SchemaModule } from './schema/schema.js';
 import { DynamicModule } from './dynamic/dynamic.js';
-import { QueryExecutor } from './query-executor/query-executor.js';
+import type { QueryExecutor } from './query-executor/query-executor.js';
 import { QueryCreator } from './query-creator.js';
-import { KyselyPlugin } from './plugin/kysely-plugin.js';
-import { DatabaseIntrospector } from './dialect/database-introspector.js';
-import { Driver, IsolationLevel, AccessMode } from './driver/driver.js';
-import { FunctionModule } from './query-builder/function-module.js';
-import { LogConfig } from './util/log.js';
-import { QueryExecutorProvider } from './query-executor/query-executor-provider.js';
-import { QueryResult } from './driver/database-connection.js';
-import { CompiledQuery } from './query-compiler/compiled-query.js';
-import { QueryId } from './util/query-id.js';
-import { Compilable } from './util/compilable.js';
+import type { KyselyPlugin } from './plugin/kysely-plugin.js';
+import type { DatabaseIntrospector } from './dialect/database-introspector.js';
+import { type Driver, type IsolationLevel, type AccessMode } from './driver/driver.js';
+import { type FunctionModule } from './query-builder/function-module.js';
+import { type LogConfig } from './util/log.js';
+import type { QueryExecutorProvider } from './query-executor/query-executor-provider.js';
+import type { QueryResult } from './driver/database-connection.js';
+import type { CompiledQuery } from './query-compiler/compiled-query.js';
+import { type QueryId } from './util/query-id.js';
+import { type Compilable } from './util/compilable.js';
 import { CaseBuilder } from './query-builder/case-builder.js';
-import { Expression } from './expression/expression.js';
-import { DrainOuterGeneric } from './util/type-utils.js';
-import { ReleaseSavepoint, RollbackToSavepoint } from './parser/savepoint-parser.js';
-import { ControlledConnection } from './util/provide-controlled-connection.js';
+import type { Expression } from './expression/expression.js';
+import type { DrainOuterGeneric } from './util/type-utils.js';
+import type { ReleaseSavepoint, RollbackToSavepoint } from './parser/savepoint-parser.js';
+import { type ControlledConnection } from './util/provide-controlled-connection.js';
 declare global {
     interface AsyncDisposable {
     }

package/dist/esm/migration/file-migration-provider.d.ts

@@ -1,4 +1,4 @@
-import { Migration, MigrationProvider } from './migrator.js';
+import type { Migration, MigrationProvider } from './migrator.js';
 /**
  * Reads all migrations from a folder in node.js.
  *

package/dist/esm/migration/migrator.d.ts

@@ -1,4 +1,4 @@
-import { Kysely } from '../kysely.js';
+import type { Kysely } from '../kysely.js';
 export declare const DEFAULT_MIGRATION_TABLE = "kysely_migration";
 export declare const DEFAULT_MIGRATION_LOCK_TABLE = "kysely_migration_lock";
 export declare const DEFAULT_ALLOW_UNORDERED_MIGRATIONS = false;
@@ -340,12 +340,12 @@ export interface MigrationResult {
      * The execution status.
      *
      *  - `Success` means the migration was successfully executed. Note that
-     *    if any of the later migrations in the {@link MigrationResult.results}
+     *    if any of the later migrations in the {@link MigrationResultSet.results}
      *    list failed (have status `Error`) AND the dialect supports transactional
      *    DDL, even the successfull migrations were rolled back.
      *
      *  - `Error` means the migration failed. In this case the
-     *    {@link MigrationResult.error} contains the error.
+     *    {@link MigrationResultSet.error} contains the error.
      *
      *  - `NotExecuted` means that the migration was supposed to be executed
      *    but wasn't because an earlier migration failed.

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { IdentifierNode } from './identifier-node.js';
-import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { RawNode } from './raw-node.js';
 export type AddIndexNodeProps = Omit<AddIndexNode, 'kind' | 'name'>;
 export interface AddIndexNode extends OperationNode {
     readonly kind: 'AddIndexNode';
@@ -10,12 +10,14 @@ export interface AddIndexNode extends OperationNode {
     readonly using?: RawNode;
     readonly ifNotExists?: boolean;
 }
+type AddIndexNodeFactory = Readonly<{
+    is(node: OperationNode): node is AddIndexNode;
+    create(name: string): Readonly<AddIndexNode>;
+    cloneWith(node: AddIndexNode, props: Omit<AddIndexNode, 'kind' | 'name'>): Readonly<AddIndexNode>;
+    cloneWithColumns(node: AddIndexNode, columns: OperationNode[]): Readonly<AddIndexNode>;
+}>;
 /**
  * @internal
  */
-export declare const AddIndexNode: Readonly<{
-    is(node: OperationNode): node is AddIndexNode;
-    create(name: string): AddIndexNode;
-    cloneWith(node: AddIndexNode, props: AddIndexNodeProps): AddIndexNode;
-    cloneWithColumns(node: AddIndexNode, columns: OperationNode[]): AddIndexNode;
-}>;
+export declare const AddIndexNode: AddIndexNodeFactory;
+export {};

package/dist/esm/operation-node/aggregate-function-node.d.ts

@@ -1,8 +1,8 @@
-import { OperationNode } from './operation-node.js';
-import { OverNode } from './over-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { OverNode } from './over-node.js';
 import { WhereNode } from './where-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 interface AggregateFunctionNode extends OperationNode {
     readonly kind: 'AggregateFunctionNode';
     readonly func: string;
@@ -13,15 +13,17 @@ export interface AggregateFunctionNode extends OperationNode {
     readonly filter?: WhereNode;
     readonly over?: OverNode;
 }
+type AggregateFunctionNodeFactory = Readonly<{
+    is(node: OperationNode): node is AggregateFunctionNode;
+    create(aggregateFunction: string, aggregated?: readonly OperationNode[]): Readonly<AggregateFunctionNode>;
+    cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): Readonly<AggregateFunctionNode>;
+    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>, withinGroup?: boolean): Readonly<AggregateFunctionNode>;
+    cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): Readonly<AggregateFunctionNode>;
+    cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): Readonly<AggregateFunctionNode>;
+    cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): Readonly<AggregateFunctionNode>;
+}>;
 /**
  * @internal
  */
-export declare const AggregateFunctionNode: Readonly<{
-    is(node: OperationNode): node is AggregateFunctionNode;
-    create(aggregateFunction: string, aggregated?: readonly OperationNode[]): AggregateFunctionNode;
-    cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
-    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>, withinGroup?: boolean): AggregateFunctionNode;
-    cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
-    cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
-    cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): AggregateFunctionNode;
-}>;
+export declare const AggregateFunctionNode: AggregateFunctionNodeFactory;
+export {};

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

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

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

@@ -1,6 +1,6 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
-import { RawNode } from './raw-node.js';
+import type { RawNode } from './raw-node.js';
 export type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>;
 export interface AlterColumnNode extends OperationNode {
     readonly kind: 'AlterColumnNode';
@@ -12,10 +12,12 @@ export interface AlterColumnNode extends OperationNode {
     readonly setNotNull?: true;
     readonly dropNotNull?: true;
 }
+type AlterColumnNodeFactory = Readonly<{
+    is(node: OperationNode): node is AlterColumnNode;
+    create<T extends keyof AlterColumnNodeProps>(column: string, prop: T, value: Required<AlterColumnNodeProps>[T]): Readonly<AlterColumnNode>;
+}>;
 /**
  * @internal
  */
-export declare const AlterColumnNode: Readonly<{
-    is(node: OperationNode): node is AlterColumnNode;
-    create<T extends keyof AlterColumnNodeProps>(column: string, prop: T, value: Required<AlterColumnNodeProps>[T]): AlterColumnNode;
-}>;
+export declare const AlterColumnNode: AlterColumnNodeFactory;
+export {};

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

@@ -1,16 +1,16 @@
-import { OperationNode } from './operation-node.js';
-import { AddColumnNode } from './add-column-node.js';
-import { DropColumnNode } from './drop-column-node.js';
-import { TableNode } from './table-node.js';
-import { IdentifierNode } from './identifier-node.js';
-import { RenameColumnNode } from './rename-column-node.js';
-import { AlterColumnNode } from './alter-column-node.js';
-import { AddConstraintNode } from './add-constraint-node.js';
-import { DropConstraintNode } from './drop-constraint-node.js';
-import { ModifyColumnNode } from './modify-column-node.js';
-import { DropIndexNode } from './drop-index-node.js';
-import { AddIndexNode } from './add-index-node.js';
-import { RenameConstraintNode } from './rename-constraint-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { AddColumnNode } from './add-column-node.js';
+import type { DropColumnNode } from './drop-column-node.js';
+import type { TableNode } from './table-node.js';
+import type { IdentifierNode } from './identifier-node.js';
+import type { RenameColumnNode } from './rename-column-node.js';
+import type { AlterColumnNode } from './alter-column-node.js';
+import type { AddConstraintNode } from './add-constraint-node.js';
+import type { DropConstraintNode } from './drop-constraint-node.js';
+import type { ModifyColumnNode } from './modify-column-node.js';
+import type { DropIndexNode } from './drop-index-node.js';
+import type { AddIndexNode } from './add-index-node.js';
+import type { RenameConstraintNode } from './rename-constraint-node.js';
 export type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint' | 'addIndex' | 'dropIndex' | 'renameConstraint'>;
 export type AlterTableColumnAlterationNode = RenameColumnNode | AddColumnNode | DropColumnNode | AlterColumnNode | ModifyColumnNode;
 export interface AlterTableNode extends OperationNode {
@@ -25,12 +25,14 @@ export interface AlterTableNode extends OperationNode {
     readonly addIndex?: AddIndexNode;
     readonly dropIndex?: DropIndexNode;
 }
+type AlterTableNodeFactory = Readonly<{
+    is(node: OperationNode): node is AlterTableNode;
+    create(table: TableNode): Readonly<AlterTableNode>;
+    cloneWithTableProps(node: AlterTableNode, props: AlterTableNodeTableProps): Readonly<AlterTableNode>;
+    cloneWithColumnAlteration(node: AlterTableNode, columnAlteration: AlterTableColumnAlterationNode): Readonly<AlterTableNode>;
+}>;
 /**
  * @internal
  */
-export declare const AlterTableNode: Readonly<{
-    is(node: OperationNode): node is AlterTableNode;
-    create(table: TableNode): AlterTableNode;
-    cloneWithTableProps(node: AlterTableNode, props: AlterTableNodeTableProps): AlterTableNode;
-    cloneWithColumnAlteration(node: AlterTableNode, columnAlteration: AlterTableColumnAlterationNode): AlterTableNode;
-}>;
+export declare const AlterTableNode: AlterTableNodeFactory;
+export {};

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

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

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

@@ -1,14 +1,16 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface BinaryOperationNode extends OperationNode {
     readonly kind: 'BinaryOperationNode';
     readonly leftOperand: OperationNode;
     readonly operator: OperationNode;
     readonly rightOperand: OperationNode;
 }
+type BinaryOperationNodeFactory = Readonly<{
+    is(node: OperationNode): node is BinaryOperationNode;
+    create(leftOperand: OperationNode, operator: OperationNode, rightOperand: OperationNode): Readonly<BinaryOperationNode>;
+}>;
 /**
  * @internal
  */
-export declare const BinaryOperationNode: Readonly<{
-    is(node: OperationNode): node is BinaryOperationNode;
-    create(leftOperand: OperationNode, operator: OperationNode, rightOperand: OperationNode): BinaryOperationNode;
-}>;
+export declare const BinaryOperationNode: BinaryOperationNodeFactory;
+export {};

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

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { WhenNode } from './when-node.js';
 export interface CaseNode extends OperationNode {
     readonly kind: 'CaseNode';
@@ -7,13 +7,15 @@ export interface CaseNode extends OperationNode {
     readonly else?: OperationNode;
     readonly isStatement?: boolean;
 }
+type CaseNodeFactory = Readonly<{
+    is(node: OperationNode): node is CaseNode;
+    create(value?: OperationNode): Readonly<CaseNode>;
+    cloneWithWhen(caseNode: CaseNode, when: WhenNode): Readonly<CaseNode>;
+    cloneWithThen(caseNode: CaseNode, then: OperationNode): Readonly<CaseNode>;
+    cloneWith(caseNode: CaseNode, props: Partial<Pick<CaseNode, 'else' | 'isStatement'>>): Readonly<CaseNode>;
+}>;
 /**
  * @internal
  */
-export declare const CaseNode: Readonly<{
-    is(node: OperationNode): node is CaseNode;
-    create(value?: OperationNode): CaseNode;
-    cloneWithWhen(caseNode: CaseNode, when: WhenNode): CaseNode;
-    cloneWithThen(caseNode: CaseNode, then: OperationNode): CaseNode;
-    cloneWith(caseNode: CaseNode, props: Partial<Pick<CaseNode, "else" | "isStatement">>): CaseNode;
-}>;
+export declare const CaseNode: CaseNodeFactory;
+export {};

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

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

package/dist/esm/operation-node/check-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 CheckConstraintNode extends OperationNode {
     readonly kind: 'CheckConstraintNode';
     readonly expression: OperationNode;
     readonly name?: IdentifierNode;
 }
+type CheckConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is CheckConstraintNode;
+    create(expression: OperationNode, constraintName?: string): Readonly<CheckConstraintNode>;
+}>;
 /**
  * @internal
  */
-export declare const CheckConstraintNode: Readonly<{
-    is(node: OperationNode): node is CheckConstraintNode;
-    create(expression: OperationNode, constraintName?: string): CheckConstraintNode;
-}>;
+export declare const CheckConstraintNode: CheckConstraintNodeFactory;
+export {};

package/dist/esm/operation-node/check-constraint-node.js

@@ -12,7 +12,9 @@ export const CheckConstraintNode = freeze({
         return freeze({
             kind: 'CheckConstraintNode',
             expression,
-            name: constraintName ? IdentifierNode.create(constraintName) : undefined,
+            name: constraintName
+                ? IdentifierNode.create(constraintName)
+                : undefined,
         });
     },
 });

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

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

package/dist/esm/operation-node/collate-node.js

@@ -4,7 +4,7 @@ import { IdentifierNode } from './identifier-node.js';
 /**
  * @internal
  */
-export const CollateNode = {
+export const CollateNode = freeze({
     is(node) {
         return node.kind === 'CollateNode';
     },
@@ -14,4 +14,4 @@ export const CollateNode = {
             collation: IdentifierNode.create(collation),
         });
     },
-};
+});

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

@@ -1,9 +1,9 @@
-import { CheckConstraintNode } from './check-constraint-node.js';
+import type { CheckConstraintNode } from './check-constraint-node.js';
 import { ColumnNode } from './column-node.js';
-import { DefaultValueNode } from './default-value-node.js';
-import { GeneratedNode } from './generated-node.js';
-import { OperationNode } from './operation-node.js';
-import { ReferencesNode } from './references-node.js';
+import type { DefaultValueNode } from './default-value-node.js';
+import type { GeneratedNode } from './generated-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ReferencesNode } from './references-node.js';
 export type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind' | 'dataType'>;
 export interface ColumnDefinitionNode extends OperationNode {
     readonly kind: 'ColumnDefinitionNode';
@@ -24,13 +24,15 @@ export interface ColumnDefinitionNode extends OperationNode {
     readonly identity?: boolean;
     readonly ifNotExists?: boolean;
 }
+type ColumnDefinitionNodeFactory = Readonly<{
+    is(node: OperationNode): node is ColumnDefinitionNode;
+    create(column: string, dataType: OperationNode): Readonly<ColumnDefinitionNode>;
+    cloneWithFrontModifier(node: ColumnDefinitionNode, modifier: OperationNode): Readonly<ColumnDefinitionNode>;
+    cloneWithEndModifier(node: ColumnDefinitionNode, modifier: OperationNode): Readonly<ColumnDefinitionNode>;
+    cloneWith(node: ColumnDefinitionNode, props: ColumnDefinitionNodeProps): Readonly<ColumnDefinitionNode>;
+}>;
 /**
  * @internal
  */
-export declare const ColumnDefinitionNode: Readonly<{
-    is(node: OperationNode): node is ColumnDefinitionNode;
-    create(column: string, dataType: OperationNode): ColumnDefinitionNode;
-    cloneWithFrontModifier(node: ColumnDefinitionNode, modifier: OperationNode): ColumnDefinitionNode;
-    cloneWithEndModifier(node: ColumnDefinitionNode, modifier: OperationNode): ColumnDefinitionNode;
-    cloneWith(node: ColumnDefinitionNode, props: ColumnDefinitionNodeProps): ColumnDefinitionNode;
-}>;
+export declare const ColumnDefinitionNode: ColumnDefinitionNodeFactory;
+export {};

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

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

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

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

package/dist/esm/operation-node/common-table-expression-name-node.d.ts

@@ -1,15 +1,17 @@
 import { ColumnNode } from './column-node.js';
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 export interface CommonTableExpressionNameNode extends OperationNode {
     readonly kind: 'CommonTableExpressionNameNode';
     readonly table: TableNode;
     readonly columns?: ReadonlyArray<ColumnNode>;
 }
+type CommonTableExpressionNameNodeFactory = Readonly<{
+    is(node: OperationNode): node is CommonTableExpressionNameNode;
+    create(tableName: string, columnNames?: ReadonlyArray<string>): Readonly<CommonTableExpressionNameNode>;
+}>;
 /**
  * @internal
  */
-export declare const CommonTableExpressionNameNode: Readonly<{
-    is(node: OperationNode): node is CommonTableExpressionNameNode;
-    create(tableName: string, columnNames?: ReadonlyArray<string>): CommonTableExpressionNameNode;
-}>;
+export declare const CommonTableExpressionNameNode: CommonTableExpressionNameNodeFactory;
+export {};

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

@@ -1,5 +1,5 @@
-import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
-import { OperationNode } from './operation-node.js';
+import type { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
+import type { OperationNode } from './operation-node.js';
 type CommonTableExpressionNodeProps = Pick<CommonTableExpressionNode, 'materialized'>;
 export interface CommonTableExpressionNode extends OperationNode {
     readonly kind: 'CommonTableExpressionNode';
@@ -7,12 +7,13 @@ export interface CommonTableExpressionNode extends OperationNode {
     readonly materialized?: boolean;
     readonly expression: OperationNode;
 }
+type CommonTableExpressionNodeFactory = Readonly<{
+    is(node: OperationNode): node is CommonTableExpressionNode;
+    create(name: CommonTableExpressionNameNode, expression: OperationNode): Readonly<CommonTableExpressionNode>;
+    cloneWith(node: CommonTableExpressionNode, props: CommonTableExpressionNodeProps): Readonly<CommonTableExpressionNode>;
+}>;
 /**
  * @internal
  */
-export declare const CommonTableExpressionNode: Readonly<{
-    is(node: OperationNode): node is CommonTableExpressionNode;
-    create(name: CommonTableExpressionNameNode, expression: OperationNode): CommonTableExpressionNode;
-    cloneWith(node: CommonTableExpressionNode, props: CommonTableExpressionNodeProps): CommonTableExpressionNode;
-}>;
+export declare const CommonTableExpressionNode: CommonTableExpressionNodeFactory;
 export {};