@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/esm/operation-node/common-table-expression-name-node.d.ts

@@ -0,0 +1,17 @@
+import { ColumnNode } from './column-node.js';
+import type { OperationNode } from './operation-node.js';
+import { TableNode } from './table-node.js';
+export interface CommonTableExpressionNameNode extends OperationNode {
+    readonly kind: 'CommonTableExpressionNameNode';
+    readonly table: TableNode;
+    readonly columns?: ReadonlyArray<ColumnNode>;
+}
+type CommonTableExpressionNameNodeFactory = Readonly<{
+    is(node: OperationNode): node is CommonTableExpressionNameNode;
+    create(tableName: string, columnNames?: ReadonlyArray<string>): Readonly<CommonTableExpressionNameNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CommonTableExpressionNameNode: CommonTableExpressionNameNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/common-table-expression-name-node.js

@@ -0,0 +1,21 @@
+/// <reference types="./common-table-expression-name-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { ColumnNode } from './column-node.js';
+import { TableNode } from './table-node.js';
+/**
+ * @internal
+ */
+export const CommonTableExpressionNameNode = freeze({
+    is(node) {
+        return node.kind === 'CommonTableExpressionNameNode';
+    },
+    create(tableName, columnNames) {
+        return freeze({
+            kind: 'CommonTableExpressionNameNode',
+            table: TableNode.create(tableName),
+            columns: columnNames
+                ? freeze(columnNames.map(ColumnNode.create))
+                : undefined,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/common-table-expression-node.d.ts

@@ -0,0 +1,19 @@
+import type { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
+import type { OperationNode } from './operation-node.js';
+type CommonTableExpressionNodeProps = Pick<CommonTableExpressionNode, 'materialized'>;
+export interface CommonTableExpressionNode extends OperationNode {
+    readonly kind: 'CommonTableExpressionNode';
+    readonly name: CommonTableExpressionNameNode;
+    readonly materialized?: boolean;
+    readonly expression: OperationNode;
+}
+type CommonTableExpressionNodeFactory = Readonly<{
+    is(node: OperationNode): node is CommonTableExpressionNode;
+    create(name: CommonTableExpressionNameNode, expression: OperationNode): Readonly<CommonTableExpressionNode>;
+    cloneWith(node: CommonTableExpressionNode, props: CommonTableExpressionNodeProps): Readonly<CommonTableExpressionNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CommonTableExpressionNode: CommonTableExpressionNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/common-table-expression-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./common-table-expression-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const CommonTableExpressionNode = freeze({
+    is(node) {
+        return node.kind === 'CommonTableExpressionNode';
+    },
+    create(name, expression) {
+        return freeze({
+            kind: 'CommonTableExpressionNode',
+            name,
+            expression,
+        });
+    },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
+});

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

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

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

@@ -0,0 +1,2 @@
+/// <reference types="./constraint-node.d.ts" />
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/create-index-node.d.ts

@@ -0,0 +1,29 @@
+import { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { RawNode } from './raw-node.js';
+import type { TableNode } from './table-node.js';
+import type { WhereNode } from './where-node.js';
+export type CreateIndexNodeProps = Omit<CreateIndexNode, 'kind' | 'name'>;
+export type IndexType = 'btree' | 'hash' | 'gist' | 'gin';
+export interface CreateIndexNode extends OperationNode {
+    readonly kind: 'CreateIndexNode';
+    readonly name: IdentifierNode;
+    readonly table?: TableNode;
+    readonly columns?: OperationNode[];
+    readonly unique?: boolean;
+    readonly using?: RawNode;
+    readonly ifNotExists?: boolean;
+    readonly where?: WhereNode;
+    readonly nullsNotDistinct?: boolean;
+}
+type CreateIndexNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateIndexNode;
+    create(name: string): Readonly<CreateIndexNode>;
+    cloneWith(node: CreateIndexNode, props: CreateIndexNodeProps): Readonly<CreateIndexNode>;
+    cloneWithColumns(node: CreateIndexNode, columns: OperationNode[]): Readonly<CreateIndexNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CreateIndexNode: CreateIndexNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/create-index-node.js

@@ -0,0 +1,29 @@
+/// <reference types="./create-index-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const CreateIndexNode = freeze({
+    is(node) {
+        return node.kind === 'CreateIndexNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'CreateIndexNode',
+            name: IdentifierNode.create(name),
+        });
+    },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
+    cloneWithColumns(node, columns) {
+        return freeze({
+            ...node,
+            columns: [...(node.columns || []), ...columns],
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/create-schema-node.d.ts

@@ -0,0 +1,18 @@
+import { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+export type CreateSchemaNodeParams = Omit<Partial<CreateSchemaNode>, 'kind' | 'schema'>;
+export interface CreateSchemaNode extends OperationNode {
+    readonly kind: 'CreateSchemaNode';
+    readonly schema: IdentifierNode;
+    readonly ifNotExists?: boolean;
+}
+type CreateSchemaNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateSchemaNode;
+    create(schema: string, params?: CreateSchemaNodeParams): Readonly<CreateSchemaNode>;
+    cloneWith(createSchema: CreateSchemaNode, params: CreateSchemaNodeParams): Readonly<CreateSchemaNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CreateSchemaNode: CreateSchemaNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/create-schema-node.js

@@ -0,0 +1,24 @@
+/// <reference types="./create-schema-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const CreateSchemaNode = freeze({
+    is(node) {
+        return node.kind === 'CreateSchemaNode';
+    },
+    create(schema, params) {
+        return freeze({
+            kind: 'CreateSchemaNode',
+            schema: IdentifierNode.create(schema),
+            ...params,
+        });
+    },
+    cloneWith(createSchema, params) {
+        return freeze({
+            ...createSchema,
+            ...params,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/create-table-node.d.ts

@@ -0,0 +1,34 @@
+import type { OperationNode } from './operation-node.js';
+import type { TableNode } from './table-node.js';
+import type { ConstraintNode } from './constraint-node.js';
+import type { ColumnDefinitionNode } from './column-definition-node.js';
+import type { ArrayItemType } from '../util/type-utils.js';
+export declare const ON_COMMIT_ACTIONS: string[];
+export type OnCommitAction = ArrayItemType<typeof ON_COMMIT_ACTIONS>;
+export type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints' | 'frontModifiers' | 'endModifiers'>;
+export interface CreateTableNode extends OperationNode {
+    readonly kind: 'CreateTableNode';
+    readonly table: TableNode;
+    readonly columns: ReadonlyArray<ColumnDefinitionNode>;
+    readonly constraints?: ReadonlyArray<ConstraintNode>;
+    readonly temporary?: boolean;
+    readonly ifNotExists?: boolean;
+    readonly onCommit?: OnCommitAction;
+    readonly frontModifiers?: ReadonlyArray<OperationNode>;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
+    readonly selectQuery?: OperationNode;
+}
+type CreateTableNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateTableNode;
+    create(table: TableNode): Readonly<CreateTableNode>;
+    cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): Readonly<CreateTableNode>;
+    cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): Readonly<CreateTableNode>;
+    cloneWithFrontModifier(createTable: CreateTableNode, modifier: OperationNode): Readonly<CreateTableNode>;
+    cloneWithEndModifier(createTable: CreateTableNode, modifier: OperationNode): Readonly<CreateTableNode>;
+    cloneWith(createTable: CreateTableNode, params: CreateTableNodeParams): Readonly<CreateTableNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CreateTableNode: CreateTableNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/create-table-node.js

@@ -0,0 +1,54 @@
+/// <reference types="./create-table-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+export const ON_COMMIT_ACTIONS = ['preserve rows', 'delete rows', 'drop'];
+/**
+ * @internal
+ */
+export const CreateTableNode = freeze({
+    is(node) {
+        return node.kind === 'CreateTableNode';
+    },
+    create(table) {
+        return freeze({
+            kind: 'CreateTableNode',
+            table,
+            columns: freeze([]),
+        });
+    },
+    cloneWithColumn(createTable, column) {
+        return freeze({
+            ...createTable,
+            columns: freeze([...createTable.columns, column]),
+        });
+    },
+    cloneWithConstraint(createTable, constraint) {
+        return freeze({
+            ...createTable,
+            constraints: createTable.constraints
+                ? freeze([...createTable.constraints, constraint])
+                : freeze([constraint]),
+        });
+    },
+    cloneWithFrontModifier(createTable, modifier) {
+        return freeze({
+            ...createTable,
+            frontModifiers: createTable.frontModifiers
+                ? freeze([...createTable.frontModifiers, modifier])
+                : freeze([modifier]),
+        });
+    },
+    cloneWithEndModifier(createTable, modifier) {
+        return freeze({
+            ...createTable,
+            endModifiers: createTable.endModifiers
+                ? freeze([...createTable.endModifiers, modifier])
+                : freeze([modifier]),
+        });
+    },
+    cloneWith(createTable, params) {
+        return freeze({
+            ...createTable,
+            ...params,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/create-type-node.d.ts

@@ -0,0 +1,19 @@
+import type { OperationNode } from './operation-node.js';
+import type { SchemableIdentifierNode } from './schemable-identifier-node.js';
+import { ValueListNode } from './value-list-node.js';
+export type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
+export interface CreateTypeNode extends OperationNode {
+    readonly kind: 'CreateTypeNode';
+    readonly name: SchemableIdentifierNode;
+    readonly enum?: ValueListNode;
+}
+type CreateTypeNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateTypeNode;
+    create(name: SchemableIdentifierNode): Readonly<CreateTypeNode>;
+    cloneWithEnum(createType: CreateTypeNode, values: readonly string[]): Readonly<CreateTypeNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CreateTypeNode: CreateTypeNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/create-type-node.js

@@ -0,0 +1,24 @@
+/// <reference types="./create-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { ValueListNode } from './value-list-node.js';
+import { ValueNode } from './value-node.js';
+/**
+ * @internal
+ */
+export const CreateTypeNode = freeze({
+    is(node) {
+        return node.kind === 'CreateTypeNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'CreateTypeNode',
+            name,
+        });
+    },
+    cloneWithEnum(createType, values) {
+        return freeze({
+            ...createType,
+            enum: ValueListNode.create(values.map(ValueNode.createImmediate)),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/create-view-node.d.ts

@@ -0,0 +1,26 @@
+import type { ColumnNode } from './column-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { RawNode } from './raw-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+import type { SelectQueryNode } from './select-query-node.js';
+export type CreateViewNodeParams = Omit<Partial<CreateViewNode>, 'kind' | 'name'>;
+export interface CreateViewNode extends OperationNode {
+    readonly kind: 'CreateViewNode';
+    readonly name: SchemableIdentifierNode;
+    readonly temporary?: boolean;
+    readonly materialized?: boolean;
+    readonly orReplace?: boolean;
+    readonly ifNotExists?: boolean;
+    readonly columns?: ReadonlyArray<ColumnNode>;
+    readonly as?: SelectQueryNode | RawNode;
+}
+type CreateViewNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateViewNode;
+    create(name: string): Readonly<CreateViewNode>;
+    cloneWith(createView: CreateViewNode, params: CreateViewNodeParams): Readonly<CreateViewNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CreateViewNode: CreateViewNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/create-view-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./create-view-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+/**
+ * @internal
+ */
+export const CreateViewNode = freeze({
+    is(node) {
+        return node.kind === 'CreateViewNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'CreateViewNode',
+            name: SchemableIdentifierNode.create(name),
+        });
+    },
+    cloneWith(createView, params) {
+        return freeze({
+            ...createView,
+            ...params,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/data-type-node.d.ts

@@ -0,0 +1,19 @@
+import type { OperationNode } from './operation-node.js';
+declare const SIMPLE_COLUMN_DATA_TYPES: readonly ["varchar", "char", "text", "integer", "int2", "int4", "int8", "smallint", "bigint", "boolean", "real", "double precision", "float4", "float8", "decimal", "numeric", "binary", "bytea", "date", "datetime", "time", "timetz", "timestamp", "timestamptz", "serial", "bigserial", "uuid", "json", "jsonb", "blob", "varbinary", "int4range", "int4multirange", "int8range", "int8multirange", "numrange", "nummultirange", "tsrange", "tsmultirange", "tstzrange", "tstzmultirange", "daterange", "datemultirange"];
+type SimpleColumnDataType = (typeof SIMPLE_COLUMN_DATA_TYPES)[number];
+export type ColumnDataType = SimpleColumnDataType | `varchar(${number})` | `char(${number})` | `decimal(${number}, ${number})` | `numeric(${number}, ${number})` | `binary(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`;
+export type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
+export interface DataTypeNode extends OperationNode {
+    readonly kind: 'DataTypeNode';
+    readonly dataType: ColumnDataType;
+}
+type DataTypeNodeFactory = Readonly<{
+    is(node: OperationNode): node is DataTypeNode;
+    create(dataType: ColumnDataType): Readonly<DataTypeNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const DataTypeNode: DataTypeNodeFactory;
+export declare function isColumnDataType(dataType: string): dataType is ColumnDataType;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/data-type-node.js

@@ -0,0 +1,83 @@
+/// <reference types="./data-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+const SIMPLE_COLUMN_DATA_TYPES = [
+    'varchar',
+    'char',
+    'text',
+    'integer',
+    'int2',
+    'int4',
+    'int8',
+    'smallint',
+    'bigint',
+    'boolean',
+    'real',
+    'double precision',
+    'float4',
+    'float8',
+    'decimal',
+    'numeric',
+    'binary',
+    'bytea',
+    'date',
+    'datetime',
+    'time',
+    'timetz',
+    'timestamp',
+    'timestamptz',
+    'serial',
+    'bigserial',
+    'uuid',
+    'json',
+    'jsonb',
+    'blob',
+    'varbinary',
+    'int4range',
+    'int4multirange',
+    'int8range',
+    'int8multirange',
+    'numrange',
+    'nummultirange',
+    'tsrange',
+    'tsmultirange',
+    'tstzrange',
+    'tstzmultirange',
+    'daterange',
+    'datemultirange',
+];
+const COLUMN_DATA_TYPE_REGEX = [
+    /^varchar\(\d+\)$/,
+    /^char\(\d+\)$/,
+    /^decimal\(\d+, \d+\)$/,
+    /^numeric\(\d+, \d+\)$/,
+    /^binary\(\d+\)$/,
+    /^datetime\(\d+\)$/,
+    /^time\(\d+\)$/,
+    /^timetz\(\d+\)$/,
+    /^timestamp\(\d+\)$/,
+    /^timestamptz\(\d+\)$/,
+    /^varbinary\(\d+\)$/,
+];
+/**
+ * @internal
+ */
+export const DataTypeNode = freeze({
+    is(node) {
+        return node.kind === 'DataTypeNode';
+    },
+    create(dataType) {
+        return freeze({
+            kind: 'DataTypeNode',
+            dataType,
+        });
+    },
+});
+export function isColumnDataType(dataType) {
+    if (SIMPLE_COLUMN_DATA_TYPES.includes(dataType)) {
+        return true;
+    }
+    if (COLUMN_DATA_TYPE_REGEX.some((r) => r.test(dataType))) {
+        return true;
+    }
+    return false;
+}

package/dist/server/node_modules/kysely/dist/esm/operation-node/default-insert-value-node.d.ts

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/default-insert-value-node.js

@@ -0,0 +1,15 @@
+/// <reference types="./default-insert-value-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const DefaultInsertValueNode = freeze({
+    is(node) {
+        return node.kind === 'DefaultInsertValueNode';
+    },
+    create() {
+        return freeze({
+            kind: 'DefaultInsertValueNode',
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/default-value-node.d.ts

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/default-value-node.js

@@ -0,0 +1,16 @@
+/// <reference types="./default-value-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const DefaultValueNode = freeze({
+    is(node) {
+        return node.kind === 'DefaultValueNode';
+    },
+    create(defaultValue) {
+        return freeze({
+            kind: 'DefaultValueNode',
+            defaultValue,
+        });
+    },
+});

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

@@ -0,0 +1,42 @@
+import { FromNode } from './from-node.js';
+import type { JoinNode } from './join-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ReturningNode } from './returning-node.js';
+import type { WhereNode } from './where-node.js';
+import type { WithNode } from './with-node.js';
+import type { LimitNode } from './limit-node.js';
+import type { OrderByNode } from './order-by-node.js';
+import type { OrderByItemNode } from './order-by-item-node.js';
+import type { ExplainNode } from './explain-node.js';
+import { UsingNode } from './using-node.js';
+import type { TopNode } from './top-node.js';
+import type { OutputNode } from './output-node.js';
+export interface DeleteQueryNode extends OperationNode {
+    readonly kind: 'DeleteQueryNode';
+    readonly from: FromNode;
+    readonly using?: UsingNode;
+    readonly joins?: ReadonlyArray<JoinNode>;
+    readonly where?: WhereNode;
+    readonly returning?: ReturningNode;
+    readonly with?: WithNode;
+    readonly orderBy?: OrderByNode;
+    readonly limit?: LimitNode;
+    readonly explain?: ExplainNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
+    readonly top?: TopNode;
+    readonly output?: OutputNode;
+}
+type DeleteQueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is DeleteQueryNode;
+    create(fromItems: OperationNode[], withNode?: WithNode): Readonly<DeleteQueryNode>;
+    cloneWithOrderByItems(node: DeleteQueryNode, items: ReadonlyArray<OrderByItemNode>): Readonly<DeleteQueryNode>;
+    cloneWithoutOrderBy(node: DeleteQueryNode): Readonly<DeleteQueryNode>;
+    cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): Readonly<DeleteQueryNode>;
+    cloneWithoutLimit(deleteNode: DeleteQueryNode): Readonly<DeleteQueryNode>;
+    cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): Readonly<DeleteQueryNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const DeleteQueryNode: DeleteQueryNodeFactory;
+export {};

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

@@ -0,0 +1,50 @@
+/// <reference types="./delete-query-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { FromNode } from './from-node.js';
+import { UsingNode } from './using-node.js';
+import { QueryNode } from './query-node.js';
+/**
+ * @internal
+ */
+export const DeleteQueryNode = freeze({
+    is(node) {
+        return node.kind === 'DeleteQueryNode';
+    },
+    create(fromItems, withNode) {
+        return freeze({
+            kind: 'DeleteQueryNode',
+            from: FromNode.create(fromItems),
+            ...(withNode && { with: withNode }),
+        });
+    },
+    // TODO: remove in v0.29
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithOrderByItems: (node, items) => QueryNode.cloneWithOrderByItems(node, items),
+    // TODO: remove in v0.29
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithoutOrderBy: (node) => QueryNode.cloneWithoutOrderBy(node),
+    cloneWithLimit(deleteNode, limit) {
+        return freeze({
+            ...deleteNode,
+            limit,
+        });
+    },
+    cloneWithoutLimit(deleteNode) {
+        return freeze({
+            ...deleteNode,
+            limit: undefined,
+        });
+    },
+    cloneWithUsing(deleteNode, tables) {
+        return freeze({
+            ...deleteNode,
+            using: deleteNode.using !== undefined
+                ? UsingNode.cloneWithTables(deleteNode.using, tables)
+                : UsingNode.create(tables),
+        });
+    },
+});