noormme 1.0.0

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

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

package/dist/cjs/operation-node/rename-constraint-node.d.ts

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+import { IdentifierNode } from './identifier-node.js';
+export interface RenameConstraintNode extends OperationNode {
+    readonly kind: 'RenameConstraintNode';
+    readonly oldName: IdentifierNode;
+    readonly newName: IdentifierNode;
+}
+/**
+ * @internal
+ */
+export declare const RenameConstraintNode: Readonly<{
+    is(node: OperationNode): node is RenameConstraintNode;
+    create(oldName: string, newName: string): RenameConstraintNode;
+}>;

package/dist/cjs/operation-node/rename-constraint-node.js

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

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

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+import { SelectionNode } from './selection-node.js';
+export interface ReturningNode extends OperationNode {
+    readonly kind: 'ReturningNode';
+    readonly selections: ReadonlyArray<SelectionNode>;
+}
+/**
+ * @internal
+ */
+export declare const ReturningNode: Readonly<{
+    is(node: OperationNode): node is ReturningNode;
+    create(selections: ReadonlyArray<SelectionNode>): ReturningNode;
+    cloneWithSelections(returning: ReturningNode, selections: ReadonlyArray<SelectionNode>): ReturningNode;
+}>;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturningNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.ReturningNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ReturningNode';
+    },
+    create(selections) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ReturningNode',
+            selections: (0, object_utils_js_1.freeze)(selections),
+        });
+    },
+    cloneWithSelections(returning, selections) {
+        return (0, object_utils_js_1.freeze)({
+            ...returning,
+            selections: returning.selections
+                ? (0, object_utils_js_1.freeze)([...returning.selections, ...selections])
+                : (0, object_utils_js_1.freeze)(selections),
+        });
+    },
+});

package/dist/cjs/operation-node/schemable-identifier-node.d.ts

@@ -0,0 +1,15 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+export interface SchemableIdentifierNode extends OperationNode {
+    readonly kind: 'SchemableIdentifierNode';
+    readonly schema?: IdentifierNode;
+    readonly identifier: IdentifierNode;
+}
+/**
+ * @internal
+ */
+export declare const SchemableIdentifierNode: Readonly<{
+    is(node: OperationNode): node is SchemableIdentifierNode;
+    create(identifier: string): SchemableIdentifierNode;
+    createWithSchema(schema: string, identifier: string): SchemableIdentifierNode;
+}>;

package/dist/cjs/operation-node/schemable-identifier-node.js

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

package/dist/cjs/operation-node/select-all-node.d.ts

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

package/dist/cjs/operation-node/select-all-node.js

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

package/dist/cjs/operation-node/select-modifier-node.d.ts

@@ -0,0 +1,16 @@
+import { OperationNode } from './operation-node.js';
+export type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked' | 'Distinct';
+export interface SelectModifierNode extends OperationNode {
+    readonly kind: 'SelectModifierNode';
+    readonly modifier?: SelectModifier;
+    readonly rawModifier?: OperationNode;
+    readonly of?: ReadonlyArray<OperationNode>;
+}
+/**
+ * @internal
+ */
+export declare const SelectModifierNode: Readonly<{
+    is(node: OperationNode): node is SelectModifierNode;
+    create(modifier: SelectModifier, of?: ReadonlyArray<OperationNode>): SelectModifierNode;
+    createWithExpression(modifier: OperationNode): SelectModifierNode;
+}>;

package/dist/cjs/operation-node/select-modifier-node.js

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

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

@@ -0,0 +1,67 @@
+import { FromNode } from './from-node.js';
+import { GroupByItemNode } from './group-by-item-node.js';
+import { GroupByNode } from './group-by-node.js';
+import { HavingNode } from './having-node.js';
+import { JoinNode } from './join-node.js';
+import { LimitNode } from './limit-node.js';
+import { OffsetNode } from './offset-node.js';
+import { OperationNode } from './operation-node.js';
+import { OrderByItemNode } from './order-by-item-node.js';
+import { OrderByNode } from './order-by-node.js';
+import { SelectionNode } from './selection-node.js';
+import { WhereNode } from './where-node.js';
+import { WithNode } from './with-node.js';
+import { SelectModifierNode } from './select-modifier-node.js';
+import { ExplainNode } from './explain-node.js';
+import { SetOperationNode } from './set-operation-node.js';
+import { FetchNode } from './fetch-node.js';
+import { TopNode } from './top-node.js';
+export interface SelectQueryNode extends OperationNode {
+    readonly kind: 'SelectQueryNode';
+    readonly from?: FromNode;
+    readonly selections?: ReadonlyArray<SelectionNode>;
+    readonly distinctOn?: ReadonlyArray<OperationNode>;
+    readonly joins?: ReadonlyArray<JoinNode>;
+    readonly groupBy?: GroupByNode;
+    readonly orderBy?: OrderByNode;
+    readonly where?: WhereNode;
+    readonly frontModifiers?: ReadonlyArray<SelectModifierNode>;
+    readonly endModifiers?: ReadonlyArray<SelectModifierNode>;
+    readonly limit?: LimitNode;
+    readonly offset?: OffsetNode;
+    readonly with?: WithNode;
+    readonly having?: HavingNode;
+    readonly explain?: ExplainNode;
+    readonly setOperations?: ReadonlyArray<SetOperationNode>;
+    readonly fetch?: FetchNode;
+    readonly top?: TopNode;
+}
+/**
+ * @internal
+ */
+export declare const SelectQueryNode: Readonly<{
+    is(node: OperationNode): node is SelectQueryNode;
+    create(withNode?: WithNode): SelectQueryNode;
+    createFrom(fromItems: ReadonlyArray<OperationNode>, withNode?: WithNode): SelectQueryNode;
+    cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
+    cloneWithDistinctOn(select: SelectQueryNode, expressions: ReadonlyArray<OperationNode>): SelectQueryNode;
+    cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithOrderByItems: (node: SelectQueryNode, items: ReadonlyArray<OrderByItemNode>) => SelectQueryNode;
+    cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
+    cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
+    cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
+    cloneWithFetch(selectNode: SelectQueryNode, fetch: FetchNode): SelectQueryNode;
+    cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
+    cloneWithSetOperations(selectNode: SelectQueryNode, setOperations: ReadonlyArray<SetOperationNode>): SelectQueryNode;
+    cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithoutOrderBy: (node: SelectQueryNode) => SelectQueryNode;
+    cloneWithoutGroupBy(select: SelectQueryNode): SelectQueryNode;
+}>;

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectQueryNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const from_node_js_1 = require("./from-node.js");
+const group_by_node_js_1 = require("./group-by-node.js");
+const having_node_js_1 = require("./having-node.js");
+const query_node_js_1 = require("./query-node.js");
+/**
+ * @internal
+ */
+exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'SelectQueryNode';
+    },
+    create(withNode) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'SelectQueryNode',
+            ...(withNode && { with: withNode }),
+        });
+    },
+    createFrom(fromItems, withNode) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'SelectQueryNode',
+            from: from_node_js_1.FromNode.create(fromItems),
+            ...(withNode && { with: withNode }),
+        });
+    },
+    cloneWithSelections(select, selections) {
+        return (0, object_utils_js_1.freeze)({
+            ...select,
+            selections: select.selections
+                ? (0, object_utils_js_1.freeze)([...select.selections, ...selections])
+                : (0, object_utils_js_1.freeze)(selections),
+        });
+    },
+    cloneWithDistinctOn(select, expressions) {
+        return (0, object_utils_js_1.freeze)({
+            ...select,
+            distinctOn: select.distinctOn
+                ? (0, object_utils_js_1.freeze)([...select.distinctOn, ...expressions])
+                : (0, object_utils_js_1.freeze)(expressions),
+        });
+    },
+    cloneWithFrontModifier(select, modifier) {
+        return (0, object_utils_js_1.freeze)({
+            ...select,
+            frontModifiers: select.frontModifiers
+                ? (0, object_utils_js_1.freeze)([...select.frontModifiers, modifier])
+                : (0, object_utils_js_1.freeze)([modifier]),
+        });
+    },
+    // TODO: remove in v0.29
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithOrderByItems: (node, items) => query_node_js_1.QueryNode.cloneWithOrderByItems(node, items),
+    cloneWithGroupByItems(selectNode, items) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            groupBy: selectNode.groupBy
+                ? group_by_node_js_1.GroupByNode.cloneWithItems(selectNode.groupBy, items)
+                : group_by_node_js_1.GroupByNode.create(items),
+        });
+    },
+    cloneWithLimit(selectNode, limit) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            limit,
+        });
+    },
+    cloneWithOffset(selectNode, offset) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            offset,
+        });
+    },
+    cloneWithFetch(selectNode, fetch) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            fetch,
+        });
+    },
+    cloneWithHaving(selectNode, operation) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            having: selectNode.having
+                ? having_node_js_1.HavingNode.cloneWithOperation(selectNode.having, 'And', operation)
+                : having_node_js_1.HavingNode.create(operation),
+        });
+    },
+    cloneWithSetOperations(selectNode, setOperations) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            setOperations: selectNode.setOperations
+                ? (0, object_utils_js_1.freeze)([...selectNode.setOperations, ...setOperations])
+                : (0, object_utils_js_1.freeze)([...setOperations]),
+        });
+    },
+    cloneWithoutSelections(select) {
+        return (0, object_utils_js_1.freeze)({
+            ...select,
+            selections: [],
+        });
+    },
+    cloneWithoutLimit(select) {
+        return (0, object_utils_js_1.freeze)({
+            ...select,
+            limit: undefined,
+        });
+    },
+    cloneWithoutOffset(select) {
+        return (0, object_utils_js_1.freeze)({
+            ...select,
+            offset: undefined,
+        });
+    },
+    // TODO: remove in v0.29
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithoutOrderBy: (node) => query_node_js_1.QueryNode.cloneWithoutOrderBy(node),
+    cloneWithoutGroupBy(select) {
+        return (0, object_utils_js_1.freeze)({
+            ...select,
+            groupBy: undefined,
+        });
+    },
+});

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

@@ -0,0 +1,20 @@
+import { AliasNode } from './alias-node.js';
+import { OperationNode } from './operation-node.js';
+import { SelectAllNode } from './select-all-node.js';
+import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
+import { TableNode } from './table-node.js';
+type SelectionNodeChild = SimpleReferenceExpressionNode | AliasNode | SelectAllNode;
+export interface SelectionNode extends OperationNode {
+    readonly kind: 'SelectionNode';
+    readonly selection: SelectionNodeChild;
+}
+/**
+ * @internal
+ */
+export declare const SelectionNode: Readonly<{
+    is(node: OperationNode): node is SelectionNode;
+    create(selection: SelectionNodeChild): SelectionNode;
+    createSelectAll(): SelectionNode;
+    createSelectAllFromTable(table: TableNode): SelectionNode;
+}>;
+export {};

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectionNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const reference_node_js_1 = require("./reference-node.js");
+const select_all_node_js_1 = require("./select-all-node.js");
+/**
+ * @internal
+ */
+exports.SelectionNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'SelectionNode';
+    },
+    create(selection) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'SelectionNode',
+            selection: selection,
+        });
+    },
+    createSelectAll() {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'SelectionNode',
+            selection: select_all_node_js_1.SelectAllNode.create(),
+        });
+    },
+    createSelectAllFromTable(table) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'SelectionNode',
+            selection: reference_node_js_1.ReferenceNode.createSelectAll(table),
+        });
+    },
+});

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

@@ -0,0 +1,15 @@
+import { OperationNode } from './operation-node.js';
+export type SetOperator = 'union' | 'intersect' | 'except';
+export interface SetOperationNode extends OperationNode {
+    kind: 'SetOperationNode';
+    operator: SetOperator;
+    expression: OperationNode;
+    all: boolean;
+}
+/**
+ * @internal
+ */
+export declare const SetOperationNode: Readonly<{
+    is(node: OperationNode): node is SetOperationNode;
+    create(operator: SetOperator, expression: OperationNode, all: boolean): SetOperationNode;
+}>;

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

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

package/dist/cjs/operation-node/simple-reference-expression-node.d.ts

@@ -0,0 +1,3 @@
+import { ColumnNode } from './column-node.js';
+import { ReferenceNode } from './reference-node.js';
+export type SimpleReferenceExpressionNode = ColumnNode | ReferenceNode;

package/dist/cjs/operation-node/simple-reference-expression-node.js

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

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

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+export interface TableNode extends OperationNode {
+    readonly kind: 'TableNode';
+    readonly table: SchemableIdentifierNode;
+}
+/**
+ * @internal
+ */
+export declare const TableNode: Readonly<{
+    is(node: OperationNode): node is TableNode;
+    create(table: string): TableNode;
+    createWithSchema(schema: string, table: string): TableNode;
+}>;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const schemable_identifier_node_js_1 = require("./schemable-identifier-node.js");
+/**
+ * @internal
+ */
+exports.TableNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'TableNode';
+    },
+    create(table) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'TableNode',
+            table: schemable_identifier_node_js_1.SchemableIdentifierNode.create(table),
+        });
+    },
+    createWithSchema(schema, table) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'TableNode',
+            table: schemable_identifier_node_js_1.SchemableIdentifierNode.createWithSchema(schema, table),
+        });
+    },
+});

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

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+export type TopModifier = 'percent' | 'with ties' | 'percent with ties';
+export interface TopNode extends OperationNode {
+    readonly kind: 'TopNode';
+    readonly expression: number | bigint;
+    readonly modifiers?: TopModifier;
+}
+/**
+ * @internal
+ */
+export declare const TopNode: Readonly<{
+    is(node: OperationNode): node is TopNode;
+    create(expression: number | bigint, modifiers?: TopModifier): TopNode;
+}>;

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

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

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

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

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

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

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

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

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

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