Initial commit - Event Planner application

node_modules/kysely/dist/esm/operation-node/add-column-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/add-column-node.js

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

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

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

node_modules/kysely/dist/esm/operation-node/add-constraint-node.js

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

node_modules/kysely/dist/esm/operation-node/add-index-node.d.ts

@@ -0,0 +1,23 @@
+import { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { RawNode } from './raw-node.js';
+export type AddIndexNodeProps = Omit<AddIndexNode, 'kind' | 'name'>;
+export interface AddIndexNode extends OperationNode {
+    readonly kind: 'AddIndexNode';
+    readonly name: IdentifierNode;
+    readonly columns?: OperationNode[];
+    readonly unique?: boolean;
+    readonly using?: RawNode;
+    readonly ifNotExists?: boolean;
+}
+type AddIndexNodeFactory = Readonly<{
+    is(node: OperationNode): node is AddIndexNode;
+    create(name: string): Readonly<AddIndexNode>;
+    cloneWith(node: AddIndexNode, props: Omit<AddIndexNode, 'kind' | 'name'>): Readonly<AddIndexNode>;
+    cloneWithColumns(node: AddIndexNode, columns: OperationNode[]): Readonly<AddIndexNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const AddIndexNode: AddIndexNodeFactory;
+export {};

node_modules/kysely/dist/esm/operation-node/add-index-node.js

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

node_modules/kysely/dist/esm/operation-node/aggregate-function-node.d.ts

@@ -0,0 +1,29 @@
+import type { OperationNode } from './operation-node.js';
+import type { OverNode } from './over-node.js';
+import { WhereNode } from './where-node.js';
+import { OrderByNode } from './order-by-node.js';
+import type { OrderByItemNode } from './order-by-item-node.js';
+export interface AggregateFunctionNode extends OperationNode {
+    readonly kind: 'AggregateFunctionNode';
+    readonly func: string;
+    readonly aggregated: readonly OperationNode[];
+    readonly distinct?: boolean;
+    readonly orderBy?: OrderByNode;
+    readonly withinGroup?: OrderByNode;
+    readonly filter?: WhereNode;
+    readonly over?: OverNode;
+}
+type AggregateFunctionNodeFactory = Readonly<{
+    is(node: OperationNode): node is AggregateFunctionNode;
+    create(aggregateFunction: string, aggregated?: readonly OperationNode[]): Readonly<AggregateFunctionNode>;
+    cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): Readonly<AggregateFunctionNode>;
+    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>, withinGroup?: boolean): Readonly<AggregateFunctionNode>;
+    cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): Readonly<AggregateFunctionNode>;
+    cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): Readonly<AggregateFunctionNode>;
+    cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): Readonly<AggregateFunctionNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const AggregateFunctionNode: AggregateFunctionNodeFactory;
+export {};

node_modules/kysely/dist/esm/operation-node/aggregate-function-node.js

@@ -0,0 +1,56 @@
+/// <reference types="./aggregate-function-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { WhereNode } from './where-node.js';
+import { OrderByNode } from './order-by-node.js';
+/**
+ * @internal
+ */
+export const AggregateFunctionNode = freeze({
+    is(node) {
+        return node.kind === 'AggregateFunctionNode';
+    },
+    create(aggregateFunction, aggregated = []) {
+        return freeze({
+            kind: 'AggregateFunctionNode',
+            func: aggregateFunction,
+            aggregated,
+        });
+    },
+    cloneWithDistinct(aggregateFunctionNode) {
+        return freeze({
+            ...aggregateFunctionNode,
+            distinct: true,
+        });
+    },
+    cloneWithOrderBy(aggregateFunctionNode, orderItems, withinGroup = false) {
+        const prop = withinGroup ? 'withinGroup' : 'orderBy';
+        return freeze({
+            ...aggregateFunctionNode,
+            [prop]: aggregateFunctionNode[prop]
+                ? OrderByNode.cloneWithItems(aggregateFunctionNode[prop], orderItems)
+                : OrderByNode.create(orderItems),
+        });
+    },
+    cloneWithFilter(aggregateFunctionNode, filter) {
+        return freeze({
+            ...aggregateFunctionNode,
+            filter: aggregateFunctionNode.filter
+                ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'And', filter)
+                : WhereNode.create(filter),
+        });
+    },
+    cloneWithOrFilter(aggregateFunctionNode, filter) {
+        return freeze({
+            ...aggregateFunctionNode,
+            filter: aggregateFunctionNode.filter
+                ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'Or', filter)
+                : WhereNode.create(filter),
+        });
+    },
+    cloneWithOver(aggregateFunctionNode, over) {
+        return freeze({
+            ...aggregateFunctionNode,
+            over,
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/alias-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/alias-node.js

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

node_modules/kysely/dist/esm/operation-node/alter-column-node.d.ts

@@ -0,0 +1,23 @@
+import type { OperationNode } from './operation-node.js';
+import { ColumnNode } from './column-node.js';
+import type { RawNode } from './raw-node.js';
+export type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>;
+export interface AlterColumnNode extends OperationNode {
+    readonly kind: 'AlterColumnNode';
+    readonly column: ColumnNode;
+    readonly dataType?: OperationNode;
+    readonly dataTypeExpression?: RawNode;
+    readonly setDefault?: OperationNode;
+    readonly dropDefault?: true;
+    readonly setNotNull?: true;
+    readonly dropNotNull?: true;
+}
+type AlterColumnNodeFactory = Readonly<{
+    is(node: OperationNode): node is AlterColumnNode;
+    create<T extends keyof AlterColumnNodeProps>(column: string, prop: T, value: Required<AlterColumnNodeProps>[T]): Readonly<AlterColumnNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const AlterColumnNode: AlterColumnNodeFactory;
+export {};

node_modules/kysely/dist/esm/operation-node/alter-column-node.js

@@ -0,0 +1,18 @@
+/// <reference types="./alter-column-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { ColumnNode } from './column-node.js';
+/**
+ * @internal
+ */
+export const AlterColumnNode = freeze({
+    is(node) {
+        return node.kind === 'AlterColumnNode';
+    },
+    create(column, prop, value) {
+        return freeze({
+            kind: 'AlterColumnNode',
+            column: ColumnNode.create(column),
+            [prop]: value,
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/alter-table-node.d.ts

@@ -0,0 +1,38 @@
+import type { OperationNode } from './operation-node.js';
+import type { AddColumnNode } from './add-column-node.js';
+import type { DropColumnNode } from './drop-column-node.js';
+import type { TableNode } from './table-node.js';
+import type { IdentifierNode } from './identifier-node.js';
+import type { RenameColumnNode } from './rename-column-node.js';
+import type { AlterColumnNode } from './alter-column-node.js';
+import type { AddConstraintNode } from './add-constraint-node.js';
+import type { DropConstraintNode } from './drop-constraint-node.js';
+import type { ModifyColumnNode } from './modify-column-node.js';
+import type { DropIndexNode } from './drop-index-node.js';
+import type { AddIndexNode } from './add-index-node.js';
+import type { RenameConstraintNode } from './rename-constraint-node.js';
+export type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint' | 'addIndex' | 'dropIndex' | 'renameConstraint'>;
+export type AlterTableColumnAlterationNode = RenameColumnNode | AddColumnNode | DropColumnNode | AlterColumnNode | ModifyColumnNode;
+export interface AlterTableNode extends OperationNode {
+    readonly kind: 'AlterTableNode';
+    readonly table: TableNode;
+    readonly renameTo?: TableNode;
+    readonly setSchema?: IdentifierNode;
+    readonly columnAlterations?: ReadonlyArray<AlterTableColumnAlterationNode>;
+    readonly addConstraint?: AddConstraintNode;
+    readonly dropConstraint?: DropConstraintNode;
+    readonly renameConstraint?: RenameConstraintNode;
+    readonly addIndex?: AddIndexNode;
+    readonly dropIndex?: DropIndexNode;
+}
+type AlterTableNodeFactory = Readonly<{
+    is(node: OperationNode): node is AlterTableNode;
+    create(table: TableNode): Readonly<AlterTableNode>;
+    cloneWithTableProps(node: AlterTableNode, props: AlterTableNodeTableProps): Readonly<AlterTableNode>;
+    cloneWithColumnAlteration(node: AlterTableNode, columnAlteration: AlterTableColumnAlterationNode): Readonly<AlterTableNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const AlterTableNode: AlterTableNodeFactory;
+export {};

node_modules/kysely/dist/esm/operation-node/alter-table-node.js

@@ -0,0 +1,30 @@
+/// <reference types="./alter-table-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const AlterTableNode = freeze({
+    is(node) {
+        return node.kind === 'AlterTableNode';
+    },
+    create(table) {
+        return freeze({
+            kind: 'AlterTableNode',
+            table,
+        });
+    },
+    cloneWithTableProps(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
+    cloneWithColumnAlteration(node, columnAlteration) {
+        return freeze({
+            ...node,
+            columnAlterations: node.columnAlterations
+                ? [...node.columnAlterations, columnAlteration]
+                : [columnAlteration],
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/and-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/and-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./and-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const AndNode = freeze({
+    is(node) {
+        return node.kind === 'AndNode';
+    },
+    create(left, right) {
+        return freeze({
+            kind: 'AndNode',
+            left,
+            right,
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/binary-operation-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/binary-operation-node.js

@@ -0,0 +1,18 @@
+/// <reference types="./binary-operation-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const BinaryOperationNode = freeze({
+    is(node) {
+        return node.kind === 'BinaryOperationNode';
+    },
+    create(leftOperand, operator, rightOperand) {
+        return freeze({
+            kind: 'BinaryOperationNode',
+            leftOperand,
+            operator,
+            rightOperand,
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/case-node.d.ts

@@ -0,0 +1,21 @@
+import type { OperationNode } from './operation-node.js';
+import { WhenNode } from './when-node.js';
+export interface CaseNode extends OperationNode {
+    readonly kind: 'CaseNode';
+    readonly value?: OperationNode;
+    readonly when?: ReadonlyArray<WhenNode>;
+    readonly else?: OperationNode;
+    readonly isStatement?: boolean;
+}
+type CaseNodeFactory = Readonly<{
+    is(node: OperationNode): node is CaseNode;
+    create(value?: OperationNode): Readonly<CaseNode>;
+    cloneWithWhen(caseNode: CaseNode, when: WhenNode): Readonly<CaseNode>;
+    cloneWithThen(caseNode: CaseNode, then: OperationNode): Readonly<CaseNode>;
+    cloneWith(caseNode: CaseNode, props: Partial<Pick<CaseNode, 'else' | 'isStatement'>>): Readonly<CaseNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CaseNode: CaseNodeFactory;
+export {};

node_modules/kysely/dist/esm/operation-node/case-node.js

@@ -0,0 +1,40 @@
+/// <reference types="./case-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { WhenNode } from './when-node.js';
+/**
+ * @internal
+ */
+export const CaseNode = freeze({
+    is(node) {
+        return node.kind === 'CaseNode';
+    },
+    create(value) {
+        return freeze({
+            kind: 'CaseNode',
+            value,
+        });
+    },
+    cloneWithWhen(caseNode, when) {
+        return freeze({
+            ...caseNode,
+            when: freeze(caseNode.when ? [...caseNode.when, when] : [when]),
+        });
+    },
+    cloneWithThen(caseNode, then) {
+        return freeze({
+            ...caseNode,
+            when: caseNode.when
+                ? freeze([
+                    ...caseNode.when.slice(0, -1),
+                    WhenNode.cloneWithResult(caseNode.when[caseNode.when.length - 1], then),
+                ])
+                : undefined,
+        });
+    },
+    cloneWith(caseNode, props) {
+        return freeze({
+            ...caseNode,
+            ...props,
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/cast-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/cast-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./cast-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const CastNode = freeze({
+    is(node) {
+        return node.kind === 'CastNode';
+    },
+    create(expression, dataType) {
+        return freeze({
+            kind: 'CastNode',
+            expression,
+            dataType,
+        });
+    },
+});

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

@@ -0,0 +1,16 @@
+import type { OperationNode } from './operation-node.js';
+import { IdentifierNode } from './identifier-node.js';
+export interface CheckConstraintNode extends OperationNode {
+    readonly kind: 'CheckConstraintNode';
+    readonly expression: OperationNode;
+    readonly name?: IdentifierNode;
+}
+type CheckConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is CheckConstraintNode;
+    create(expression: OperationNode, constraintName?: string): Readonly<CheckConstraintNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CheckConstraintNode: CheckConstraintNodeFactory;
+export {};

node_modules/kysely/dist/esm/operation-node/check-constraint-node.js

@@ -0,0 +1,20 @@
+/// <reference types="./check-constraint-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const CheckConstraintNode = freeze({
+    is(node) {
+        return node.kind === 'CheckConstraintNode';
+    },
+    create(expression, constraintName) {
+        return freeze({
+            kind: 'CheckConstraintNode',
+            expression,
+            name: constraintName
+                ? IdentifierNode.create(constraintName)
+                : undefined,
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/collate-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/collate-node.js

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

node_modules/kysely/dist/esm/operation-node/column-definition-node.d.ts

@@ -0,0 +1,38 @@
+import type { CheckConstraintNode } from './check-constraint-node.js';
+import { ColumnNode } from './column-node.js';
+import type { DefaultValueNode } from './default-value-node.js';
+import type { GeneratedNode } from './generated-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ReferencesNode } from './references-node.js';
+export type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind' | 'dataType'>;
+export interface ColumnDefinitionNode extends OperationNode {
+    readonly kind: 'ColumnDefinitionNode';
+    readonly column: ColumnNode;
+    readonly dataType: OperationNode;
+    readonly references?: ReferencesNode;
+    readonly primaryKey?: boolean;
+    readonly autoIncrement?: boolean;
+    readonly unique?: boolean;
+    readonly notNull?: boolean;
+    readonly defaultTo?: DefaultValueNode;
+    readonly check?: CheckConstraintNode;
+    readonly generated?: GeneratedNode;
+    readonly unsigned?: boolean;
+    readonly frontModifiers?: ReadonlyArray<OperationNode>;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
+    readonly nullsNotDistinct?: boolean;
+    readonly identity?: boolean;
+    readonly ifNotExists?: boolean;
+}
+type ColumnDefinitionNodeFactory = Readonly<{
+    is(node: OperationNode): node is ColumnDefinitionNode;
+    create(column: string, dataType: OperationNode): Readonly<ColumnDefinitionNode>;
+    cloneWithFrontModifier(node: ColumnDefinitionNode, modifier: OperationNode): Readonly<ColumnDefinitionNode>;
+    cloneWithEndModifier(node: ColumnDefinitionNode, modifier: OperationNode): Readonly<ColumnDefinitionNode>;
+    cloneWith(node: ColumnDefinitionNode, props: ColumnDefinitionNodeProps): Readonly<ColumnDefinitionNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const ColumnDefinitionNode: ColumnDefinitionNodeFactory;
+export {};

node_modules/kysely/dist/esm/operation-node/column-definition-node.js

@@ -0,0 +1,40 @@
+/// <reference types="./column-definition-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { ColumnNode } from './column-node.js';
+/**
+ * @internal
+ */
+export const ColumnDefinitionNode = freeze({
+    is(node) {
+        return node.kind === 'ColumnDefinitionNode';
+    },
+    create(column, dataType) {
+        return freeze({
+            kind: 'ColumnDefinitionNode',
+            column: ColumnNode.create(column),
+            dataType,
+        });
+    },
+    cloneWithFrontModifier(node, modifier) {
+        return freeze({
+            ...node,
+            frontModifiers: node.frontModifiers
+                ? freeze([...node.frontModifiers, modifier])
+                : [modifier],
+        });
+    },
+    cloneWithEndModifier(node, modifier) {
+        return freeze({
+            ...node,
+            endModifiers: node.endModifiers
+                ? freeze([...node.endModifiers, modifier])
+                : [modifier],
+        });
+    },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/column-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/column-node.js

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

node_modules/kysely/dist/esm/operation-node/column-update-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/column-update-node.js

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

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 {};

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,
+        });
+    },
+});

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 {};

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,
+        });
+    },
+});

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;

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

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

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 {};

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],
+        });
+    },
+});

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 {};

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,
+        });
+    },
+});

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 {};

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,
+        });
+    },
+});

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 {};

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)),
+        });
+    },
+});

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 {};

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,
+        });
+    },
+});

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 {};

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;
+}

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 {};

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',
+        });
+    },
+});

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 {};

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,
+        });
+    },
+});

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 {};

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),
+        });
+    },
+});

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/drop-column-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./drop-column-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { ColumnNode } from './column-node.js';
+/**
+ * @internal
+ */
+export const DropColumnNode = freeze({
+    is(node) {
+        return node.kind === 'DropColumnNode';
+    },
+    create(column) {
+        return freeze({
+            kind: 'DropColumnNode',
+            column: ColumnNode.create(column),
+        });
+    },
+});

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/drop-constraint-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./drop-constraint-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const DropConstraintNode = freeze({
+    is(node) {
+        return node.kind === 'DropConstraintNode';
+    },
+    create(constraintName) {
+        return freeze({
+            kind: 'DropConstraintNode',
+            constraintName: IdentifierNode.create(constraintName),
+        });
+    },
+    cloneWith(dropConstraint, props) {
+        return freeze({
+            ...dropConstraint,
+            ...props,
+        });
+    },
+});

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/drop-index-node.js

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

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/drop-schema-node.js

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

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/drop-table-node.js

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

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/drop-type-node.js

@@ -0,0 +1,22 @@
+/// <reference types="./drop-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const DropTypeNode = freeze({
+    is(node) {
+        return node.kind === 'DropTypeNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'DropTypeNode',
+            name,
+        });
+    },
+    cloneWith(dropType, params) {
+        return freeze({
+            ...dropType,
+            ...params,
+        });
+    },
+});

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/drop-view-node.js

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

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/explain-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./explain-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const ExplainNode = freeze({
+    is(node) {
+        return node.kind === 'ExplainNode';
+    },
+    create(format, options) {
+        return freeze({
+            kind: 'ExplainNode',
+            format,
+            options,
+        });
+    },
+});

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/fetch-node.js

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

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/foreign-key-constraint-node.js

@@ -0,0 +1,28 @@
+/// <reference types="./foreign-key-constraint-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+import { ReferencesNode, } from './references-node.js';
+/**
+ * @internal
+ */
+export const ForeignKeyConstraintNode = freeze({
+    is(node) {
+        return node.kind === 'ForeignKeyConstraintNode';
+    },
+    create(sourceColumns, targetTable, targetColumns, constraintName) {
+        return freeze({
+            kind: 'ForeignKeyConstraintNode',
+            columns: sourceColumns,
+            references: ReferencesNode.create(targetTable, targetColumns),
+            name: constraintName
+                ? IdentifierNode.create(constraintName)
+                : undefined,
+        });
+    },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
+});

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/from-node.js

@@ -0,0 +1,22 @@
+/// <reference types="./from-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const FromNode = freeze({
+    is(node) {
+        return node.kind === 'FromNode';
+    },
+    create(froms) {
+        return freeze({
+            kind: 'FromNode',
+            froms: freeze(froms),
+        });
+    },
+    cloneWithFroms(from, froms) {
+        return freeze({
+            ...from,
+            froms: freeze([...from.froms, ...froms]),
+        });
+    },
+});

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/function-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./function-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const FunctionNode = freeze({
+    is(node) {
+        return node.kind === 'FunctionNode';
+    },
+    create(func, args) {
+        return freeze({
+            kind: 'FunctionNode',
+            func,
+            arguments: args,
+        });
+    },
+});

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/generated-node.js

@@ -0,0 +1,29 @@
+/// <reference types="./generated-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const GeneratedNode = freeze({
+    is(node) {
+        return node.kind === 'GeneratedNode';
+    },
+    create(params) {
+        return freeze({
+            kind: 'GeneratedNode',
+            ...params,
+        });
+    },
+    createWithExpression(expression) {
+        return freeze({
+            kind: 'GeneratedNode',
+            always: true,
+            expression,
+        });
+    },
+    cloneWith(node, params) {
+        return freeze({
+            ...node,
+            ...params,
+        });
+    },
+});

node_modules/kysely/dist/esm/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 {};

node_modules/kysely/dist/esm/operation-node/group-by-item-node.js

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

node_modules/kysely/dist/esm/operation-node/group-by-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/group-by-node.js

@@ -0,0 +1,22 @@
+/// <reference types="./group-by-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const GroupByNode = freeze({
+    is(node) {
+        return node.kind === 'GroupByNode';
+    },
+    create(items) {
+        return freeze({
+            kind: 'GroupByNode',
+            items: freeze(items),
+        });
+    },
+    cloneWithItems(groupBy, items) {
+        return freeze({
+            ...groupBy,
+            items: freeze([...groupBy.items, ...items]),
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/having-node.d.ts

@@ -0,0 +1,15 @@
+import type { OperationNode } from './operation-node.js';
+export interface HavingNode extends OperationNode {
+    readonly kind: 'HavingNode';
+    readonly having: OperationNode;
+}
+type HavingNodeFactory = Readonly<{
+    is(node: OperationNode): node is HavingNode;
+    create(filter: OperationNode): Readonly<HavingNode>;
+    cloneWithOperation(havingNode: HavingNode, operator: 'And' | 'Or', operation: OperationNode): Readonly<HavingNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const HavingNode: HavingNodeFactory;
+export {};

node_modules/kysely/dist/esm/operation-node/having-node.js

@@ -0,0 +1,26 @@
+/// <reference types="./having-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { AndNode } from './and-node.js';
+import { OrNode } from './or-node.js';
+/**
+ * @internal
+ */
+export const HavingNode = freeze({
+    is(node) {
+        return node.kind === 'HavingNode';
+    },
+    create(filter) {
+        return freeze({
+            kind: 'HavingNode',
+            having: filter,
+        });
+    },
+    cloneWithOperation(havingNode, operator, operation) {
+        return freeze({
+            ...havingNode,
+            having: operator === 'And'
+                ? AndNode.create(havingNode.having, operation)
+                : OrNode.create(havingNode.having, operation),
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/identifier-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/identifier-node.js

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

node_modules/kysely/dist/esm/operation-node/insert-query-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/insert-query-node.js

@@ -0,0 +1,29 @@
+/// <reference types="./insert-query-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const InsertQueryNode = freeze({
+    is(node) {
+        return node.kind === 'InsertQueryNode';
+    },
+    create(into, withNode, replace) {
+        return freeze({
+            kind: 'InsertQueryNode',
+            into,
+            ...(withNode && { with: withNode }),
+            replace,
+        });
+    },
+    createWithoutInto() {
+        return freeze({
+            kind: 'InsertQueryNode',
+        });
+    },
+    cloneWith(insertQuery, props) {
+        return freeze({
+            ...insertQuery,
+            ...props,
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/join-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/join-node.js

@@ -0,0 +1,35 @@
+/// <reference types="./join-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { OnNode } from './on-node.js';
+/**
+ * @internal
+ */
+export const JoinNode = freeze({
+    is(node) {
+        return node.kind === 'JoinNode';
+    },
+    create(joinType, table) {
+        return freeze({
+            kind: 'JoinNode',
+            joinType,
+            table,
+            on: undefined,
+        });
+    },
+    createWithOn(joinType, table, on) {
+        return freeze({
+            kind: 'JoinNode',
+            joinType,
+            table,
+            on: OnNode.create(on),
+        });
+    },
+    cloneWithOn(joinNode, operation) {
+        return freeze({
+            ...joinNode,
+            on: joinNode.on
+                ? OnNode.cloneWithOperation(joinNode.on, 'And', operation)
+                : OnNode.create(operation),
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/json-operator-chain-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/json-operator-chain-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./json-operator-chain-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const JSONOperatorChainNode = freeze({
+    is(node) {
+        return node.kind === 'JSONOperatorChainNode';
+    },
+    create(operator) {
+        return freeze({
+            kind: 'JSONOperatorChainNode',
+            operator,
+            values: freeze([]),
+        });
+    },
+    cloneWithValue(node, value) {
+        return freeze({
+            ...node,
+            values: freeze([...node.values, value]),
+        });
+    },
+});

node_modules/kysely/dist/esm/operation-node/json-path-leg-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/json-path-leg-node.js

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

node_modules/kysely/dist/esm/operation-node/json-path-node.d.ts

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

node_modules/kysely/dist/esm/operation-node/json-path-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./json-path-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const JSONPathNode = freeze({
+    is(node) {
+        return node.kind === 'JSONPathNode';
+    },
+    create(inOperator) {
+        return freeze({
+            kind: 'JSONPathNode',
+            inOperator,
+            pathLegs: freeze([]),
+        });
+    },
+    cloneWithLeg(jsonPathNode, pathLeg) {
+        return freeze({
+            ...jsonPathNode,
+            pathLegs: freeze([...jsonPathNode.pathLegs, pathLeg]),
+        });
+    },
+});