kysely 0.2.4 → 0.2.5

package/lib/operation-node/column-definition-node.d.ts

@@ -0,0 +1,29 @@
+import { CheckConstraintNode } from './check-constraint-node';
+import { ColumnNode } from './column-node';
+import { DataTypeNode } from './data-type-node';
+import { OperationNode } from './operation-node';
+import { RawNode } from './raw-node';
+import { ReferencesNode } from './references-node';
+import { ValueNode } from './value-node';
+export declare type ColumnDefinitionNodeParams = Omit<Partial<ColumnDefinitionNode>, 'kind'>;
+export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
+export interface ColumnDefinitionNode extends OperationNode {
+    readonly kind: 'ColumnDefinitionNode';
+    readonly column: ColumnNode;
+    readonly dataType: ColumnDataTypeNode;
+    readonly references?: ReferencesNode;
+    readonly isPrimaryKey: boolean;
+    readonly isAutoIncrementing: boolean;
+    readonly isUnique: boolean;
+    readonly isNullable: boolean;
+    readonly defaultTo?: ValueNode | RawNode;
+    readonly check?: CheckConstraintNode;
+}
+/**
+ * @internal
+ */
+export declare const columnDefinitionNode: Readonly<{
+    is(node: OperationNode): node is ColumnDefinitionNode;
+    create(column: string, dataType: ColumnDataTypeNode): ColumnDefinitionNode;
+    cloneWith(node: ColumnDefinitionNode, params: ColumnDefinitionNodeParams): ColumnDefinitionNode;
+}>;

package/lib/operation-node/column-definition-node.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.columnDefinitionNode = void 0;
+const object_utils_1 = require("../util/object-utils");
+const column_node_1 = require("./column-node");
+/**
+ * @internal
+ */
+exports.columnDefinitionNode = object_utils_1.freeze({
+    is(node) {
+        return node.kind === 'ColumnDefinitionNode';
+    },
+    create(column, dataType) {
+        return object_utils_1.freeze({
+            kind: 'ColumnDefinitionNode',
+            column: column_node_1.columnNode.create(column),
+            dataType,
+            isPrimaryKey: false,
+            isAutoIncrementing: false,
+            isUnique: false,
+            isNullable: true,
+        });
+    },
+    cloneWith(node, params) {
+        return object_utils_1.freeze({
+            ...node,
+            ...params,
+        });
+    },
+});

package/lib/operation-node/column-node.d.ts

@@ -4,6 +4,9 @@ export interface ColumnNode extends OperationNode {
     readonly kind: 'ColumnNode';
     readonly column: IdentifierNode;
 }
+/**
+ * @internal
+ */
 export declare const columnNode: Readonly<{
     is(node: OperationNode): node is ColumnNode;
     create(column: string): ColumnNode;

package/lib/operation-node/column-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.columnNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const identifier_node_1 = require("./identifier-node");
+/**
+ * @internal
+ */
 exports.columnNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'ColumnNode';

package/lib/operation-node/column-update-node.d.ts

@@ -6,6 +6,9 @@ export interface ColumnUpdateNode extends OperationNode {
     readonly column: ColumnNode;
     readonly value: ValueExpressionNode;
 }
+/**
+ * @internal
+ */
 export declare const columnUpdateNode: Readonly<{
     is(node: OperationNode): node is ColumnUpdateNode;
     create(column: ColumnNode, value: ValueExpressionNode): ColumnUpdateNode;

package/lib/operation-node/column-update-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.columnUpdateNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.columnUpdateNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'ColumnUpdateNode';

package/lib/operation-node/common-table-expression-node.d.ts

@@ -7,6 +7,9 @@ export interface CommonTableExpressionNode extends OperationNode {
     readonly name: IdentifierNode;
     readonly expression: QueryNode | RawNode;
 }
+/**
+ * @internal
+ */
 export declare const commonTableExpressionNode: Readonly<{
     is(node: OperationNode): node is CommonTableExpressionNode;
     create(name: IdentifierNode, expression: QueryNode | RawNode): CommonTableExpressionNode;

package/lib/operation-node/common-table-expression-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonTableExpressionNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.commonTableExpressionNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'CommonTableExpressionNode';

package/lib/operation-node/constraint-node.d.ts

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

package/lib/operation-node/constraint-node.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/operation-node/create-index-node.d.ts

@@ -14,6 +14,9 @@ export interface CreateIndexNode extends OperationNode {
     readonly unique?: boolean;
     readonly using?: RawNode;
 }
+/**
+ * @internal
+ */
 export declare const createIndexNode: Readonly<{
     is(node: OperationNode): node is CreateIndexNode;
     create(name: string): CreateIndexNode;

package/lib/operation-node/create-index-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createIndexNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const identifier_node_1 = require("./identifier-node");
+/**
+ * @internal
+ */
 exports.createIndexNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'CreateIndexNode';

package/lib/operation-node/create-schema-node.d.ts

@@ -7,6 +7,9 @@ export interface CreateSchemaNode extends OperationNode {
     readonly schema: IdentifierNode;
     readonly modifier?: CreateSchemaNodeModifier;
 }
+/**
+ * @internal
+ */
 export declare const createSchemaNode: Readonly<{
     is(node: OperationNode): node is CreateSchemaNode;
     create(schema: string, params?: CreateSchemaNodeParams | undefined): CreateSchemaNode;

package/lib/operation-node/create-schema-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSchemaNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const identifier_node_1 = require("./identifier-node");
+/**
+ * @internal
+ */
 exports.createSchemaNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'CreateSchemaNode';

package/lib/operation-node/create-table-node.d.ts

@@ -1,25 +1,25 @@
-import { CheckConstraintNode } from './check-constraint-node';
-import { AddColumnNode } from './add-column-node';
 import { OperationNode } from './operation-node';
 import { TableNode } from './table-node';
-import { PrimaryKeyConstraintNode } from './primary-constraint-node';
-import { UniqueConstraintNode } from './unique-constraint-node';
+import { ConstraintNode } from './constraint-node';
+import { ColumnDefinitionNode } from './column-definition-node';
 export declare type CreateTableNodeModifier = 'IfNotExists';
 export interface CreateTableNode extends OperationNode {
     readonly kind: 'CreateTableNode';
     readonly table: TableNode;
-    readonly columns: ReadonlyArray<AddColumnNode>;
+    readonly columns: ReadonlyArray<ColumnDefinitionNode>;
     readonly modifier?: CreateTableNodeModifier;
-    readonly primaryKeyConstraint?: PrimaryKeyConstraintNode;
-    readonly uniqueConstraints?: ReadonlyArray<UniqueConstraintNode>;
-    readonly checkConstraints?: ReadonlyArray<CheckConstraintNode>;
+    readonly constraints?: ReadonlyArray<ConstraintNode>;
 }
+/**
+ * @internal
+ */
 export declare const createTableNode: Readonly<{
     is(node: OperationNode): node is CreateTableNode;
     create(table: TableNode): CreateTableNode;
-    cloneWithColumn(createTable: CreateTableNode, column: AddColumnNode): CreateTableNode;
+    cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
     cloneWithModifier(createTable: CreateTableNode, modifier: CreateTableNodeModifier): CreateTableNode;
     cloneWithPrimaryKeyConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
     cloneWithUniqueConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
     cloneWithCheckConstraint(createTable: CreateTableNode, constraintName: string, sql: string): CreateTableNode;
+    cloneWithForeignKeyConstraint(createTable: CreateTableNode, constraintName: string, sourceColumns: string[], targetTable: string, targetColumns: string[]): CreateTableNode;
 }>;

package/lib/operation-node/create-table-node.js

@@ -3,8 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTableNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const check_constraint_node_1 = require("./check-constraint-node");
+const table_node_1 = require("./table-node");
 const primary_constraint_node_1 = require("./primary-constraint-node");
 const unique_constraint_node_1 = require("./unique-constraint-node");
+const foreign_key_constraint_node_1 = require("./foreign-key-constraint-node");
+const column_node_1 = require("./column-node");
+/**
+ * @internal
+ */
 exports.createTableNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'CreateTableNode';
@@ -29,17 +35,20 @@ exports.createTableNode = object_utils_1.freeze({
         });
     },
     cloneWithPrimaryKeyConstraint(createTable, constraintName, columns) {
+        const constraint = primary_constraint_node_1.primaryConstraintNode.create(columns, constraintName);
         return object_utils_1.freeze({
             ...createTable,
-            primaryKeyConstraint: primary_constraint_node_1.primaryConstraintNode.create(columns, constraintName),
+            constraints: createTable.constraints
+                ? object_utils_1.freeze([...createTable.constraints, constraint])
+                : object_utils_1.freeze([constraint]),
         });
     },
     cloneWithUniqueConstraint(createTable, constraintName, columns) {
         const constraint = unique_constraint_node_1.uniqueConstraintNode.create(columns, constraintName);
         return object_utils_1.freeze({
             ...createTable,
-            uniqueConstraints: createTable.uniqueConstraints
-                ? object_utils_1.freeze([...createTable.uniqueConstraints, constraint])
+            constraints: createTable.constraints
+                ? object_utils_1.freeze([...createTable.constraints, constraint])
                 : object_utils_1.freeze([constraint]),
         });
     },
@@ -47,8 +56,17 @@ exports.createTableNode = object_utils_1.freeze({
         const constraint = check_constraint_node_1.checkConstraintNode.create(sql, constraintName);
         return object_utils_1.freeze({
             ...createTable,
-            checkConstraints: createTable.checkConstraints
-                ? object_utils_1.freeze([...createTable.checkConstraints, constraint])
+            constraints: createTable.constraints
+                ? object_utils_1.freeze([...createTable.constraints, constraint])
+                : object_utils_1.freeze([constraint]),
+        });
+    },
+    cloneWithForeignKeyConstraint(createTable, constraintName, sourceColumns, targetTable, targetColumns) {
+        const constraint = foreign_key_constraint_node_1.foreignKeyConstraintNode.create(sourceColumns.map(column_node_1.columnNode.create), table_node_1.tableNode.create(targetTable), targetColumns.map(column_node_1.columnNode.create), constraintName);
+        return object_utils_1.freeze({
+            ...createTable,
+            constraints: createTable.constraints
+                ? object_utils_1.freeze([...createTable.constraints, constraint])
                 : object_utils_1.freeze([constraint]),
         });
     },

package/lib/operation-node/data-type-node.d.ts

@@ -5,6 +5,9 @@ export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';
     readonly dataType: ColumnDataType;
 }
+/**
+ * @internal
+ */
 export declare const dataTypeNode: Readonly<{
     is(node: OperationNode): node is DataTypeNode;
     create(dataType: ColumnDataType): DataTypeNode;

package/lib/operation-node/data-type-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dataTypeNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.dataTypeNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'DataTypeNode';

package/lib/operation-node/delete-query-node.d.ts

@@ -13,6 +13,9 @@ export interface DeleteQueryNode extends OperationNode {
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
 }
+/**
+ * @internal
+ */
 export declare const deleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
     create(fromItem: TableExpressionNode, withNode?: WithNode | undefined): DeleteQueryNode;

package/lib/operation-node/delete-query-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteQueryNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const from_node_1 = require("./from-node");
+/**
+ * @internal
+ */
 exports.deleteQueryNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'DeleteQueryNode';

package/lib/operation-node/drop-column-node.d.ts

@@ -4,6 +4,9 @@ export interface DropColumnNode extends OperationNode {
     readonly kind: 'DropColumnNode';
     readonly column: ColumnNode;
 }
+/**
+ * @internal
+ */
 export declare const dropColumnNode: Readonly<{
     is(node: OperationNode): node is DropColumnNode;
     create(column: string): DropColumnNode;

package/lib/operation-node/drop-column-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dropColumnNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const column_node_1 = require("./column-node");
+/**
+ * @internal
+ */
 exports.dropColumnNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'DropColumnNode';

package/lib/operation-node/drop-constraint-node.d.ts

@@ -4,6 +4,9 @@ export interface DropConstraintNode extends OperationNode {
     readonly kind: 'DropConstraintNode';
     readonly constraintName: IdentifierNode;
 }
+/**
+ * @internal
+ */
 export declare const dropConstraintNode: Readonly<{
     is(node: OperationNode): node is DropConstraintNode;
     create(constraintName: string): DropConstraintNode;

package/lib/operation-node/drop-constraint-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dropConstraintNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const identifier_node_1 = require("./identifier-node");
+/**
+ * @internal
+ */
 exports.dropConstraintNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'DropConstraintNode';

package/lib/operation-node/drop-index-node.d.ts

@@ -7,6 +7,9 @@ export interface DropIndexNode extends OperationNode {
     readonly name: IdentifierNode;
     readonly modifier?: DropIndexNodeModifier;
 }
+/**
+ * @internal
+ */
 export declare const dropIndexNode: Readonly<{
     is(node: OperationNode): node is DropIndexNode;
     create(name: string, params?: DropIndexNodeParams | undefined): DropIndexNode;

package/lib/operation-node/drop-index-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dropIndexNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const identifier_node_1 = require("./identifier-node");
+/**
+ * @internal
+ */
 exports.dropIndexNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'DropIndexNode';

package/lib/operation-node/drop-schema-node.d.ts

@@ -7,6 +7,9 @@ export interface DropSchemaNode extends OperationNode {
     readonly schema: IdentifierNode;
     readonly modifier?: DropSchemaNodeModifier;
 }
+/**
+ * @internal
+ */
 export declare const dropSchemaNode: Readonly<{
     is(node: OperationNode): node is DropSchemaNode;
     create(schema: string, params?: DropSchemaNodeParams | undefined): DropSchemaNode;

package/lib/operation-node/drop-schema-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dropSchemaNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const identifier_node_1 = require("./identifier-node");
+/**
+ * @internal
+ */
 exports.dropSchemaNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'DropSchemaNode';

package/lib/operation-node/drop-table-node.d.ts

@@ -1,14 +1,17 @@
 import { OperationNode } from './operation-node';
 import { TableNode } from './table-node';
-export declare type DropIndexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
+export declare type DropTablexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
 export declare type DropTableNodeModifier = 'IfExists';
 export interface DropTableNode extends OperationNode {
     readonly kind: 'DropTableNode';
     readonly table: TableNode;
     readonly modifier?: DropTableNodeModifier;
 }
+/**
+ * @internal
+ */
 export declare const dropTableNode: Readonly<{
     is(node: OperationNode): node is DropTableNode;
-    create(table: TableNode, params?: DropIndexNodeParams | undefined): DropTableNode;
+    create(table: TableNode, params?: DropTablexNodeParams | undefined): DropTableNode;
     cloneWithModifier(dropIndex: DropTableNode, modifier: DropTableNodeModifier): DropTableNode;
 }>;

package/lib/operation-node/drop-table-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dropTableNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.dropTableNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'DropTableNode';

package/lib/operation-node/filter-node.d.ts

@@ -9,6 +9,9 @@ export interface FilterNode extends OperationNode {
     readonly op: OperatorNode | RawNode;
     readonly right: ValueExpressionNode;
 }
+/**
+ * @internal
+ */
 export declare const filterNode: Readonly<{
     is(node: OperationNode): node is FilterNode;
     create(left: ReferenceExpressionNode | undefined, op: OperatorNode | RawNode, right: ValueExpressionNode): FilterNode;

package/lib/operation-node/filter-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.filterNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'FilterNode';

package/lib/operation-node/foreign-key-constraint-node.d.ts

@@ -5,10 +5,14 @@ import { ReferencesNode } from './references-node';
 import { TableNode } from './table-node';
 export interface ForeignKeyConstraintNode extends OperationNode {
     readonly kind: 'ForeignKeyConstraintNode';
+    readonly columns: ReadonlyArray<ColumnNode>;
     readonly references: ReferencesNode;
     readonly name?: IdentifierNode;
 }
+/**
+ * @internal
+ */
 export declare const foreignKeyConstraintNode: Readonly<{
     is(node: OperationNode): node is ForeignKeyConstraintNode;
-    create(table: TableNode, column: ColumnNode, constraintName?: string | undefined): ForeignKeyConstraintNode;
+    create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string | undefined): ForeignKeyConstraintNode;
 }>;

package/lib/operation-node/foreign-key-constraint-node.js

@@ -4,14 +4,18 @@ exports.foreignKeyConstraintNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const identifier_node_1 = require("./identifier-node");
 const references_node_1 = require("./references-node");
+/**
+ * @internal
+ */
 exports.foreignKeyConstraintNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'ForeignKeyConstraintNode';
     },
-    create(table, column, constraintName) {
+    create(sourceColumns, targetTable, targetColumns, constraintName) {
         return object_utils_1.freeze({
             kind: 'ForeignKeyConstraintNode',
-            references: references_node_1.referencesNode.create(table, column),
+            columns: sourceColumns,
+            references: references_node_1.referencesNode.create(targetTable, targetColumns),
             name: constraintName ? identifier_node_1.identifierNode.create(constraintName) : undefined,
         });
     },

package/lib/operation-node/from-node.d.ts

@@ -4,6 +4,9 @@ export interface FromNode extends OperationNode {
     readonly kind: 'FromNode';
     readonly froms: ReadonlyArray<TableExpressionNode>;
 }
+/**
+ * @internal
+ */
 export declare const fromNode: Readonly<{
     is(node: OperationNode): node is FromNode;
     create(froms: ReadonlyArray<TableExpressionNode>): FromNode;

package/lib/operation-node/from-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fromNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.fromNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'FromNode';

package/lib/operation-node/group-by-item-node.d.ts

@@ -4,6 +4,9 @@ export interface GroupByItemNode extends OperationNode {
     readonly kind: 'GroupByItemNode';
     readonly groupBy: ReferenceExpressionNode;
 }
+/**
+ * @internal
+ */
 export declare const groupByItemNode: Readonly<{
     is(node: OperationNode): node is GroupByItemNode;
     create(groupBy: ReferenceExpressionNode): GroupByItemNode;

package/lib/operation-node/group-by-item-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupByItemNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.groupByItemNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'GroupByItemNode';

package/lib/operation-node/group-by-node.d.ts

@@ -4,6 +4,9 @@ export interface GroupByNode extends OperationNode {
     readonly kind: 'GroupByNode';
     readonly items: ReadonlyArray<GroupByItemNode>;
 }
+/**
+ * @internal
+ */
 export declare const groupByNode: Readonly<{
     is(node: OperationNode): node is GroupByNode;
     create(items: ReadonlyArray<GroupByItemNode>): GroupByNode;

package/lib/operation-node/group-by-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupByNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.groupByNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'GroupByNode';

package/lib/operation-node/having-node.d.ts

@@ -8,6 +8,9 @@ export interface HavingNode extends OperationNode {
     readonly kind: 'HavingNode';
     readonly having: HavingNodeChild;
 }
+/**
+ * @internal
+ */
 export declare const havingNode: Readonly<{
     is(node: OperationNode): node is HavingNode;
     create(filter: HavingNodeChild): HavingNode;

package/lib/operation-node/having-node.js

@@ -4,6 +4,9 @@ exports.havingNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const and_node_1 = require("./and-node");
 const or_node_1 = require("./or-node");
+/**
+ * @internal
+ */
 exports.havingNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'HavingNode';

package/lib/operation-node/identifier-node.d.ts

@@ -3,6 +3,9 @@ export interface IdentifierNode extends OperationNode {
     readonly kind: 'IdentifierNode';
     readonly identifier: string;
 }
+/**
+ * @internal
+ */
 export declare const identifierNode: Readonly<{
     is(node: OperationNode): node is IdentifierNode;
     create(identifier: string): IdentifierNode;

package/lib/operation-node/identifier-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.identifierNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.identifierNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'IdentifierNode';

package/lib/operation-node/insert-query-node.d.ts

@@ -17,6 +17,9 @@ export interface InsertQueryNode extends OperationNode {
     readonly onConflict?: OnConflictNode;
     readonly with?: WithNode;
 }
+/**
+ * @internal
+ */
 export declare const insertQueryNode: Readonly<{
     is(node: OperationNode): node is InsertQueryNode;
     create(into: TableNode, withNode?: WithNode | undefined): InsertQueryNode;

package/lib/operation-node/insert-query-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.insertQueryNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const on_conflict_node_1 = require("./on-conflict-node");
+/**
+ * @internal
+ */
 exports.insertQueryNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'InsertQueryNode';