kysely 0.28.8 → 0.28.9

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 {};

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

@@ -1,5 +1,5 @@
-import { CheckConstraintNode } from './check-constraint-node.js';
-import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
-import { PrimaryKeyConstraintNode } from './primary-key-constraint-node.js';
-import { UniqueConstraintNode } from './unique-constraint-node.js';
+import type { CheckConstraintNode } from './check-constraint-node.js';
+import type { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
+import type { PrimaryKeyConstraintNode } from './primary-key-constraint-node.js';
+import type { UniqueConstraintNode } from './unique-constraint-node.js';
 export type ConstraintNode = PrimaryKeyConstraintNode | UniqueConstraintNode | CheckConstraintNode | ForeignKeyConstraintNode;

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

@@ -1,8 +1,8 @@
 import { IdentifierNode } from './identifier-node.js';
-import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-import { TableNode } from './table-node.js';
-import { WhereNode } from './where-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { RawNode } from './raw-node.js';
+import type { TableNode } from './table-node.js';
+import type { WhereNode } from './where-node.js';
 export type CreateIndexNodeProps = Omit<CreateIndexNode, 'kind' | 'name'>;
 export type IndexType = 'btree' | 'hash' | 'gist' | 'gin';
 export interface CreateIndexNode extends OperationNode {
@@ -16,12 +16,14 @@ export interface CreateIndexNode extends OperationNode {
     readonly where?: WhereNode;
     readonly nullsNotDistinct?: boolean;
 }
+type CreateIndexNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateIndexNode;
+    create(name: string): Readonly<CreateIndexNode>;
+    cloneWith(node: CreateIndexNode, props: CreateIndexNodeProps): Readonly<CreateIndexNode>;
+    cloneWithColumns(node: CreateIndexNode, columns: OperationNode[]): Readonly<CreateIndexNode>;
+}>;
 /**
  * @internal
  */
-export declare const CreateIndexNode: Readonly<{
-    is(node: OperationNode): node is CreateIndexNode;
-    create(name: string): CreateIndexNode;
-    cloneWith(node: CreateIndexNode, props: CreateIndexNodeProps): CreateIndexNode;
-    cloneWithColumns(node: CreateIndexNode, columns: OperationNode[]): CreateIndexNode;
-}>;
+export declare const CreateIndexNode: CreateIndexNodeFactory;
+export {};

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

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

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

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

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

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