noormme 1.0.0

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

@@ -0,0 +1,40 @@
+import { ColumnNode } from './column-node.js';
+import { ExplainNode } from './explain-node.js';
+import { OnConflictNode } from './on-conflict-node.js';
+import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
+import { OperationNode } from './operation-node.js';
+import { OrActionNode } from './or-action-node.js';
+import { OutputNode } from './output-node.js';
+import { ReturningNode } from './returning-node.js';
+import { TableNode } from './table-node.js';
+import { TopNode } from './top-node.js';
+import { WithNode } from './with-node.js';
+export type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
+export interface InsertQueryNode extends OperationNode {
+    readonly kind: 'InsertQueryNode';
+    readonly into?: TableNode;
+    readonly columns?: ReadonlyArray<ColumnNode>;
+    readonly values?: OperationNode;
+    readonly returning?: ReturningNode;
+    readonly onConflict?: OnConflictNode;
+    readonly onDuplicateKey?: OnDuplicateKeyNode;
+    readonly with?: WithNode;
+    /** @deprecated use {@link orAction} instead. */
+    readonly ignore?: boolean;
+    readonly orAction?: OrActionNode;
+    readonly replace?: boolean;
+    readonly explain?: ExplainNode;
+    readonly defaultValues?: boolean;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
+    readonly top?: TopNode;
+    readonly output?: OutputNode;
+}
+/**
+ * @internal
+ */
+export declare const InsertQueryNode: Readonly<{
+    is(node: OperationNode): node is InsertQueryNode;
+    create(into: TableNode, withNode?: WithNode, replace?: boolean): InsertQueryNode;
+    createWithoutInto(): InsertQueryNode;
+    cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): InsertQueryNode;
+}>;

package/dist/cjs/operation-node/insert-query-node.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertQueryNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.InsertQueryNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'InsertQueryNode';
+    },
+    create(into, withNode, replace) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'InsertQueryNode',
+            into,
+            ...(withNode && { with: withNode }),
+            replace,
+        });
+    },
+    createWithoutInto() {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'InsertQueryNode',
+        });
+    },
+    cloneWith(insertQuery, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...insertQuery,
+            ...props,
+        });
+    },
+});

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

@@ -0,0 +1,18 @@
+import { OnNode } from './on-node.js';
+import { OperationNode } from './operation-node.js';
+export type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'CrossJoin' | 'LateralInnerJoin' | 'LateralLeftJoin' | 'LateralCrossJoin' | 'Using' | 'OuterApply' | 'CrossApply';
+export interface JoinNode extends OperationNode {
+    readonly kind: 'JoinNode';
+    readonly joinType: JoinType;
+    readonly table: OperationNode;
+    readonly on?: OnNode;
+}
+/**
+ * @internal
+ */
+export declare const JoinNode: Readonly<{
+    is(node: OperationNode): node is JoinNode;
+    create(joinType: JoinType, table: OperationNode): JoinNode;
+    createWithOn(joinType: JoinType, table: OperationNode, on: OperationNode): JoinNode;
+    cloneWithOn(joinNode: JoinNode, operation: OperationNode): JoinNode;
+}>;

package/dist/cjs/operation-node/join-node.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const on_node_js_1 = require("./on-node.js");
+/**
+ * @internal
+ */
+exports.JoinNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'JoinNode';
+    },
+    create(joinType, table) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JoinNode',
+            joinType,
+            table,
+            on: undefined,
+        });
+    },
+    createWithOn(joinType, table, on) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JoinNode',
+            joinType,
+            table,
+            on: on_node_js_1.OnNode.create(on),
+        });
+    },
+    cloneWithOn(joinNode, operation) {
+        return (0, object_utils_js_1.freeze)({
+            ...joinNode,
+            on: joinNode.on
+                ? on_node_js_1.OnNode.cloneWithOperation(joinNode.on, 'And', operation)
+                : on_node_js_1.OnNode.create(operation),
+        });
+    },
+});

package/dist/cjs/operation-node/json-operator-chain-node.d.ts

@@ -0,0 +1,16 @@
+import { OperationNode } from './operation-node.js';
+import { OperatorNode } from './operator-node.js';
+import { ValueNode } from './value-node.js';
+export interface JSONOperatorChainNode extends OperationNode {
+    readonly kind: 'JSONOperatorChainNode';
+    readonly operator: OperatorNode;
+    readonly values: readonly ValueNode[];
+}
+/**
+ * @internal
+ */
+export declare const JSONOperatorChainNode: Readonly<{
+    is(node: OperationNode): node is JSONOperatorChainNode;
+    create(operator: OperatorNode): JSONOperatorChainNode;
+    cloneWithValue(node: JSONOperatorChainNode, value: ValueNode): JSONOperatorChainNode;
+}>;

package/dist/cjs/operation-node/json-operator-chain-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONOperatorChainNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.JSONOperatorChainNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'JSONOperatorChainNode';
+    },
+    create(operator) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JSONOperatorChainNode',
+            operator,
+            values: (0, object_utils_js_1.freeze)([]),
+        });
+    },
+    cloneWithValue(node, value) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            values: (0, object_utils_js_1.freeze)([...node.values, value]),
+        });
+    },
+});

package/dist/cjs/operation-node/json-path-leg-node.d.ts

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+export type JSONPathLegType = 'Member' | 'ArrayLocation';
+export interface JSONPathLegNode extends OperationNode {
+    readonly kind: 'JSONPathLegNode';
+    readonly type: JSONPathLegType;
+    readonly value: string | number;
+}
+/**
+ * @internal
+ */
+export declare const JSONPathLegNode: Readonly<{
+    is(node: OperationNode): node is JSONPathLegNode;
+    create(type: JSONPathLegType, value: string | number): JSONPathLegNode;
+}>;

package/dist/cjs/operation-node/json-path-leg-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONPathLegNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.JSONPathLegNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'JSONPathLegNode';
+    },
+    create(type, value) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JSONPathLegNode',
+            type,
+            value,
+        });
+    },
+});

package/dist/cjs/operation-node/json-path-node.d.ts

@@ -0,0 +1,16 @@
+import { JSONPathLegNode } from './json-path-leg-node.js';
+import { OperationNode } from './operation-node.js';
+import { OperatorNode } from './operator-node.js';
+export interface JSONPathNode extends OperationNode {
+    readonly kind: 'JSONPathNode';
+    readonly inOperator?: OperatorNode;
+    readonly pathLegs: ReadonlyArray<JSONPathLegNode>;
+}
+/**
+ * @internal
+ */
+export declare const JSONPathNode: Readonly<{
+    is(node: OperationNode): node is JSONPathNode;
+    create(inOperator?: OperatorNode): JSONPathNode;
+    cloneWithLeg(jsonPathNode: JSONPathNode, pathLeg: JSONPathLegNode): JSONPathNode;
+}>;

package/dist/cjs/operation-node/json-path-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONPathNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.JSONPathNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'JSONPathNode';
+    },
+    create(inOperator) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JSONPathNode',
+            inOperator,
+            pathLegs: (0, object_utils_js_1.freeze)([]),
+        });
+    },
+    cloneWithLeg(jsonPathNode, pathLeg) {
+        return (0, object_utils_js_1.freeze)({
+            ...jsonPathNode,
+            pathLegs: (0, object_utils_js_1.freeze)([...jsonPathNode.pathLegs, pathLeg]),
+        });
+    },
+});

package/dist/cjs/operation-node/json-reference-node.d.ts

@@ -0,0 +1,17 @@
+import { JSONOperatorChainNode } from './json-operator-chain-node.js';
+import { JSONPathNode } from './json-path-node.js';
+import { OperationNode } from './operation-node.js';
+import { ReferenceNode } from './reference-node.js';
+export interface JSONReferenceNode extends OperationNode {
+    readonly kind: 'JSONReferenceNode';
+    readonly reference: ReferenceNode;
+    readonly traversal: JSONPathNode | JSONOperatorChainNode;
+}
+/**
+ * @internal
+ */
+export declare const JSONReferenceNode: Readonly<{
+    is(node: OperationNode): node is JSONReferenceNode;
+    create(reference: ReferenceNode, traversal: JSONPathNode | JSONOperatorChainNode): JSONReferenceNode;
+    cloneWithTraversal(node: JSONReferenceNode, traversal: JSONPathNode | JSONOperatorChainNode): JSONReferenceNode;
+}>;

package/dist/cjs/operation-node/json-reference-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONReferenceNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.JSONReferenceNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'JSONReferenceNode';
+    },
+    create(reference, traversal) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JSONReferenceNode',
+            reference,
+            traversal,
+        });
+    },
+    cloneWithTraversal(node, traversal) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            traversal,
+        });
+    },
+});

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

@@ -0,0 +1,12 @@
+import { OperationNode } from './operation-node.js';
+export interface LimitNode extends OperationNode {
+    readonly kind: 'LimitNode';
+    readonly limit: OperationNode;
+}
+/**
+ * @internal
+ */
+export declare const LimitNode: Readonly<{
+    is(node: OperationNode): node is LimitNode;
+    create(limit: OperationNode): LimitNode;
+}>;

package/dist/cjs/operation-node/limit-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.LimitNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'LimitNode';
+    },
+    create(limit) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'LimitNode',
+            limit,
+        });
+    },
+});

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

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

package/dist/cjs/operation-node/list-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.ListNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ListNode';
+    },
+    create(items) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ListNode',
+            items: (0, object_utils_js_1.freeze)(items),
+        });
+    },
+});

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

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+export interface MatchedNode extends OperationNode {
+    readonly kind: 'MatchedNode';
+    readonly not: boolean;
+    readonly bySource: boolean;
+}
+/**
+ * @internal
+ */
+export declare const MatchedNode: Readonly<{
+    is(node: OperationNode): node is MatchedNode;
+    create(not: boolean, bySource?: boolean): MatchedNode;
+}>;

package/dist/cjs/operation-node/matched-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchedNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.MatchedNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'MatchedNode';
+    },
+    create(not, bySource = false) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'MatchedNode',
+            not,
+            bySource,
+        });
+    },
+});

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

@@ -0,0 +1,30 @@
+import { AliasNode } from './alias-node.js';
+import { JoinNode } from './join-node.js';
+import { OperationNode } from './operation-node.js';
+import { OutputNode } from './output-node.js';
+import { ReturningNode } from './returning-node.js';
+import { TableNode } from './table-node.js';
+import { TopNode } from './top-node.js';
+import { WhenNode } from './when-node.js';
+import { WithNode } from './with-node.js';
+export interface MergeQueryNode extends OperationNode {
+    readonly kind: 'MergeQueryNode';
+    readonly into: TableNode | AliasNode;
+    readonly using?: JoinNode;
+    readonly whens?: ReadonlyArray<WhenNode>;
+    readonly with?: WithNode;
+    readonly top?: TopNode;
+    readonly returning?: ReturningNode;
+    readonly output?: OutputNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
+}
+/**
+ * @internal
+ */
+export declare const MergeQueryNode: Readonly<{
+    is(node: OperationNode): node is MergeQueryNode;
+    create(into: TableNode | AliasNode, withNode?: WithNode): MergeQueryNode;
+    cloneWithUsing(mergeNode: MergeQueryNode, using: JoinNode): MergeQueryNode;
+    cloneWithWhen(mergeNode: MergeQueryNode, when: WhenNode): MergeQueryNode;
+    cloneWithThen(mergeNode: MergeQueryNode, then: OperationNode): MergeQueryNode;
+}>;

package/dist/cjs/operation-node/merge-query-node.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeQueryNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const when_node_js_1 = require("./when-node.js");
+/**
+ * @internal
+ */
+exports.MergeQueryNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'MergeQueryNode';
+    },
+    create(into, withNode) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'MergeQueryNode',
+            into,
+            ...(withNode && { with: withNode }),
+        });
+    },
+    cloneWithUsing(mergeNode, using) {
+        return (0, object_utils_js_1.freeze)({
+            ...mergeNode,
+            using,
+        });
+    },
+    cloneWithWhen(mergeNode, when) {
+        return (0, object_utils_js_1.freeze)({
+            ...mergeNode,
+            whens: mergeNode.whens
+                ? (0, object_utils_js_1.freeze)([...mergeNode.whens, when])
+                : (0, object_utils_js_1.freeze)([when]),
+        });
+    },
+    cloneWithThen(mergeNode, then) {
+        return (0, object_utils_js_1.freeze)({
+            ...mergeNode,
+            whens: mergeNode.whens
+                ? (0, object_utils_js_1.freeze)([
+                    ...mergeNode.whens.slice(0, -1),
+                    when_node_js_1.WhenNode.cloneWithResult(mergeNode.whens[mergeNode.whens.length - 1], then),
+                ])
+                : undefined,
+        });
+    },
+});

package/dist/cjs/operation-node/modify-column-node.d.ts

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

package/dist/cjs/operation-node/modify-column-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModifyColumnNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.ModifyColumnNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ModifyColumnNode';
+    },
+    create(column) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ModifyColumnNode',
+            column,
+        });
+    },
+});

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

@@ -0,0 +1,12 @@
+import { OperationNode } from './operation-node.js';
+export interface OffsetNode extends OperationNode {
+    readonly kind: 'OffsetNode';
+    readonly offset: OperationNode;
+}
+/**
+ * @internal
+ */
+export declare const OffsetNode: Readonly<{
+    is(node: OperationNode): node is OffsetNode;
+    create(offset: OperationNode): OffsetNode;
+}>;

package/dist/cjs/operation-node/offset-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffsetNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.OffsetNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'OffsetNode';
+    },
+    create(offset) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'OffsetNode',
+            offset,
+        });
+    },
+});

package/dist/cjs/operation-node/on-conflict-node.d.ts

@@ -0,0 +1,30 @@
+import { ColumnNode } from './column-node.js';
+import { ColumnUpdateNode } from './column-update-node.js';
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+import { WhereNode } from './where-node.js';
+export type OnConflictNodeProps = Omit<OnConflictNode, 'kind' | 'indexWhere' | 'updateWhere'>;
+export interface OnConflictNode extends OperationNode {
+    readonly kind: 'OnConflictNode';
+    readonly columns?: ReadonlyArray<ColumnNode>;
+    readonly constraint?: IdentifierNode;
+    readonly indexExpression?: OperationNode;
+    readonly indexWhere?: WhereNode;
+    readonly updates?: ReadonlyArray<ColumnUpdateNode>;
+    readonly updateWhere?: WhereNode;
+    readonly doNothing?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const OnConflictNode: Readonly<{
+    is(node: OperationNode): node is OnConflictNode;
+    create(): OnConflictNode;
+    cloneWith(node: OnConflictNode, props: OnConflictNodeProps): OnConflictNode;
+    cloneWithIndexWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithIndexOrWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithUpdateWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithUpdateOrWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithoutIndexWhere(node: OnConflictNode): OnConflictNode;
+    cloneWithoutUpdateWhere(node: OnConflictNode): OnConflictNode;
+}>;

package/dist/cjs/operation-node/on-conflict-node.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnConflictNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const where_node_js_1 = require("./where-node.js");
+/**
+ * @internal
+ */
+exports.OnConflictNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'OnConflictNode';
+    },
+    create() {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'OnConflictNode',
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
+        });
+    },
+    cloneWithIndexWhere(node, operation) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            indexWhere: node.indexWhere
+                ? where_node_js_1.WhereNode.cloneWithOperation(node.indexWhere, 'And', operation)
+                : where_node_js_1.WhereNode.create(operation),
+        });
+    },
+    cloneWithIndexOrWhere(node, operation) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            indexWhere: node.indexWhere
+                ? where_node_js_1.WhereNode.cloneWithOperation(node.indexWhere, 'Or', operation)
+                : where_node_js_1.WhereNode.create(operation),
+        });
+    },
+    cloneWithUpdateWhere(node, operation) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            updateWhere: node.updateWhere
+                ? where_node_js_1.WhereNode.cloneWithOperation(node.updateWhere, 'And', operation)
+                : where_node_js_1.WhereNode.create(operation),
+        });
+    },
+    cloneWithUpdateOrWhere(node, operation) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            updateWhere: node.updateWhere
+                ? where_node_js_1.WhereNode.cloneWithOperation(node.updateWhere, 'Or', operation)
+                : where_node_js_1.WhereNode.create(operation),
+        });
+    },
+    cloneWithoutIndexWhere(node) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            indexWhere: undefined,
+        });
+    },
+    cloneWithoutUpdateWhere(node) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            updateWhere: undefined,
+        });
+    },
+});

package/dist/cjs/operation-node/on-duplicate-key-node.d.ts

@@ -0,0 +1,14 @@
+import { ColumnUpdateNode } from './column-update-node.js';
+import { OperationNode } from './operation-node.js';
+export type OnDuplicateKeyNodeProps = Omit<OnDuplicateKeyNode, 'kind'>;
+export interface OnDuplicateKeyNode extends OperationNode {
+    readonly kind: 'OnDuplicateKeyNode';
+    readonly updates: ReadonlyArray<ColumnUpdateNode>;
+}
+/**
+ * @internal
+ */
+export declare const OnDuplicateKeyNode: Readonly<{
+    is(node: OperationNode): node is OnDuplicateKeyNode;
+    create(updates: ReadonlyArray<ColumnUpdateNode>): OnDuplicateKeyNode;
+}>;