@decocms/mesh 1.0.0-alpha.1

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteQueryNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const from_node_js_1 = require("./from-node.js");
+const using_node_js_1 = require("./using-node.js");
+const query_node_js_1 = require("./query-node.js");
+/**
+ * @internal
+ */
+exports.DeleteQueryNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'DeleteQueryNode';
+    },
+    create(fromItems, withNode) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'DeleteQueryNode',
+            from: from_node_js_1.FromNode.create(fromItems),
+            ...(withNode && { with: withNode }),
+        });
+    },
+    // TODO: remove in v0.29
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithOrderByItems: (node, items) => query_node_js_1.QueryNode.cloneWithOrderByItems(node, items),
+    // TODO: remove in v0.29
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithoutOrderBy: (node) => query_node_js_1.QueryNode.cloneWithoutOrderBy(node),
+    cloneWithLimit(deleteNode, limit) {
+        return (0, object_utils_js_1.freeze)({
+            ...deleteNode,
+            limit,
+        });
+    },
+    cloneWithoutLimit(deleteNode) {
+        return (0, object_utils_js_1.freeze)({
+            ...deleteNode,
+            limit: undefined,
+        });
+    },
+    cloneWithUsing(deleteNode, tables) {
+        return (0, object_utils_js_1.freeze)({
+            ...deleteNode,
+            using: deleteNode.using !== undefined
+                ? using_node_js_1.UsingNode.cloneWithTables(deleteNode.using, tables)
+                : using_node_js_1.UsingNode.create(tables),
+        });
+    },
+});

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropIndexNode = 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.DropIndexNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'DropIndexNode';
+    },
+    create(name, params) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'DropIndexNode',
+            name: schemable_identifier_node_js_1.SchemableIdentifierNode.create(name),
+            ...params,
+        });
+    },
+    cloneWith(dropIndex, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...dropIndex,
+            ...props,
+        });
+    },
+});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropViewNode = 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.DropViewNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'DropViewNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'DropViewNode',
+            name: schemable_identifier_node_js_1.SchemableIdentifierNode.create(name),
+        });
+    },
+    cloneWith(dropView, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...dropView,
+            ...params,
+        });
+    },
+});

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

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

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

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

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

@@ -0,0 +1,17 @@
+import type { OperationNode } from './operation-node.js';
+import { ValueNode } from './value-node.js';
+export type FetchModifier = 'only' | 'with ties';
+export interface FetchNode extends OperationNode {
+    readonly kind: 'FetchNode';
+    readonly rowCount: ValueNode;
+    readonly modifier: FetchModifier;
+}
+type FetchNodeFactory = Readonly<{
+    is(node: OperationNode): node is FetchNode;
+    create(rowCount: number | bigint, modifier: FetchModifier): Readonly<FetchNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const FetchNode: FetchNodeFactory;
+export {};

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

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

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

@@ -0,0 +1,26 @@
+import type { ColumnNode } from './column-node.js';
+import { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+import { type OnModifyForeignAction, ReferencesNode } from './references-node.js';
+import type { TableNode } from './table-node.js';
+export type ForeignKeyConstraintNodeProps = Omit<ForeignKeyConstraintNode, 'kind' | 'columns' | 'references'>;
+export interface ForeignKeyConstraintNode extends OperationNode {
+    readonly kind: 'ForeignKeyConstraintNode';
+    readonly columns: ReadonlyArray<ColumnNode>;
+    readonly references: ReferencesNode;
+    readonly onDelete?: OnModifyForeignAction;
+    readonly onUpdate?: OnModifyForeignAction;
+    readonly name?: IdentifierNode;
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
+}
+type ForeignKeyConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is ForeignKeyConstraintNode;
+    create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string): Readonly<ForeignKeyConstraintNode>;
+    cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<ForeignKeyConstraintNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const ForeignKeyConstraintNode: ForeignKeyConstraintNodeFactory;
+export {};

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForeignKeyConstraintNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+const references_node_js_1 = require("./references-node.js");
+/**
+ * @internal
+ */
+exports.ForeignKeyConstraintNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ForeignKeyConstraintNode';
+    },
+    create(sourceColumns, targetTable, targetColumns, constraintName) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ForeignKeyConstraintNode',
+            columns: sourceColumns,
+            references: references_node_js_1.ReferencesNode.create(targetTable, targetColumns),
+            name: constraintName
+                ? identifier_node_js_1.IdentifierNode.create(constraintName)
+                : undefined,
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
+        });
+    },
+});

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { OperationNode } from './operation-node.js';
+export interface FunctionNode extends OperationNode {
+    readonly kind: 'FunctionNode';
+    readonly func: string;
+    readonly arguments: ReadonlyArray<OperationNode>;
+}
+type FunctionNodeFactory = Readonly<{
+    is(node: OperationNode): node is FunctionNode;
+    create(func: string, args: ReadonlyArray<OperationNode>): Readonly<FunctionNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const FunctionNode: FunctionNodeFactory;
+export {};

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

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

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

@@ -0,0 +1,21 @@
+import type { OperationNode } from './operation-node.js';
+export type GeneratedNodeParams = Omit<GeneratedNode, 'kind' | 'expression'>;
+export interface GeneratedNode extends OperationNode {
+    readonly kind: 'GeneratedNode';
+    readonly byDefault?: boolean;
+    readonly always?: boolean;
+    readonly identity?: boolean;
+    readonly stored?: boolean;
+    readonly expression?: OperationNode;
+}
+type GeneratedNodeFactory = Readonly<{
+    is(node: OperationNode): node is GeneratedNode;
+    create(params: GeneratedNodeParams): Readonly<GeneratedNode>;
+    createWithExpression(expression: OperationNode): Readonly<GeneratedNode>;
+    cloneWith(node: GeneratedNode, params: GeneratedNodeParams): Readonly<GeneratedNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const GeneratedNode: GeneratedNodeFactory;
+export {};

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

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

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

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