@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/cjs/query-builder/on-conflict-builder.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnConflictUpdateBuilder = exports.OnConflictDoNothingBuilder = exports.OnConflictBuilder = void 0;
+const column_node_js_1 = require("../operation-node/column-node.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const on_conflict_node_js_1 = require("../operation-node/on-conflict-node.js");
+const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const update_set_parser_js_1 = require("../parser/update-set-parser.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+class OnConflictBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * Specify a single column as the conflict target.
+     *
+     * Also see the {@link columns}, {@link constraint} and {@link expression}
+     * methods for alternative ways to specify the conflict target.
+     */
+    column(column) {
+        const columnNode = column_node_js_1.ColumnNode.create(column);
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                columns: this.#props.onConflictNode.columns
+                    ? (0, object_utils_js_1.freeze)([...this.#props.onConflictNode.columns, columnNode])
+                    : (0, object_utils_js_1.freeze)([columnNode]),
+            }),
+        });
+    }
+    /**
+     * Specify a list of columns as the conflict target.
+     *
+     * Also see the {@link column}, {@link constraint} and {@link expression}
+     * methods for alternative ways to specify the conflict target.
+     */
+    columns(columns) {
+        const columnNodes = columns.map(column_node_js_1.ColumnNode.create);
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                columns: this.#props.onConflictNode.columns
+                    ? (0, object_utils_js_1.freeze)([...this.#props.onConflictNode.columns, ...columnNodes])
+                    : (0, object_utils_js_1.freeze)(columnNodes),
+            }),
+        });
+    }
+    /**
+     * Specify a specific constraint by name as the conflict target.
+     *
+     * Also see the {@link column}, {@link columns} and {@link expression}
+     * methods for alternative ways to specify the conflict target.
+     */
+    constraint(constraintName) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                constraint: identifier_node_js_1.IdentifierNode.create(constraintName),
+            }),
+        });
+    }
+    /**
+     * Specify an expression as the conflict target.
+     *
+     * This can be used if the unique index is an expression index.
+     *
+     * Also see the {@link column}, {@link columns} and {@link constraint}
+     * methods for alternative ways to specify the conflict target.
+     */
+    expression(expression) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                indexExpression: expression.toOperationNode(),
+            }),
+        });
+    }
+    where(...args) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),
+        });
+    }
+    whereRef(lhs, op, rhs) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs)),
+        });
+    }
+    clearWhere() {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithoutIndexWhere(this.#props.onConflictNode),
+        });
+    }
+    /**
+     * Adds the "do nothing" conflict action.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const id = 1
+     * const first_name = 'John'
+     *
+     * await db
+     *   .insertInto('person')
+     *   .values({ first_name, id })
+     *   .onConflict((oc) => oc
+     *     .column('id')
+     *     .doNothing()
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "id")
+     * values ($1, $2)
+     * on conflict ("id") do nothing
+     * ```
+     */
+    doNothing() {
+        return new OnConflictDoNothingBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                doNothing: true,
+            }),
+        });
+    }
+    /**
+     * Adds the "do update set" conflict action.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const id = 1
+     * const first_name = 'John'
+     *
+     * await db
+     *   .insertInto('person')
+     *   .values({ first_name, id })
+     *   .onConflict((oc) => oc
+     *     .column('id')
+     *     .doUpdateSet({ first_name })
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "id")
+     * values ($1, $2)
+     * on conflict ("id")
+     * do update set "first_name" = $3
+     * ```
+     *
+     * In the next example we use the `ref` method to reference
+     * columns of the virtual table `excluded` in a type-safe way
+     * to create an upsert operation:
+     *
+     * ```ts
+     * import type { NewPerson } from 'type-editor' // imaginary module
+     *
+     * async function upsertPerson(person: NewPerson): Promise<void> {
+     *   await db.insertInto('person')
+     *     .values(person)
+     *     .onConflict((oc) => oc
+     *       .column('id')
+     *       .doUpdateSet((eb) => ({
+     *         first_name: eb.ref('excluded.first_name'),
+     *         last_name: eb.ref('excluded.last_name')
+     *       })
+     *     )
+     *   )
+     *   .execute()
+     * }
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "last_name")
+     * values ($1, $2)
+     * on conflict ("id")
+     * do update set
+     *  "first_name" = excluded."first_name",
+     *  "last_name" = excluded."last_name"
+     * ```
+     */
+    doUpdateSet(update) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                updates: (0, update_set_parser_js_1.parseUpdateObjectExpression)(update),
+            }),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+}
+exports.OnConflictBuilder = OnConflictBuilder;
+class OnConflictDoNothingBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    toOperationNode() {
+        return this.#props.onConflictNode;
+    }
+}
+exports.OnConflictDoNothingBuilder = OnConflictDoNothingBuilder;
+class OnConflictUpdateBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    where(...args) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),
+        });
+    }
+    /**
+     * Specify a where condition for the update operation.
+     *
+     * See {@link WhereInterface.whereRef} for more info.
+     */
+    whereRef(lhs, op, rhs) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs)),
+        });
+    }
+    clearWhere() {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: on_conflict_node_js_1.OnConflictNode.cloneWithoutUpdateWhere(this.#props.onConflictNode),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    toOperationNode() {
+        return this.#props.onConflictNode;
+    }
+}
+exports.OnConflictUpdateBuilder = OnConflictUpdateBuilder;

package/dist/server/node_modules/kysely/dist/cjs/query-builder/order-by-interface.d.ts

@@ -0,0 +1,158 @@
+import type { Expression } from '../expression/expression.js';
+import type { OrderByExpression, DirectedOrderByStringReference, OrderByModifiers } from '../parser/order-by-parser.js';
+export interface OrderByInterface<DB, TB extends keyof DB, O> {
+    /**
+     * Adds an `order by` clause to the query.
+     *
+     * `orderBy` calls are additive. Meaning, additional `orderBy` calls append to
+     * the existing order by clause.
+     *
+     * `orderBy` is supported in select queries on all dialects. In MySQL, you can
+     * also use `orderBy` in update and delete queries.
+     *
+     * In a single call you can add a single column/expression or multiple columns/expressions.
+     *
+     * Single column/expression calls can have 1-2 arguments. The first argument is
+     * the expression to order by, while the second optional argument is the direction
+     * (`asc` or `desc`), a callback that accepts and returns an {@link OrderByItemBuilder}
+     * or an expression.
+     *
+     * See {@link clearOrderBy} to remove the `order by` clause from a query.
+     *
+     * ### Examples
+     *
+     * Single column/expression per call:
+     *
+     * ```ts
+     * await db
+     *   .selectFrom('person')
+     *   .select('person.first_name as fn')
+     *   .orderBy('id')
+     *   .orderBy('fn', 'desc')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person"."first_name" as "fn"
+     * from "person"
+     * order by "id", "fn" desc
+     * ```
+     *
+     * Building advanced modifiers:
+     *
+     * ```ts
+     * await db
+     *   .selectFrom('person')
+     *   .select('person.first_name as fn')
+     *   .orderBy('id', (ob) => ob.desc().nullsFirst())
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person"."first_name" as "fn"
+     * from "person"
+     * order by "id" desc nulls first
+     * ```
+     *
+     * The order by expression can also be a raw sql expression or a subquery
+     * in addition to column references:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .orderBy((eb) => eb.selectFrom('pet')
+     *     .select('pet.name')
+     *     .whereRef('pet.owner_id', '=', 'person.id')
+     *     .limit(1)
+     *   )
+     *   .orderBy(
+     *     sql<string>`concat(first_name, last_name) asc`
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * order by
+     *   ( select "pet"."name"
+     *     from "pet"
+     *     where "pet"."owner_id" = "person"."id"
+     *     limit $1
+     *   ) asc,
+     *   concat(first_name, last_name) asc
+     * ```
+     *
+     * `dynamic.ref` can be used to refer to columns not known at
+     * compile time:
+     *
+     * ```ts
+     * async function someQuery(orderBy: string) {
+     *   const { ref } = db.dynamic
+     *
+     *   return await db
+     *     .selectFrom('person')
+     *     .select('person.first_name as fn')
+     *     .orderBy(ref(orderBy))
+     *     .execute()
+     * }
+     *
+     * someQuery('fn')
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person"."first_name" as "fn"
+     * from "person"
+     * order by "fn"
+     * ```
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, O>>(expr: OE, modifiers?: OrderByModifiers): OrderByInterface<DB, TB, O>;
+    /**
+     * @deprecated It does ~2-2.6x more compile-time instantiations compared to multiple chained `orderBy(expr, modifiers?)` calls (in `order by` clauses with reasonable item counts), and has broken autocompletion.
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, O> | DirectedOrderByStringReference<DB, TB, O>>(exprs: ReadonlyArray<OE>): OrderByInterface<DB, TB, O>;
+    /**
+     * @deprecated It does ~2.9x more compile-time instantiations compared to a `orderBy(expr, direction)` call.
+     */
+    orderBy<OE extends DirectedOrderByStringReference<DB, TB, O>>(expr: OE): OrderByInterface<DB, TB, O>;
+    /**
+     * @deprecated Use `orderBy(expr, (ob) => ...)` instead.
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, O>>(expr: OE, modifiers: Expression<any>): OrderByInterface<DB, TB, O>;
+    /**
+     * Clears the `order by` clause from the query.
+     *
+     * See {@link orderBy} for adding an `order by` clause or item to a query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const query = db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .orderBy('id', 'desc')
+     *
+     * const results = await query
+     *   .clearOrderBy()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearOrderBy(): OrderByInterface<DB, TB, O>;
+}

package/dist/server/node_modules/kysely/dist/cjs/query-builder/order-by-interface.js

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

package/dist/server/node_modules/kysely/dist/cjs/query-builder/order-by-item-builder.d.ts

@@ -0,0 +1,43 @@
+import type { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
+import type { Collation } from '../parser/collate-parser.js';
+export declare class OrderByItemBuilder implements OperationNodeSource {
+    #private;
+    constructor(props: OrderByItemBuilderProps);
+    /**
+     * Adds `desc` to the `order by` item.
+     *
+     * See {@link asc} for the opposite.
+     */
+    desc(): OrderByItemBuilder;
+    /**
+     * Adds `asc` to the `order by` item.
+     *
+     * See {@link desc} for the opposite.
+     */
+    asc(): OrderByItemBuilder;
+    /**
+     * Adds `nulls last` to the `order by` item.
+     *
+     * This is only supported by some dialects like PostgreSQL and SQLite.
+     *
+     * See {@link nullsFirst} for the opposite.
+     */
+    nullsLast(): OrderByItemBuilder;
+    /**
+     * Adds `nulls first` to the `order by` item.
+     *
+     * This is only supported by some dialects like PostgreSQL and SQLite.
+     *
+     * See {@link nullsLast} for the opposite.
+     */
+    nullsFirst(): OrderByItemBuilder;
+    /**
+     * Adds `collate <collationName>` to the `order by` item.
+     */
+    collate(collation: Collation): OrderByItemBuilder;
+    toOperationNode(): OrderByItemNode;
+}
+export interface OrderByItemBuilderProps {
+    readonly node: OrderByItemNode;
+}

package/dist/server/node_modules/kysely/dist/cjs/query-builder/order-by-item-builder.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderByItemBuilder = void 0;
+const collate_node_js_1 = require("../operation-node/collate-node.js");
+const order_by_item_node_js_1 = require("../operation-node/order-by-item-node.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+class OrderByItemBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * Adds `desc` to the `order by` item.
+     *
+     * See {@link asc} for the opposite.
+     */
+    desc() {
+        return new OrderByItemBuilder({
+            node: order_by_item_node_js_1.OrderByItemNode.cloneWith(this.#props.node, {
+                direction: raw_node_js_1.RawNode.createWithSql('desc'),
+            }),
+        });
+    }
+    /**
+     * Adds `asc` to the `order by` item.
+     *
+     * See {@link desc} for the opposite.
+     */
+    asc() {
+        return new OrderByItemBuilder({
+            node: order_by_item_node_js_1.OrderByItemNode.cloneWith(this.#props.node, {
+                direction: raw_node_js_1.RawNode.createWithSql('asc'),
+            }),
+        });
+    }
+    /**
+     * Adds `nulls last` to the `order by` item.
+     *
+     * This is only supported by some dialects like PostgreSQL and SQLite.
+     *
+     * See {@link nullsFirst} for the opposite.
+     */
+    nullsLast() {
+        return new OrderByItemBuilder({
+            node: order_by_item_node_js_1.OrderByItemNode.cloneWith(this.#props.node, { nulls: 'last' }),
+        });
+    }
+    /**
+     * Adds `nulls first` to the `order by` item.
+     *
+     * This is only supported by some dialects like PostgreSQL and SQLite.
+     *
+     * See {@link nullsLast} for the opposite.
+     */
+    nullsFirst() {
+        return new OrderByItemBuilder({
+            node: order_by_item_node_js_1.OrderByItemNode.cloneWith(this.#props.node, { nulls: 'first' }),
+        });
+    }
+    /**
+     * Adds `collate <collationName>` to the `order by` item.
+     */
+    collate(collation) {
+        return new OrderByItemBuilder({
+            node: order_by_item_node_js_1.OrderByItemNode.cloneWith(this.#props.node, {
+                collation: collate_node_js_1.CollateNode.create(collation),
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.node;
+    }
+}
+exports.OrderByItemBuilder = OrderByItemBuilder;

package/dist/server/node_modules/kysely/dist/cjs/query-builder/output-interface.d.ts

@@ -0,0 +1,138 @@
+import type { ExpressionBuilder } from '../expression/expression-builder.js';
+import type { AliasedExpressionOrFactory } from '../parser/expression-parser.js';
+import type { ReturningAllRow, ReturningRow } from '../parser/returning-parser.js';
+import type { AnyAliasedColumnWithTable, AnyColumnWithTable } from '../util/type-utils.js';
+export interface OutputInterface<DB, TB extends keyof DB, O, OP extends OutputPrefix = OutputPrefix> {
+    /**
+     * Allows you to return data from modified rows.
+     *
+     * On supported databases like MS SQL Server (MSSQL), this method can be chained
+     * to `insert`, `update`, `delete` and `merge` queries to return data.
+     *
+     * Also see the {@link outputAll} method.
+     *
+     * ### Examples
+     *
+     * Return one column:
+     *
+     * ```ts
+     * const { id } = await db
+     *   .insertInto('person')
+     *   .output('inserted.id')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston',
+     *     gender: 'female',
+     *   })
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "last_name", "gender")
+     * output "inserted"."id"
+     * values (@1, @2, @3)
+     * ```
+     *
+     * Return multiple columns:
+     *
+     * ```ts
+     * const { old_first_name, old_last_name, new_first_name, new_last_name } = await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'John', last_name: 'Doe' })
+     *   .output([
+     *     'deleted.first_name as old_first_name',
+     *     'deleted.last_name as old_last_name',
+     *     'inserted.first_name as new_first_name',
+     *     'inserted.last_name as new_last_name',
+     *   ])
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * update "person"
+     * set "first_name" = @1, "last_name" = @2
+     * output "deleted"."first_name" as "old_first_name",
+     *   "deleted"."last_name" as "old_last_name",
+     *   "inserted"."first_name" as "new_first_name",
+     *   "inserted"."last_name" as "new_last_name"
+     * where "created_at" < @3
+     * ```
+     *
+     * Return arbitrary expressions:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const { full_name } = await db
+     *   .deleteFrom('person')
+     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name'))
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * delete from "person"
+     * output concat("deleted"."first_name", ' ', "deleted"."last_name") as "full_name"
+     * where "created_at" < @1
+     * ```
+     *
+     * Return the action performed on the row:
+     *
+     * ```ts
+     * await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .whenNotMatched()
+     *   .thenInsertValues({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'male'
+     *   })
+     *   .output([
+     *     'inserted.id as inserted_id',
+     *     'deleted.id as deleted_id',
+     *   ])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet" on "pet"."owner_id" = "person"."id"
+     * when matched then delete
+     * when not matched then
+     * insert ("first_name", "last_name", "gender")
+     * values (@1, @2, @3)
+     * output "inserted"."id" as "inserted_id", "deleted"."id" as "deleted_id"
+     * ```
+     *
+     */
+    output<OE extends OutputExpression<DB, TB, OP>>(selections: ReadonlyArray<OE>): OutputInterface<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>, OP>;
+    output<CB extends OutputCallback<DB, TB, OP>>(callback: CB): OutputInterface<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputCallback<CB>>, OP>;
+    output<OE extends OutputExpression<DB, TB, OP>>(selection: OE): OutputInterface<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>, OP>;
+    /**
+     * Adds an `output {prefix}.*` to an `insert`/`update`/`delete`/`merge` query on databases
+     * that support `output` such as MS SQL Server (MSSQL).
+     *
+     * Also see the {@link output} method.
+     */
+    outputAll(table: OP): OutputInterface<DB, TB, ReturningAllRow<DB, TB, O>, OP>;
+}
+export type OutputPrefix = 'deleted' | 'inserted';
+export type OutputDatabase<DB, TB extends keyof DB, OP extends OutputPrefix = OutputPrefix> = {
+    [K in OP]: DB[TB];
+};
+export type OutputExpression<DB, TB extends keyof DB, OP extends OutputPrefix = OutputPrefix, ODB = OutputDatabase<DB, TB, OP>, OTB extends keyof ODB = keyof ODB> = AnyAliasedColumnWithTable<ODB, OTB> | AnyColumnWithTable<ODB, OTB> | AliasedExpressionOrFactory<ODB, OTB>;
+export type OutputCallback<DB, TB extends keyof DB, OP extends OutputPrefix = OutputPrefix> = (eb: ExpressionBuilder<OutputDatabase<DB, TB, OP>, OP>) => ReadonlyArray<OutputExpression<DB, TB, OP>>;
+export type SelectExpressionFromOutputExpression<OE> = OE extends `${OutputPrefix}.${infer C}` ? C : OE;
+export type SelectExpressionFromOutputCallback<CB> = CB extends (eb: ExpressionBuilder<any, any>) => ReadonlyArray<infer OE> ? SelectExpressionFromOutputExpression<OE> : never;

package/dist/server/node_modules/kysely/dist/cjs/query-builder/output-interface.js

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