kysely 0.28.8 → 0.28.10

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

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

@@ -1,8 +1,8 @@
-import { ColumnNode } from './column-node.js';
-import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
+import type { ColumnNode } from './column-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { RawNode } from './raw-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
-import { SelectQueryNode } from './select-query-node.js';
+import type { SelectQueryNode } from './select-query-node.js';
 export type CreateViewNodeParams = Omit<Partial<CreateViewNode>, 'kind' | 'name'>;
 export interface CreateViewNode extends OperationNode {
     readonly kind: 'CreateViewNode';
@@ -14,11 +14,13 @@ export interface CreateViewNode extends OperationNode {
     readonly columns?: ReadonlyArray<ColumnNode>;
     readonly as?: SelectQueryNode | RawNode;
 }
+type CreateViewNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateViewNode;
+    create(name: string): Readonly<CreateViewNode>;
+    cloneWith(createView: CreateViewNode, params: CreateViewNodeParams): Readonly<CreateViewNode>;
+}>;
 /**
  * @internal
  */
-export declare const CreateViewNode: Readonly<{
-    is(node: OperationNode): node is CreateViewNode;
-    create(name: string): CreateViewNode;
-    cloneWith(createView: CreateViewNode, params: CreateViewNodeParams): CreateViewNode;
-}>;
+export declare const CreateViewNode: CreateViewNodeFactory;
+export {};

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

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 declare const SIMPLE_COLUMN_DATA_TYPES: readonly ["varchar", "char", "text", "integer", "int2", "int4", "int8", "smallint", "bigint", "boolean", "real", "double precision", "float4", "float8", "decimal", "numeric", "binary", "bytea", "date", "datetime", "time", "timetz", "timestamp", "timestamptz", "serial", "bigserial", "uuid", "json", "jsonb", "blob", "varbinary", "int4range", "int4multirange", "int8range", "int8multirange", "numrange", "nummultirange", "tsrange", "tsmultirange", "tstzrange", "tstzmultirange", "daterange", "datemultirange"];
 type SimpleColumnDataType = (typeof SIMPLE_COLUMN_DATA_TYPES)[number];
 export type ColumnDataType = SimpleColumnDataType | `varchar(${number})` | `char(${number})` | `decimal(${number}, ${number})` | `numeric(${number}, ${number})` | `binary(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`;
@@ -7,12 +7,13 @@ export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';
     readonly dataType: ColumnDataType;
 }
+type DataTypeNodeFactory = Readonly<{
+    is(node: OperationNode): node is DataTypeNode;
+    create(dataType: ColumnDataType): Readonly<DataTypeNode>;
+}>;
 /**
  * @internal
  */
-export declare const DataTypeNode: Readonly<{
-    is(node: OperationNode): node is DataTypeNode;
-    create(dataType: ColumnDataType): DataTypeNode;
-}>;
+export declare const DataTypeNode: DataTypeNodeFactory;
 export declare function isColumnDataType(dataType: string): dataType is ColumnDataType;
 export {};

package/dist/esm/operation-node/default-insert-value-node.d.ts

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

package/dist/esm/operation-node/default-value-node.d.ts

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

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

@@ -1,16 +1,16 @@
 import { FromNode } from './from-node.js';
-import { JoinNode } from './join-node.js';
-import { OperationNode } from './operation-node.js';
-import { ReturningNode } from './returning-node.js';
-import { WhereNode } from './where-node.js';
-import { WithNode } from './with-node.js';
-import { LimitNode } from './limit-node.js';
-import { OrderByNode } from './order-by-node.js';
-import { OrderByItemNode } from './order-by-item-node.js';
-import { ExplainNode } from './explain-node.js';
+import type { JoinNode } from './join-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ReturningNode } from './returning-node.js';
+import type { WhereNode } from './where-node.js';
+import type { WithNode } from './with-node.js';
+import type { LimitNode } from './limit-node.js';
+import type { OrderByNode } from './order-by-node.js';
+import type { OrderByItemNode } from './order-by-item-node.js';
+import type { ExplainNode } from './explain-node.js';
 import { UsingNode } from './using-node.js';
-import { TopNode } from './top-node.js';
-import { OutputNode } from './output-node.js';
+import type { TopNode } from './top-node.js';
+import type { OutputNode } from './output-node.js';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
@@ -26,21 +26,17 @@ export interface DeleteQueryNode extends OperationNode {
     readonly top?: TopNode;
     readonly output?: OutputNode;
 }
+type DeleteQueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is DeleteQueryNode;
+    create(fromItems: OperationNode[], withNode?: WithNode): Readonly<DeleteQueryNode>;
+    cloneWithOrderByItems(node: DeleteQueryNode, items: ReadonlyArray<OrderByItemNode>): Readonly<DeleteQueryNode>;
+    cloneWithoutOrderBy(node: DeleteQueryNode): Readonly<DeleteQueryNode>;
+    cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): Readonly<DeleteQueryNode>;
+    cloneWithoutLimit(deleteNode: DeleteQueryNode): Readonly<DeleteQueryNode>;
+    cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): Readonly<DeleteQueryNode>;
+}>;
 /**
  * @internal
  */
-export declare const DeleteQueryNode: Readonly<{
-    is(node: OperationNode): node is DeleteQueryNode;
-    create(fromItems: OperationNode[], withNode?: WithNode): DeleteQueryNode;
-    /**
-     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
-     */
-    cloneWithOrderByItems: (node: DeleteQueryNode, items: ReadonlyArray<OrderByItemNode>) => DeleteQueryNode;
-    /**
-     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
-     */
-    cloneWithoutOrderBy: (node: DeleteQueryNode) => DeleteQueryNode;
-    cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
-    cloneWithoutLimit(deleteNode: DeleteQueryNode): DeleteQueryNode;
-    cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;
-}>;
+export declare const DeleteQueryNode: DeleteQueryNodeFactory;
+export {};

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

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

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

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { IdentifierNode } from './identifier-node.js';
 export type DropConstraintNodeProps = Omit<DropConstraintNode, 'kind' | 'constraintName'>;
 export interface DropConstraintNode extends OperationNode {
@@ -7,11 +7,13 @@ export interface DropConstraintNode extends OperationNode {
     readonly ifExists?: boolean;
     readonly modifier?: 'cascade' | 'restrict';
 }
+type DropConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropConstraintNode;
+    create(constraintName: string, params?: DropConstraintNodeProps): Readonly<DropConstraintNode>;
+    cloneWith(dropConstraint: DropConstraintNode, props: DropConstraintNodeProps): Readonly<DropConstraintNode>;
+}>;
 /**
  * @internal
  */
-export declare const DropConstraintNode: Readonly<{
-    is(node: OperationNode): node is DropConstraintNode;
-    create(constraintName: string): DropConstraintNode;
-    cloneWith(dropConstraint: DropConstraintNode, props: DropConstraintNodeProps): DropConstraintNode;
-}>;
+export declare const DropConstraintNode: DropConstraintNodeFactory;
+export {};

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

@@ -1,6 +1,6 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
-import { TableNode } from './table-node.js';
+import type { TableNode } from './table-node.js';
 export type DropIndexNodeProps = Omit<DropIndexNode, 'kind' | 'name'>;
 export interface DropIndexNode extends OperationNode {
     readonly kind: 'DropIndexNode';
@@ -9,11 +9,13 @@ export interface DropIndexNode extends OperationNode {
     readonly ifExists?: boolean;
     readonly cascade?: boolean;
 }
+type DropIndexNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropIndexNode;
+    create(name: string, params?: DropIndexNodeProps): Readonly<DropIndexNode>;
+    cloneWith(dropIndex: DropIndexNode, props: DropIndexNodeProps): Readonly<DropIndexNode>;
+}>;
 /**
  * @internal
  */
-export declare const DropIndexNode: Readonly<{
-    is(node: OperationNode): node is DropIndexNode;
-    create(name: string, params?: DropIndexNodeProps): DropIndexNode;
-    cloneWith(dropIndex: DropIndexNode, props: DropIndexNodeProps): DropIndexNode;
-}>;
+export declare const DropIndexNode: DropIndexNodeFactory;
+export {};

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

@@ -1,5 +1,5 @@
 import { IdentifierNode } from './identifier-node.js';
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export type DropSchemaNodeParams = Omit<Partial<DropSchemaNode>, 'kind' | 'schema'>;
 export interface DropSchemaNode extends OperationNode {
     readonly kind: 'DropSchemaNode';
@@ -7,11 +7,13 @@ export interface DropSchemaNode extends OperationNode {
     readonly ifExists?: boolean;
     readonly cascade?: boolean;
 }
+type DropSchemaNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropSchemaNode;
+    create(schema: string, params?: DropSchemaNodeParams): Readonly<DropSchemaNode>;
+    cloneWith(dropSchema: DropSchemaNode, params: DropSchemaNodeParams): Readonly<DropSchemaNode>;
+}>;
 /**
  * @internal
  */
-export declare const DropSchemaNode: Readonly<{
-    is(node: OperationNode): node is DropSchemaNode;
-    create(schema: string, params?: DropSchemaNodeParams): DropSchemaNode;
-    cloneWith(dropSchema: DropSchemaNode, params: DropSchemaNodeParams): DropSchemaNode;
-}>;
+export declare const DropSchemaNode: DropSchemaNodeFactory;
+export {};

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

@@ -1,5 +1,5 @@
-import { OperationNode } from './operation-node.js';
-import { TableNode } from './table-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { TableNode } from './table-node.js';
 export type DropTablexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
 export interface DropTableNode extends OperationNode {
     readonly kind: 'DropTableNode';
@@ -7,11 +7,13 @@ export interface DropTableNode extends OperationNode {
     readonly ifExists?: boolean;
     readonly cascade?: boolean;
 }
+type DropTableNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropTableNode;
+    create(table: TableNode, params?: DropTablexNodeParams): Readonly<DropTableNode>;
+    cloneWith(dropIndex: DropTableNode, params: DropTablexNodeParams): Readonly<DropTableNode>;
+}>;
 /**
  * @internal
  */
-export declare const DropTableNode: Readonly<{
-    is(node: OperationNode): node is DropTableNode;
-    create(table: TableNode, params?: DropTablexNodeParams): DropTableNode;
-    cloneWith(dropIndex: DropTableNode, params: DropTablexNodeParams): DropTableNode;
-}>;
+export declare const DropTableNode: DropTableNodeFactory;
+export {};

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

@@ -1,16 +1,18 @@
-import { OperationNode } from './operation-node.js';
-import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { SchemableIdentifierNode } from './schemable-identifier-node.js';
 export type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name'>;
 export interface DropTypeNode extends OperationNode {
     readonly kind: 'DropTypeNode';
     readonly name: SchemableIdentifierNode;
     readonly ifExists?: boolean;
 }
+type DropTypeNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropTypeNode;
+    create(name: SchemableIdentifierNode): Readonly<DropTypeNode>;
+    cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): Readonly<DropTypeNode>;
+}>;
 /**
  * @internal
  */
-export declare const DropTypeNode: Readonly<{
-    is(node: OperationNode): node is DropTypeNode;
-    create(name: SchemableIdentifierNode): DropTypeNode;
-    cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): DropTypeNode;
-}>;
+export declare const DropTypeNode: DropTypeNodeFactory;
+export {};

package/dist/esm/operation-node/drop-view-node.d.ts

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 export type DropViewNodeParams = Omit<Partial<DropViewNode>, 'kind' | 'name'>;
 export interface DropViewNode extends OperationNode {
@@ -8,11 +8,13 @@ export interface DropViewNode extends OperationNode {
     readonly materialized?: boolean;
     readonly cascade?: boolean;
 }
+type DropViewNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropViewNode;
+    create(name: string): Readonly<DropViewNode>;
+    cloneWith(dropView: DropViewNode, params: DropViewNodeParams): Readonly<DropViewNode>;
+}>;
 /**
  * @internal
  */
-export declare const DropViewNode: Readonly<{
-    is(node: OperationNode): node is DropViewNode;
-    create(name: string): DropViewNode;
-    cloneWith(dropView: DropViewNode, params: DropViewNodeParams): DropViewNode;
-}>;
+export declare const DropViewNode: DropViewNodeFactory;
+export {};

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

@@ -1,14 +1,16 @@
-import { ExplainFormat } from '../util/explainable.js';
-import { OperationNode } from './operation-node.js';
+import type { ExplainFormat } from '../util/explainable.js';
+import type { OperationNode } from './operation-node.js';
 export interface ExplainNode extends OperationNode {
     readonly kind: 'ExplainNode';
     readonly format?: ExplainFormat;
     readonly options?: OperationNode;
 }
+type ExplainNodeFactory = Readonly<{
+    is(node: OperationNode): node is ExplainNode;
+    create(format?: ExplainFormat, options?: OperationNode): Readonly<ExplainNode>;
+}>;
 /**
  * @internal
  */
-export declare const ExplainNode: Readonly<{
-    is(node: OperationNode): node is ExplainNode;
-    create(format?: ExplainFormat, options?: OperationNode): ExplainNode;
-}>;
+export declare const ExplainNode: ExplainNodeFactory;
+export {};