@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/cjs/operation-node/output-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/over-node.d.ts

@@ -0,0 +1,21 @@
+import type { OperationNode } from './operation-node.js';
+import type { OrderByItemNode } from './order-by-item-node.js';
+import { OrderByNode } from './order-by-node.js';
+import type { PartitionByItemNode } from './partition-by-item-node.js';
+import { PartitionByNode } from './partition-by-node.js';
+export interface OverNode extends OperationNode {
+    readonly kind: 'OverNode';
+    readonly orderBy?: OrderByNode;
+    readonly partitionBy?: PartitionByNode;
+}
+type OverNodeFactory = Readonly<{
+    is(node: OperationNode): node is OverNode;
+    create(): Readonly<OverNode>;
+    cloneWithOrderByItems(overNode: OverNode, items: ReadonlyArray<OrderByItemNode>): Readonly<OverNode>;
+    cloneWithPartitionByItems(overNode: OverNode, items: ReadonlyArray<PartitionByItemNode>): Readonly<OverNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const OverNode: OverNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/over-node.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const order_by_node_js_1 = require("./order-by-node.js");
+const partition_by_node_js_1 = require("./partition-by-node.js");
+/**
+ * @internal
+ */
+exports.OverNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'OverNode';
+    },
+    create() {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'OverNode',
+        });
+    },
+    cloneWithOrderByItems(overNode, items) {
+        return (0, object_utils_js_1.freeze)({
+            ...overNode,
+            orderBy: overNode.orderBy
+                ? order_by_node_js_1.OrderByNode.cloneWithItems(overNode.orderBy, items)
+                : order_by_node_js_1.OrderByNode.create(items),
+        });
+    },
+    cloneWithPartitionByItems(overNode, items) {
+        return (0, object_utils_js_1.freeze)({
+            ...overNode,
+            partitionBy: overNode.partitionBy
+                ? partition_by_node_js_1.PartitionByNode.cloneWithItems(overNode.partitionBy, items)
+                : partition_by_node_js_1.PartitionByNode.create(items),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/parens-node.d.ts

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/parens-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/partition-by-item-node.d.ts

@@ -0,0 +1,15 @@
+import type { OperationNode } from './operation-node.js';
+import type { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
+export interface PartitionByItemNode extends OperationNode {
+    readonly kind: 'PartitionByItemNode';
+    readonly partitionBy: SimpleReferenceExpressionNode;
+}
+type PartitionByItemNodeFactory = Readonly<{
+    is(node: OperationNode): node is PartitionByItemNode;
+    create(partitionBy: SimpleReferenceExpressionNode): Readonly<PartitionByItemNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const PartitionByItemNode: PartitionByItemNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/partition-by-item-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/partition-by-node.d.ts

@@ -0,0 +1,16 @@
+import type { PartitionByItemNode } from './partition-by-item-node.js';
+import type { OperationNode } from './operation-node.js';
+export interface PartitionByNode extends OperationNode {
+    readonly kind: 'PartitionByNode';
+    readonly items: ReadonlyArray<PartitionByItemNode>;
+}
+type PartitionByNodeFactory = Readonly<{
+    is(node: OperationNode): node is PartitionByNode;
+    create(items: ReadonlyArray<PartitionByItemNode>): Readonly<PartitionByNode>;
+    cloneWithItems(partitionBy: PartitionByNode, items: ReadonlyArray<PartitionByItemNode>): Readonly<PartitionByNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const PartitionByNode: PartitionByNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/partition-by-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/primary-key-constraint-node.d.ts

@@ -0,0 +1,31 @@
+import { ColumnNode } from './column-node.js';
+import { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+export interface PrimaryKeyConstraintNode extends OperationNode {
+    readonly kind: 'PrimaryKeyConstraintNode';
+    readonly columns: ReadonlyArray<ColumnNode>;
+    readonly name?: IdentifierNode;
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
+}
+export type PrimaryKeyConstraintNodeProps = Omit<Partial<PrimaryKeyConstraintNode>, 'kind'>;
+type PrimaryKeyConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is PrimaryKeyConstraintNode;
+    create(columns: string[], constraintName?: string): Readonly<PrimaryKeyConstraintNode>;
+    cloneWith(node: PrimaryKeyConstraintNode, props: PrimaryKeyConstraintNodeProps): Readonly<PrimaryKeyConstraintNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const PrimaryKeyConstraintNode: PrimaryKeyConstraintNodeFactory;
+/**
+ * Backwards compatibility for a typo in the codebase.
+ *
+ * @deprecated Use {@link PrimaryKeyConstraintNode} instead.
+ */
+export declare const PrimaryConstraintNode: Readonly<{
+    is(node: OperationNode): node is PrimaryKeyConstraintNode;
+    create(columns: string[], constraintName?: string): Readonly<PrimaryKeyConstraintNode>;
+    cloneWith(node: PrimaryKeyConstraintNode, props: PrimaryKeyConstraintNodeProps): Readonly<PrimaryKeyConstraintNode>;
+}>;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/primary-key-constraint-node.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrimaryConstraintNode = exports.PrimaryKeyConstraintNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const column_node_js_1 = require("./column-node.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.PrimaryKeyConstraintNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'PrimaryKeyConstraintNode';
+    },
+    create(columns, constraintName) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'PrimaryKeyConstraintNode',
+            columns: (0, object_utils_js_1.freeze)(columns.map(column_node_js_1.ColumnNode.create)),
+            name: constraintName
+                ? identifier_node_js_1.IdentifierNode.create(constraintName)
+                : undefined,
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({ ...node, ...props });
+    },
+});
+/**
+ * Backwards compatibility for a typo in the codebase.
+ *
+ * @deprecated Use {@link PrimaryKeyConstraintNode} instead.
+ */
+exports.PrimaryConstraintNode = exports.PrimaryKeyConstraintNode;

package/dist/server/node_modules/kysely/dist/cjs/operation-node/primitive-value-list-node.d.ts

@@ -0,0 +1,19 @@
+import type { OperationNode } from './operation-node.js';
+/**
+ * This node is basically just a performance optimization over the normal ValueListNode.
+ * The queries often contain large arrays of primitive values (for example in a `where in` list)
+ * and we don't want to create a ValueNode for each item in those lists.
+ */
+export interface PrimitiveValueListNode extends OperationNode {
+    readonly kind: 'PrimitiveValueListNode';
+    readonly values: ReadonlyArray<unknown>;
+}
+type PrimitiveValueListNodeFactory = Readonly<{
+    is(node: OperationNode): node is PrimitiveValueListNode;
+    create(values: ReadonlyArray<unknown>): Readonly<PrimitiveValueListNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const PrimitiveValueListNode: PrimitiveValueListNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/primitive-value-list-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/query-node.d.ts

@@ -0,0 +1,61 @@
+import { InsertQueryNode } from './insert-query-node.js';
+import { SelectQueryNode } from './select-query-node.js';
+import { UpdateQueryNode } from './update-query-node.js';
+import { DeleteQueryNode } from './delete-query-node.js';
+import { WhereNode } from './where-node.js';
+import type { JoinNode } from './join-node.js';
+import type { SelectionNode } from './selection-node.js';
+import { ReturningNode } from './returning-node.js';
+import type { OperationNode } from './operation-node.js';
+import { ExplainNode } from './explain-node.js';
+import type { ExplainFormat } from '../util/explainable.js';
+import type { Expression } from '../expression/expression.js';
+import { MergeQueryNode } from './merge-query-node.js';
+import type { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
+import { OrderByNode } from './order-by-node.js';
+import type { OrderByItemNode } from './order-by-item-node.js';
+export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode | MergeQueryNode;
+type HasJoins = {
+    joins?: ReadonlyArray<JoinNode>;
+};
+type HasWhere = {
+    where?: WhereNode;
+};
+type HasReturning = {
+    returning?: ReturningNode;
+};
+type HasExplain = {
+    explain?: ExplainNode;
+};
+type HasTop = {
+    top?: TopNode;
+};
+type HasOutput = {
+    output?: OutputNode;
+};
+type HasEndModifiers = {
+    endModifiers?: ReadonlyArray<OperationNode>;
+};
+type HasOrderBy = {
+    orderBy?: OrderByNode;
+};
+type QueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is QueryNode;
+    cloneWithEndModifier<T extends HasEndModifiers>(node: T, modifier: OperationNode): Readonly<T>;
+    cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): Readonly<T>;
+    cloneWithJoin<T extends HasJoins>(node: T, join: JoinNode): Readonly<T>;
+    cloneWithReturning<T extends HasReturning>(node: T, selections: ReadonlyArray<SelectionNode>): Readonly<T>;
+    cloneWithoutReturning<T extends HasReturning>(node: T): Readonly<T>;
+    cloneWithoutWhere<T extends HasWhere>(node: T): Readonly<T>;
+    cloneWithExplain<T extends HasExplain>(node: T, format: ExplainFormat | undefined, options: Expression<any> | undefined): Readonly<T>;
+    cloneWithTop<T extends HasTop>(node: T, top: TopNode): Readonly<T>;
+    cloneWithOutput<T extends HasOutput>(node: T, selections: ReadonlyArray<SelectionNode>): Readonly<T>;
+    cloneWithOrderByItems<T extends HasOrderBy>(node: T, items: ReadonlyArray<OrderByItemNode>): Readonly<T>;
+    cloneWithoutOrderBy<T extends HasOrderBy>(node: T): Readonly<T>;
+}>;
+/**
+ * @internal
+ */
+export declare const QueryNode: QueryNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/query-node.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryNode = void 0;
+const insert_query_node_js_1 = require("./insert-query-node.js");
+const select_query_node_js_1 = require("./select-query-node.js");
+const update_query_node_js_1 = require("./update-query-node.js");
+const delete_query_node_js_1 = require("./delete-query-node.js");
+const where_node_js_1 = require("./where-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const returning_node_js_1 = require("./returning-node.js");
+const explain_node_js_1 = require("./explain-node.js");
+const merge_query_node_js_1 = require("./merge-query-node.js");
+const output_node_js_1 = require("./output-node.js");
+const order_by_node_js_1 = require("./order-by-node.js");
+/**
+ * @internal
+ */
+exports.QueryNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return (select_query_node_js_1.SelectQueryNode.is(node) ||
+            insert_query_node_js_1.InsertQueryNode.is(node) ||
+            update_query_node_js_1.UpdateQueryNode.is(node) ||
+            delete_query_node_js_1.DeleteQueryNode.is(node) ||
+            merge_query_node_js_1.MergeQueryNode.is(node));
+    },
+    cloneWithEndModifier(node, modifier) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            endModifiers: node.endModifiers
+                ? (0, object_utils_js_1.freeze)([...node.endModifiers, modifier])
+                : (0, object_utils_js_1.freeze)([modifier]),
+        });
+    },
+    cloneWithWhere(node, operation) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            where: node.where
+                ? where_node_js_1.WhereNode.cloneWithOperation(node.where, 'And', operation)
+                : where_node_js_1.WhereNode.create(operation),
+        });
+    },
+    cloneWithJoin(node, join) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            joins: node.joins ? (0, object_utils_js_1.freeze)([...node.joins, join]) : (0, object_utils_js_1.freeze)([join]),
+        });
+    },
+    cloneWithReturning(node, selections) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            returning: node.returning
+                ? returning_node_js_1.ReturningNode.cloneWithSelections(node.returning, selections)
+                : returning_node_js_1.ReturningNode.create(selections),
+        });
+    },
+    cloneWithoutReturning(node) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            returning: undefined,
+        });
+    },
+    cloneWithoutWhere(node) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            where: undefined,
+        });
+    },
+    cloneWithExplain(node, format, options) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            explain: explain_node_js_1.ExplainNode.create(format, options?.toOperationNode()),
+        });
+    },
+    cloneWithTop(node, top) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            top,
+        });
+    },
+    cloneWithOutput(node, selections) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            output: node.output
+                ? output_node_js_1.OutputNode.cloneWithSelections(node.output, selections)
+                : output_node_js_1.OutputNode.create(selections),
+        });
+    },
+    cloneWithOrderByItems(node, items) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            orderBy: node.orderBy
+                ? order_by_node_js_1.OrderByNode.cloneWithItems(node.orderBy, items)
+                : order_by_node_js_1.OrderByNode.create(items),
+        });
+    },
+    cloneWithoutOrderBy(node) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            orderBy: undefined,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/raw-node.d.ts

@@ -0,0 +1,18 @@
+import type { OperationNode } from './operation-node.js';
+export interface RawNode extends OperationNode {
+    readonly kind: 'RawNode';
+    readonly sqlFragments: ReadonlyArray<string>;
+    readonly parameters: ReadonlyArray<OperationNode>;
+}
+type RawNodeFactory = Readonly<{
+    is(node: OperationNode): node is RawNode;
+    create(sqlFragments: ReadonlyArray<string>, parameters: ReadonlyArray<OperationNode>): Readonly<RawNode>;
+    createWithSql(sql: string): Readonly<RawNode>;
+    createWithChild(child: OperationNode): Readonly<RawNode>;
+    createWithChildren(children: ReadonlyArray<OperationNode>): Readonly<RawNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const RawNode: RawNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/raw-node.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.RawNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'RawNode';
+    },
+    create(sqlFragments, parameters) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'RawNode',
+            sqlFragments: (0, object_utils_js_1.freeze)(sqlFragments),
+            parameters: (0, object_utils_js_1.freeze)(parameters),
+        });
+    },
+    createWithSql(sql) {
+        return exports.RawNode.create([sql], []);
+    },
+    createWithChild(child) {
+        return exports.RawNode.create(['', ''], [child]);
+    },
+    createWithChildren(children) {
+        return exports.RawNode.create(new Array(children.length + 1).fill(''), children);
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/reference-node.d.ts

@@ -0,0 +1,19 @@
+import type { OperationNode } from './operation-node.js';
+import type { ColumnNode } from './column-node.js';
+import type { TableNode } from './table-node.js';
+import { SelectAllNode } from './select-all-node.js';
+export interface ReferenceNode extends OperationNode {
+    readonly kind: 'ReferenceNode';
+    readonly column: ColumnNode | SelectAllNode;
+    readonly table?: TableNode;
+}
+type ReferenceNodeFactory = Readonly<{
+    is(node: OperationNode): node is ReferenceNode;
+    create(column: ColumnNode, table?: TableNode): Readonly<ReferenceNode>;
+    createSelectAll(table: TableNode): Readonly<ReferenceNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const ReferenceNode: ReferenceNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/reference-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/references-node.d.ts

@@ -0,0 +1,24 @@
+import type { OperationNode } from './operation-node.js';
+import type { ColumnNode } from './column-node.js';
+import type { TableNode } from './table-node.js';
+import type { ArrayItemType } from '../util/type-utils.js';
+export declare const ON_MODIFY_FOREIGN_ACTIONS: readonly ["no action", "restrict", "cascade", "set null", "set default"];
+export type OnModifyForeignAction = ArrayItemType<typeof ON_MODIFY_FOREIGN_ACTIONS>;
+export interface ReferencesNode extends OperationNode {
+    readonly kind: 'ReferencesNode';
+    readonly table: TableNode;
+    readonly columns: ReadonlyArray<ColumnNode>;
+    readonly onDelete?: OnModifyForeignAction;
+    readonly onUpdate?: OnModifyForeignAction;
+}
+type ReferencesNodeFactory = Readonly<{
+    is(node: OperationNode): node is ReferencesNode;
+    create(table: TableNode, columns: ReadonlyArray<ColumnNode>): Readonly<ReferencesNode>;
+    cloneWithOnDelete(references: ReferencesNode, onDelete: OnModifyForeignAction): Readonly<ReferencesNode>;
+    cloneWithOnUpdate(references: ReferencesNode, onUpdate: OnModifyForeignAction): Readonly<ReferencesNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const ReferencesNode: ReferencesNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/references-node.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferencesNode = exports.ON_MODIFY_FOREIGN_ACTIONS = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+exports.ON_MODIFY_FOREIGN_ACTIONS = [
+    'no action',
+    'restrict',
+    'cascade',
+    'set null',
+    'set default',
+];
+/**
+ * @internal
+ */
+exports.ReferencesNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ReferencesNode';
+    },
+    create(table, columns) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ReferencesNode',
+            table,
+            columns: (0, object_utils_js_1.freeze)([...columns]),
+        });
+    },
+    cloneWithOnDelete(references, onDelete) {
+        return (0, object_utils_js_1.freeze)({
+            ...references,
+            onDelete,
+        });
+    },
+    cloneWithOnUpdate(references, onUpdate) {
+        return (0, object_utils_js_1.freeze)({
+            ...references,
+            onUpdate,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/refresh-materialized-view-node.d.ts

@@ -0,0 +1,19 @@
+import type { OperationNode } from './operation-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+export type RefreshMaterializedViewNodeParams = Omit<Partial<RefreshMaterializedViewNode>, 'kind' | 'name'>;
+export interface RefreshMaterializedViewNode extends OperationNode {
+    readonly kind: 'RefreshMaterializedViewNode';
+    readonly name: SchemableIdentifierNode;
+    readonly concurrently?: boolean;
+    readonly withNoData?: boolean;
+}
+type RefreshMaterializedViewNodeFactory = Readonly<{
+    is(node: OperationNode): node is RefreshMaterializedViewNode;
+    create(name: string): Readonly<RefreshMaterializedViewNode>;
+    cloneWith(createView: RefreshMaterializedViewNode, params: RefreshMaterializedViewNodeParams): Readonly<RefreshMaterializedViewNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const RefreshMaterializedViewNode: RefreshMaterializedViewNodeFactory;
+export {};