arkormx 2.10.2 → 2.11.1

package/dist/{index-ClVzjhGq.d.mts → index-DLNIbeRi.d.cts}

@@ -1,7 +1,7 @@
-import { Collection } from "@h3ravel/collect.js";
 import { Kysely, Transaction } from "kysely";
-import { Command } from "@h3ravel/musket";
 import { PrismaClient } from "@prisma/client";
+import { Collection } from "@h3ravel/collect.js";
+import { Command } from "@h3ravel/musket";
 
 //#region src/types/migrations.d.ts
 type SchemaColumnType = 'id' | 'uuid' | 'enum' | 'string' | 'text' | 'integer' | 'bigInteger' | 'float' | 'decimal' | 'boolean' | 'json' | 'date' | 'dateTime' | 'timestamp';
@@ -33,6 +33,13 @@ interface SchemaColumn {
   precision?: number;
   /** Number of digits to the right of the decimal point for `decimal` columns. */
   scale?: number;
+  /**
+   * SQL expression for a database-computed column (`GENERATED ALWAYS AS (…)`).
+   * The expression must be immutable and reference only the row's own columns.
+   */
+  generatedExpression?: string;
+  /** Whether the generated column is `STORED` (Postgres only supports stored). */
+  generatedStored?: boolean;
   primaryKeyGeneration?: PrimaryKeyGeneration;
 }
 interface SchemaIndex {
@@ -259,6 +266,81 @@ interface DatabaseTableOptions {
   timestampColumns?: TimestampColumnBehavior[];
 }
 //#endregion
+//#region src/types/expression.d.ts
+/**
+ * Serializable expression nodes produced by the expression builder (`col`, `val`,
+ * `raw`, `caseWhen`, `coalesce`, `json`, aggregate helpers, …).
+ *
+ * The query builder stays adapter-agnostic: it stores these nodes on the query
+ * spec and each {@link DatabaseAdapter} compiles (or rejects) them. Every node is
+ * discriminated by its `kind`.
+ */
+type ExpressionBinaryOperator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'like' | 'ilike' | 'not-like' | 'not-ilike' | 'and' | 'or' | '+' | '-' | '*' | '/';
+type ExpressionJsonCast = 'text' | 'number' | 'boolean';
+interface ColumnExpressionNode {
+  kind: 'column';
+  /** Logical model attribute, or a joined `table.column` reference. */
+  name: string;
+}
+interface ValueExpressionNode {
+  kind: 'value';
+  value: DatabaseValue;
+}
+interface RawExpressionNode {
+  kind: 'raw';
+  sql: string;
+  bindings: DatabaseValue[];
+}
+interface JsonExpressionNode {
+  kind: 'json';
+  column: string;
+  /** Path segments below the base column (`metadata->billType` => `['billType']`). */
+  path: string[];
+  /** Optional scalar cast applied to the extracted text value. */
+  cast?: ExpressionJsonCast;
+}
+interface CaseExpressionBranch {
+  when: ExpressionNode;
+  then: ExpressionNode;
+}
+interface CaseExpressionNode {
+  kind: 'case';
+  cases: CaseExpressionBranch[];
+  else?: ExpressionNode;
+}
+interface FunctionExpressionNode {
+  kind: 'function';
+  name: string;
+  args: ExpressionNode[];
+}
+interface BinaryExpressionNode {
+  kind: 'binary';
+  operator: ExpressionBinaryOperator;
+  left: ExpressionNode;
+  right: ExpressionNode;
+}
+interface InExpressionNode {
+  kind: 'in';
+  operand: ExpressionNode;
+  values: ExpressionNode[];
+  not: boolean;
+}
+interface NullCheckExpressionNode {
+  kind: 'null-check';
+  operand: ExpressionNode;
+  not: boolean;
+}
+interface AggregateExpressionNode {
+  kind: 'aggregate';
+  fn: AggregateOperation;
+  /** Argument expression; omitted for `count(*)`. */
+  arg?: ExpressionNode;
+  distinct?: boolean;
+  /** Boolean-valued predicate compiled to `FILTER (WHERE …)` on Postgres. */
+  filter?: ExpressionNode;
+}
+type ExpressionNode = ColumnExpressionNode | ValueExpressionNode | RawExpressionNode | JsonExpressionNode | CaseExpressionNode | FunctionExpressionNode | BinaryExpressionNode | InExpressionNode | NullCheckExpressionNode | AggregateExpressionNode;
+//#endregion
 //#region src/types/factories.d.ts
 type FactoryAttributes = Record<string, unknown>;
 type MaybePromise<T> = T | Promise<T>;
@@ -2324,6 +2406,166 @@ declare class InlineFactory<TModel, TAttributes extends FactoryAttributes> exten
  */
 declare const defineFactory: <TModel, TAttributes extends FactoryAttributes = Partial<ModelAttributes<TModel>>>(model: FactoryModelConstructor<TModel>, definition: FactoryDefinition<TAttributes>) => ModelFactory<TModel, TAttributes>;
 //#endregion
+//#region src/Expression.d.ts
+/**
+ * A composable SQL expression. Instances are immutable — every operator returns a
+ * new expression — and are accepted by `select`, `where`, `groupBy`, `orderBy`,
+ * `having`, and the aggregate helpers. Adapters compile the underlying node tree.
+ */
+declare abstract class Expression {
+  /**
+   * Serializes this expression to an adapter-compilable {@link ExpressionNode}.
+   */
+  abstract toExpressionNode(): ExpressionNode;
+  /**
+   * Type guard for values that came out of the expression builder.
+   */
+  static isExpression(value: unknown): value is Expression;
+  eq(value: unknown): Expression;
+  ne(value: unknown): Expression;
+  gt(value: unknown): Expression;
+  gte(value: unknown): Expression;
+  lt(value: unknown): Expression;
+  lte(value: unknown): Expression;
+  like(value: unknown): Expression;
+  ilike(value: unknown): Expression;
+  notLike(value: unknown): Expression;
+  notIlike(value: unknown): Expression;
+  in(values: readonly unknown[]): Expression;
+  notIn(values: readonly unknown[]): Expression;
+  isNull(): Expression;
+  isNotNull(): Expression;
+  and(other: Expression): Expression;
+  or(other: Expression): Expression;
+  plus(value: unknown): Expression;
+  minus(value: unknown): Expression;
+  times(value: unknown): Expression;
+  dividedBy(value: unknown): Expression;
+}
+/**
+ * Fluent `CASE … WHEN … THEN … ELSE … END` builder. Immutable.
+ */
+declare class CaseExpression extends Expression {
+  private readonly branches;
+  private readonly elseExpr?;
+  constructor(branches: CaseBranch[], elseExpr?: Expression | undefined);
+  when(condition: Expression, result: unknown): CaseExpression;
+  else(result: unknown): CaseExpression;
+  toExpressionNode(): ExpressionNode;
+}
+interface CaseBranch {
+  when: Expression;
+  then: Expression;
+}
+/**
+ * JSON-path value extraction (`metadata ->> 'billType'`), with optional casts.
+ */
+declare class JsonExpression extends Expression {
+  private readonly column;
+  private readonly path;
+  private readonly castTo?;
+  constructor(column: string, path: string[], castTo?: ExpressionJsonCast | undefined);
+  asText(): JsonExpression;
+  asNumber(): JsonExpression;
+  asBoolean(): JsonExpression;
+  toExpressionNode(): ExpressionNode;
+}
+/**
+ * Aggregate expression (`sum`, `count`, `avg`, `min`, `max`) with optional filter.
+ */
+declare class AggregateExpression extends Expression {
+  private readonly fn;
+  private readonly arg?;
+  private readonly options;
+  constructor(fn: AggregateOperation, arg?: Expression | undefined, options?: {
+    distinct?: boolean;
+    filterExpr?: Expression;
+  });
+  /**
+   * Restricts the aggregate to rows matching `predicate` (`FILTER (WHERE …)`).
+   */
+  filter(predicate: Expression): AggregateExpression;
+  distinct(): AggregateExpression;
+  toExpressionNode(): ExpressionNode;
+}
+/**
+ * Rebuilds an {@link Expression} around an already-serialized node.
+ */
+declare const fromExpressionNode: (node: ExpressionNode) => Expression;
+/**
+ * A typed column reference. Supports joined `table.column` syntax.
+ */
+declare const col: (name: string) => Expression;
+/**
+ * A bound literal value (parameterized, never interpolated).
+ */
+declare const val: (value: DatabaseValue) => Expression;
+/**
+ * Raw SQL escape hatch with positional `?` bindings.
+ */
+declare const raw: (sql: string, bindings?: DatabaseValue[]) => Expression;
+/**
+ * Starts a `CASE WHEN condition THEN result` expression.
+ */
+declare const caseWhen: (condition: Expression, result: unknown) => CaseExpression;
+/**
+ * `COALESCE(a, b, …)` — first non-null argument. Bare strings are columns.
+ */
+declare const coalesce: (...args: unknown[]) => Expression;
+/**
+ * An arbitrary SQL function call. Bare-string arguments are treated as columns.
+ */
+declare const fn: (name: string, ...args: unknown[]) => Expression;
+/**
+ * JSON value extraction: `json('metadata', 'billType')` => `metadata ->> 'billType'`.
+ */
+declare const json: (column: string, ...path: Array<string | number>) => JsonExpression;
+/**
+ * `SUM(expr)`; a bare-string argument is treated as a column.
+ */
+declare const sum: (arg: unknown) => AggregateExpression;
+/**
+ * `AVG(expr)`; a bare-string argument is treated as a column.
+ */
+declare const avg: (arg: unknown) => AggregateExpression;
+/**
+ * `MIN(expr)`; a bare-string argument is treated as a column.
+ */
+declare const min: (arg: unknown) => AggregateExpression;
+/**
+ * `MAX(expr)`; a bare-string argument is treated as a column.
+ */
+declare const max: (arg: unknown) => AggregateExpression;
+/**
+ * `COUNT(expr)` — or `COUNT(*)` when called without an argument.
+ */
+declare const count: (arg?: unknown) => AggregateExpression;
+/**
+ * Builds a comparison predicate: `where('createdAt', '>=', boundary)`. Handy as an
+ * inline predicate for `caseWhen`, `having`, and aggregate `.filter(…)`.
+ */
+declare const where: (column: string, operator: QueryScalarComparisonOperator | "like" | "ilike" | "not like" | "not ilike" | "<>" | "==", value: unknown) => Expression;
+/**
+ * The expression-builder namespace passed to `static computed` factories, so a
+ * model can declare a virtual attribute as `category: (e) => e.coalesce(…)`.
+ */
+declare const expressionBuilder: {
+  readonly col: (name: string) => Expression;
+  readonly val: (value: DatabaseValue) => Expression;
+  readonly raw: (sql: string, bindings?: DatabaseValue[]) => Expression;
+  readonly caseWhen: (condition: Expression, result: unknown) => CaseExpression;
+  readonly coalesce: (...args: unknown[]) => Expression;
+  readonly fn: (name: string, ...args: unknown[]) => Expression;
+  readonly json: (column: string, ...path: Array<string | number>) => JsonExpression;
+  readonly sum: (arg: unknown) => AggregateExpression;
+  readonly avg: (arg: unknown) => AggregateExpression;
+  readonly min: (arg: unknown) => AggregateExpression;
+  readonly max: (arg: unknown) => AggregateExpression;
+  readonly count: (arg?: unknown) => AggregateExpression;
+  readonly where: (column: string, operator: QueryScalarComparisonOperator | "like" | "ilike" | "not like" | "not ilike" | "<>" | "==", value: unknown) => Expression;
+};
+type ExpressionBuilder = typeof expressionBuilder;
+//#endregion
 //#region src/Model.d.ts
 /**
  * Base model class that all models should extend.
@@ -2336,6 +2578,7 @@ declare const defineFactory: <TModel, TAttributes extends FactoryAttributes = Pa
 declare abstract class Model<TSchema extends ModelQuerySchemaLike | Record<string, unknown> | string = Record<string, any>, TAttributes extends Record<string, unknown> = ModelAttributesOf<TSchema>> {
   private static readonly lifecycleStates;
   private static readonly castMapCache;
+  private static readonly computedCache;
   private static readonly emittedDeprecationWarnings;
   private static eventsSuppressed;
   protected static factoryClass?: new () => ModelFactory<any, any>;
@@ -2355,6 +2598,18 @@ declare abstract class Model<TSchema extends ModelQuerySchemaLike | Record<strin
   protected static softDeletes: boolean;
   protected static deletedAtColumn: string;
   protected static globalScopes: Record<string, GlobalScope>;
+  /**
+   * Expression-backed virtual attributes. Each factory receives the expression
+   * builder and returns an {@link Expression}; the name may then be used in
+   * `select`, `where`, `groupBy`, `orderBy`, and `having`, and is expanded inline
+   * during query building.
+   *
+   * @example
+   * static computed = {
+   *   category: (e) => e.coalesce(e.col('override.category'), e.val('other')),
+   * }
+   */
+  protected static computed?: Record<string, (builder: ExpressionBuilder) => Expression>;
   protected static eventListeners: Partial<Record<ModelEventName, ModelEventListener<any>[]>>;
   protected static dispatchesEvents: Partial<Record<ModelEventName, ModelEventDispatcher<any> | ModelEventDispatcher<any>[]>>;
   protected casts: CastMap;
@@ -2403,6 +2658,11 @@ declare abstract class Model<TSchema extends ModelQuerySchemaLike | Record<strin
    * instance field) and cached per model class.
    */
   static getCasts(): CastMap;
+  /**
+   * Resolves the model's `static computed` declarations into expression nodes,
+   * cached per class. Returns an empty map when no computed attributes exist.
+   */
+  static getComputed(): Record<string, ExpressionNode>;
   /**
    * Apply built-in persistence casts (currently `json` serialisation) to a raw
    * attribute payload, without re-running arbitrary custom setters. Used by
@@ -3246,6 +3506,49 @@ type ModelLifecycleState = {
 };
 //#endregion
 //#region src/QueryBuilder.d.ts
+/** Object select projection whose values may be expressions, columns, or booleans. */
+type ExpressionSelectMap = Record<string, Expression | boolean | string>;
+/** Callback invoked with each chunk of results; return `false` to stop early. */
+type ChunkCallback<TModel> = (models: ArkormCollection<TModel>, page: number) => unknown | Promise<unknown>;
+/** Callback invoked with each record during `each`/`eachById`; return `false` to stop. */
+type EachCallback<TModel> = (model: TModel, index: number) => unknown | Promise<unknown>;
+/** Map of model attributes selected for an aggregate (`{ amount: true }`). */
+type AggregateColumnMap<TModel> = Partial<Record<keyof ModelAttributes<TModel> & string, true>>;
+/**
+ * Prisma-style grouped-aggregate request: group by `by` columns and compute the
+ * requested `_sum`/`_avg`/`_min`/`_max`/`_count` aggregates per group.
+ */
+interface GroupByAggregateSpec<TModel> {
+  by: Array<keyof ModelAttributes<TModel> & string>;
+  _count?: true | AggregateColumnMap<TModel>;
+  _sum?: AggregateColumnMap<TModel>;
+  _avg?: AggregateColumnMap<TModel>;
+  _min?: AggregateColumnMap<TModel>;
+  _max?: AggregateColumnMap<TModel>;
+}
+type SameTypeAggregate<TModel, TMap> = { [K in keyof TMap]: K extends keyof ModelAttributes<TModel> ? ModelAttributes<TModel>[K] : unknown };
+/** The typed plain row returned for a {@link GroupByAggregateSpec} query. */
+type GroupByAggregateRow<TModel, TSpec extends GroupByAggregateSpec<TModel>> = { [K in TSpec['by'][number]]: K extends keyof ModelAttributes<TModel> ? ModelAttributes<TModel>[K] : unknown } & (TSpec extends {
+  _count: infer C;
+} ? {
+  _count: C extends AggregateColumnMap<TModel> ? { [K in keyof C]: number } : number;
+} : object) & (TSpec extends {
+  _sum: infer S;
+} ? {
+  _sum: { [K in keyof S]: number | null };
+} : object) & (TSpec extends {
+  _avg: infer A;
+} ? {
+  _avg: { [K in keyof A]: number | null };
+} : object) & (TSpec extends {
+  _min: infer M;
+} ? {
+  _min: SameTypeAggregate<TModel, M>;
+} : object) & (TSpec extends {
+  _max: infer M;
+} ? {
+  _max: SameTypeAggregate<TModel, M>;
+} : object);
 /**
  * The QueryBuilder class provides a fluent interface for building and
  * executing database queries.
@@ -3294,6 +3597,7 @@ declare class QueryBuilder<TModel, TDelegate extends ModelQuerySchemaLike = Mode
    */
   where(where: QuerySchemaWhere<TDelegate>): this;
   where(callback: WhereCallback<TModel, TDelegate>): this;
+  where(expression: Expression): this;
   /**
    * Adds an OR where clause to the query. Pass a callback to build a
    * parenthesized group of nested conditions.
@@ -3303,6 +3607,13 @@ declare class QueryBuilder<TModel, TDelegate extends ModelQuerySchemaLike = Mode
    */
   orWhere(where: QuerySchemaWhere<TDelegate>): this;
   orWhere(callback: WhereCallback<TModel, TDelegate>): this;
+  orWhere(expression: Expression): this;
+  /**
+   * Appends a boolean {@link Expression} as a where predicate. When the query is
+   * using the Prisma-like legacy where representation, the expression is merged in
+   * as a structured condition alongside it.
+   */
+  private appendExpressionCondition;
   /**
    * Resolve a callback into a parenthesized group condition and append it.
    */
@@ -3747,6 +4058,17 @@ declare class QueryBuilder<TModel, TDelegate extends ModelQuerySchemaLike = Mode
    * @returns
    */
   orderBy(orderBy: QuerySchemaOrderBy<TDelegate>): this;
+  orderBy(expression: Expression, direction?: 'asc' | 'desc'): this;
+  /**
+   * Appends a raw SQL `order by` fragment (with positional `?` bindings), useful
+   * for ordering by a computed expression the builder does not model directly.
+   *
+   * @param sql
+   * @param bindings
+   * @param direction
+   * @returns
+   */
+  orderByRaw(sql: string, bindings?: DatabaseValue[], direction?: 'asc' | 'desc'): this;
   /**
    * Puts the query results in random order.
    *
@@ -4003,6 +4325,7 @@ declare class QueryBuilder<TModel, TDelegate extends ModelQuerySchemaLike = Mode
    * @returns
    */
   select(select: QuerySchemaSelect<TDelegate>): this;
+  select(select: Record<string, Expression | boolean | string>): this;
   /**
    * Appends columns or expressions to the existing select clause.
    *
@@ -4010,6 +4333,7 @@ declare class QueryBuilder<TModel, TDelegate extends ModelQuerySchemaLike = Mode
    * @returns
    */
   addSelect(select: QuerySchemaSelect<TDelegate>): this;
+  addSelect(select: Record<string, Expression | boolean | string>): this;
   /**
    * Apply or remove DISTINCT from the select query.
    *
@@ -4025,8 +4349,48 @@ declare class QueryBuilder<TModel, TDelegate extends ModelQuerySchemaLike = Mode
    */
   groupBy<TKey extends keyof ModelAttributes<TModel> & string>(columns: TKey[]): this;
   groupBy<TKey extends keyof ModelAttributes<TModel> & string>(...columns: TKey[]): this;
+  groupBy(columns: Array<string | Expression>): this;
+  groupBy(...columns: Array<string | Expression>): this;
+  groupBy<TSpec extends GroupByAggregateSpec<TModel>>(spec: TSpec): Promise<GroupByAggregateRow<TModel, TSpec>[]>;
+  /**
+   * Appends a raw SQL `group by` fragment (with positional `?` bindings), mirroring
+   * `whereRaw`/`havingRaw`. Combines with any columns/expressions already grouped.
+   *
+   * @param sql
+   * @param bindings
+   * @returns
+   */
+  groupByRaw(sql: string, bindings?: DatabaseValue[]): this;
+  /**
+   * Resolves the recorded group-by sources into adapter {@link QueryGroupByItem}s.
+   * A bare string that matches a select-column alias is expanded to that column's
+   * underlying expression (group-by-alias); otherwise it is treated as a column.
+   */
+  private buildGroupByItems;
+  private isGroupByAggregateSpec;
+  /**
+   * Executes the query and returns plain, un-hydrated rows keyed by their select
+   * alias — the natural shape for `select` + `groupBy` aggregate reports. Pass a
+   * row type to describe the projection.
+   *
+   * @returns
+   */
+  getRows<TRow = Record<string, DatabaseValue>>(): Promise<TRow[]>;
+  /**
+   * Runs a Prisma-style grouped aggregate and returns typed rows shaped as
+   * `{ <by columns>, _sum, _avg, _min, _max, _count }`.
+   */
+  private executeGroupByAggregate;
+  private coerceNumeric;
   private appendHavingCondition;
   private buildHavingComparison;
+  /**
+   * Resolves the three `having` call shapes into a condition: `having(column, …)`,
+   * `having(expression)` (a boolean expression predicate), and
+   * `having(expression, operator, value)` (compare an aggregate to a value).
+   */
+  private buildHavingCondition;
+  private compareExpression;
   /**
    * Adds a HAVING clause to filter grouped rows. Accepts either
    * `having(column, value)` (defaulting to equality) or
@@ -4039,6 +4403,8 @@ declare class QueryBuilder<TModel, TDelegate extends ModelQuerySchemaLike = Mode
    */
   having(column: string, value: DatabaseValue): this;
   having(column: string, operator: QueryScalarComparisonOperator, value: DatabaseValue): this;
+  having(expression: Expression): this;
+  having(expression: Expression, operator: QueryScalarComparisonOperator, value: DatabaseValue): this;
   /**
    * Adds an OR HAVING clause to filter grouped rows.
    *
@@ -4049,6 +4415,8 @@ declare class QueryBuilder<TModel, TDelegate extends ModelQuerySchemaLike = Mode
    */
   orHaving(column: string, value: DatabaseValue): this;
   orHaving(column: string, operator: QueryScalarComparisonOperator, value: DatabaseValue): this;
+  orHaving(expression: Expression): this;
+  orHaving(expression: Expression, operator: QueryScalarComparisonOperator, value: DatabaseValue): this;
   /**
    * Adds a raw HAVING clause, useful for filtering on aggregate expressions
    * such as `count(*)`. Combines with previous HAVING clauses using AND.
@@ -4276,6 +4644,88 @@ declare class QueryBuilder<TModel, TDelegate extends ModelQuerySchemaLike = Mode
    * @returns
    */
   get(): Promise<ArkormCollection<TModel>>;
+  /**
+   * Processes the query results in chunks, invoking the callback with each chunk
+   * as a collection. Return `false` from the callback to stop early. Resolves to
+   * `false` when stopped early, otherwise `true`.
+   *
+   * Chunking pages with `offset`/`limit`, so add an `orderBy` for stable results
+   * and prefer {@link chunkById} when modifying the records being iterated.
+   *
+   * @param count     Rows per chunk.
+   * @param callback  Receives each chunk and its 1-based page number.
+   * @returns
+   */
+  chunk(count: number, callback: ChunkCallback<TModel>): Promise<boolean>;
+  /**
+   * Chunks the results by comparing a monotonically increasing key column
+   * (`id > lastId`) rather than by offset — safe when the callback updates the
+   * records being iterated. Return `false` from the callback to stop early.
+   *
+   * @param count     Rows per chunk.
+   * @param callback  Receives each chunk and its 1-based page number.
+   * @param column    The key column to page by (defaults to the primary key).
+   * @param alias     The result attribute holding the key value (defaults to `column`).
+   * @returns
+   */
+  chunkById(count: number, callback: ChunkCallback<TModel>, column?: string, alias?: string): Promise<boolean>;
+  /**
+   * Iterates the query results one record at a time (chunking under the hood).
+   * Return `false` from the callback to stop early.
+   *
+   * @param callback  Receives each record and its 0-based index.
+   * @param count     Rows fetched per chunk (default 1000).
+   * @returns
+   */
+  each(callback: EachCallback<TModel>, count?: number): Promise<boolean>;
+  /**
+   * Like {@link each}, but pages by key column ({@link chunkById}) — safe when the
+   * callback updates the records being iterated.
+   *
+   * @param callback  Receives each record and its 0-based index.
+   * @param count     Rows fetched per chunk (default 1000).
+   * @param column    The key column to page by (defaults to the primary key).
+   * @param alias     The result attribute holding the key value (defaults to `column`).
+   * @returns
+   */
+  eachById(callback: EachCallback<TModel>, count?: number, column?: string, alias?: string): Promise<boolean>;
+  /**
+   * Streams the query results lazily as an async iterator, fetching one chunk at
+   * a time so only a small window is held in memory. Iterate with `for await`.
+   *
+   * ```ts
+   * for await (const user of User.query().orderBy({ id: 'asc' }).lazy()) {
+   *   // …
+   * }
+   * ```
+   *
+   * @param chunkSize  Rows fetched per underlying query (default 1000).
+   * @returns
+   */
+  lazy(chunkSize?: number): AsyncGenerator<TModel>;
+  /**
+   * Streams the results lazily, paging by an ascending key column — safe when the
+   * consumer updates records mid-iteration. Iterate with `for await`.
+   *
+   * @param chunkSize  Rows fetched per underlying query (default 1000).
+   * @param column     The key column to page by (defaults to the primary key).
+   * @param alias      The result attribute holding the key value (defaults to `column`).
+   * @returns
+   */
+  lazyById(chunkSize?: number, column?: string, alias?: string): AsyncGenerator<TModel>;
+  /**
+   * Streams the results lazily, paging by a descending key column. Iterate with
+   * `for await`.
+   *
+   * @param chunkSize  Rows fetched per underlying query (default 1000).
+   * @param column     The key column to page by (defaults to the primary key).
+   * @param alias      The result attribute holding the key value (defaults to `column`).
+   * @returns
+   */
+  lazyByIdDesc(chunkSize?: number, column?: string, alias?: string): AsyncGenerator<TModel>;
+  private lazyByKey;
+  private assertPositiveChunkSize;
+  private readModelAttribute;
   /**
    * Executes the query and returns the first result as a model
    * instance, or null if no results are found.
@@ -4635,6 +5085,17 @@ declare class QueryBuilder<TModel, TDelegate extends ModelQuerySchemaLike = Mode
   private tryBuildFieldCondition;
   private tryBuildQueryCondition;
   private tryBuildSelectSpec;
+  /** Reads and caches the model's resolved `static computed` expression map. */
+  private computedAttributes;
+  /**
+   * Expands references to `static computed` attribute names into their backing
+   * expressions across a select spec's columns, group by, order by, where, and
+   * having clauses. A no-op when the model declares no computed attributes.
+   */
+  private expandComputedAttributes;
+  private expandComputedCondition;
+  /** Converts a where comparison against a computed attribute into an expression. */
+  private computedComparison;
   private tryBuildAggregateSpec;
   private requireAdapter;
   private executeReadRows;
@@ -5084,7 +5545,7 @@ type DatabasePrimitive = string | number | boolean | bigint | Date | null;
 type DatabaseValue = DatabasePrimitive | DatabaseRow | DatabaseValue[];
 type DatabaseRow = Record<string, unknown>;
 type DatabaseRows = DatabaseRow[];
-type AdapterCapability = 'transactions' | 'returning' | 'insertMany' | 'upsert' | 'updateMany' | 'deleteMany' | 'exists' | 'relationLoads' | 'relationAggregates' | 'relationFilters' | 'rawSelect' | 'rawWhere' | 'distinct' | 'groupBy' | 'joins';
+type AdapterCapability = 'transactions' | 'returning' | 'insertMany' | 'upsert' | 'updateMany' | 'deleteMany' | 'exists' | 'relationLoads' | 'relationAggregates' | 'relationFilters' | 'rawSelect' | 'rawWhere' | 'distinct' | 'groupBy' | 'joins' | 'expressions';
 type AdapterCapabilities = Partial<Record<AdapterCapability, boolean>>;
 type QueryLogicalOperator = 'and' | 'or';
 type QueryComparisonOperator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'in' | 'not-in' | 'contains' | 'starts-with' | 'ends-with' | 'is-null' | 'is-not-null';
@@ -5108,11 +5569,30 @@ interface QuerySelectColumn {
   alias?: string;
   raw?: boolean;
   wildcard?: boolean;
+  /** A compiled expression projected in place of a physical column. */
+  expression?: ExpressionNode;
 }
 interface QueryOrderBy {
   column: string;
   direction: SortDirection;
+  /** Orders by a compiled expression instead of a physical column. */
+  expression?: ExpressionNode;
 }
+/**
+ * A `GROUP BY` entry: either a logical column name (string) or a compiled
+ * expression / raw fragment. The query builder resolves select-alias grouping to
+ * the underlying expression before it reaches the adapter.
+ */
+type QueryGroupByItem = string | {
+  alias: string;
+} | {
+  expression: ExpressionNode;
+} | {
+  raw: {
+    sql: string;
+    bindings?: DatabaseValue[];
+  };
+};
 interface QueryComparisonCondition {
   type: 'comparison';
   column: string;
@@ -5179,7 +5659,12 @@ interface RawQuerySpec {
   sql: string;
   bindings?: DatabaseValue[];
 }
-type QueryCondition = QueryComparisonCondition | QueryColumnComparisonCondition | QueryTimeCondition | QueryDayCondition | QueryExistsCondition | QueryFullTextCondition | QueryJsonCondition | QueryGroupCondition | QueryNotCondition | QueryRawCondition;
+/** A boolean-valued expression used directly as a predicate (where / having). */
+interface QueryExpressionCondition {
+  type: 'expression';
+  expression: ExpressionNode;
+}
+type QueryCondition = QueryComparisonCondition | QueryColumnComparisonCondition | QueryTimeCondition | QueryDayCondition | QueryExistsCondition | QueryFullTextCondition | QueryJsonCondition | QueryExpressionCondition | QueryGroupCondition | QueryNotCondition | QueryRawCondition;
 interface AggregateSelection {
   type: AggregateOperation;
   column?: string;
@@ -5258,7 +5743,7 @@ interface SelectSpec<TModel = unknown> {
   target: QueryTarget<TModel>;
   columns?: QuerySelectColumn[];
   distinct?: boolean;
-  groupBy?: string[];
+  groupBy?: QueryGroupByItem[];
   having?: QueryCondition;
   joins?: QueryJoin[];
   where?: QueryCondition;
@@ -5536,6 +6021,22 @@ declare class KyselyDatabaseAdapter implements DatabaseAdapter {
   private buildFullTextCondition;
   private buildJsonAccessor;
   private buildJsonCondition;
+  /**
+   * Compiles a serialized {@link ExpressionNode} into a parameterized SQL fragment.
+   * Shared by expression-backed select columns, `group by`, `order by`, and any
+   * boolean expression used as a `where`/`having` predicate.
+   *
+   * @param target
+   * @param node
+   * @returns
+   */
+  private buildExpression;
+  private buildExpressionColumn;
+  private buildBinaryExpression;
+  private buildAggregateExpression;
+  private buildJsonValueExpression;
+  private buildRawExpressionFragment;
+  private sanitizeFunctionName;
   private buildWhereCondition;
   private buildWhereClause;
   private buildPaginationClause;
@@ -6476,7 +6977,8 @@ declare class MakeSeederCommand extends Command<CliApp> {
 //#region src/cli/commands/MigrateCommand.d.ts
 /**
  * The MigrateCommand class implements the CLI command for applying migration
- * classes to the Prisma schema and running the Prisma workflow.
+ * classes to the database or Prisma schema and running the Prisma workflow when
+ * using the Prisma compatibility driver.
  *
  * @author Legacy (3m1n3nc3)
  * @since 0.1.0
@@ -6488,8 +6990,8 @@ declare class MigrateCommand extends Command<CliApp> {
    * Command handler for the migrate command.
    * This method is responsible for orchestrating the migration
    * process, including loading migration classes, applying them to
-   * the Prisma schema, and running the appropriate Prisma commands
-   * based on the provided options.
+   * the the database or Prisma schema, and running the appropriate Prisma commands
+   * when using the Prisma compatibility driver based on the provided options.
    *
    * @returns
    */
@@ -6666,6 +7168,19 @@ declare class ForeignKeyBuilder {
   as(fieldName: string): this;
 }
 //#endregion
+//#region src/helpers/generated-column.d.ts
+/**
+ * The two ways to declare a generated column's expression: a raw SQL string, or a
+ * factory that builds one with the expression builder.
+ */
+type GeneratedColumnExpression = string | ((builder: ExpressionBuilder) => Expression);
+/**
+ * Resolves a generated-column expression into raw Postgres SQL. Generated columns
+ * cannot carry bind parameters (they must be immutable), so literal values are
+ * inlined and aggregates are rejected.
+ */
+declare const resolveGeneratedExpression: (expression: GeneratedColumnExpression) => string;
+//#endregion
 //#region src/database/TableBuilder.d.ts
 /**
  * The EnumBuilder class provides a fluent interface for configuring enum columns
@@ -6875,6 +7390,28 @@ declare class TableBuilder {
    * @returns         The current TableBuilder instance for chaining.
    */
   dateTime(name: string, options?: Partial<SchemaColumn>): this;
+  /**
+   * Defines a database-computed column (`GENERATED ALWAYS AS (…) STORED`). The
+   * expression may be a raw SQL string or an expression-builder factory, and must
+   * be immutable and reference only the row's own columns. Combine with
+   * {@link index} to index the generated value.
+   *
+   * @example
+   * table.generated('category', "case when metadata->>'kind' = 'a' then 'x' else 'y' end", {
+   *   type: 'text',
+   * })
+   * table.generated('total', (e) => e.col('price').times(e.col('quantity')), { type: 'integer' })
+   *
+   * @param name        The generated column name.
+   * @param expression  The SQL expression string, or a builder factory.
+   * @param options     Column type (default `text`), `stored` flag, and nullability.
+   * @returns
+   */
+  generated(name: string, expression: GeneratedColumnExpression, options?: {
+    type?: SchemaColumnType;
+    stored?: boolean;
+    nullable?: boolean;
+  }): this;
   /**
    * Defines colonns for a polymorphic relationship in the table.
    *
@@ -7906,4 +8443,4 @@ declare class URLDriver {
   url(page: number): string;
 }
 //#endregion
-export { buildRelationLine as $, DelegateForModelSchema as $a, EagerLoadConstraint as $i, RuntimePathMap as $n, RelatedModelFromResult as $o, QueryFullTextCondition as $r, TimestampNames as $s, getPersistedColumnMap as $t, isTransactionCapableClient as A, QuerySchemaUniqueWhere as Aa, UpsertSpec as Ai, ForeignKeyBuilder as An, HasOneRelation as Ao, AdapterModelFieldStructure as Ar, RelationMetadataType as As, createEmptyAppliedMigrationsState as At, applyDropTableOperation as B, TransactionCapableClient as Ba, CastType as Bi, MakeFactoryCommand as Bn, RelationAggregateType as Bo, DatabaseRow as Br, PrismaSchemaSyncOptions as Bs, removeAppliedMigration as Bt, getRuntimeDebugHandler as C, QuerySchemaCreateData as Ca, RelationLoadPlan as Ci, ArkormException as Cn, defineFactory as Co, createPrismaDatabaseAdapter as Cr, ModelMetadata as Cs, supportsDatabaseMigrationExecution as Ct, getUserConfig as D, QuerySchemaRow as Da, SortDirection as Di, SchemaBuilder as Dn, MorphOneRelation as Do, AdapterCapability as Dr, MorphToRelationMetadata as Ds, buildMigrationIdentity as Dt, getRuntimePrismaClient as E, QuerySchemaOrderBy as Ea, SoftDeleteQueryMode as Ei, Migration as En, MorphToManyRelation as Eo, AdapterCapabilities as Er, MorphToManyRelationMetadata as Es, toModelName as Et, PRISMA_ENUM_MEMBER_REGEX as F, RuntimeClientLike as Fa, ArkormDebugEvent as Fi, MigrateFreshCommand as Fn, BelongsToManyRelation as Fo, AggregateOperation as Fr, GeneratedMigrationFile as Fs, isMigrationApplied as Ft, applyOperationsToPrismaSchema as G, QueryBuilder as Ga, DelegateOrderBy as Gi, AttributeOptions as Gn, RelationMetadataProvider as Go, InsertManySpec as Gr, SchemaIndex as Gs, PersistedColumnMappingsState as Gt, applyMigrationRollbackToPrismaSchema as H, TransactionOptions as Ha, DelegateCreateData as Hi, CliApp as Hn, RelationConstraint as Ho, DatabaseValue as Hr, SchemaColumnType as Hs, supportsDatabaseMigrationState as Ht, PRISMA_ENUM_REGEX as I, Serializable as Ia, ArkormDebugHandler as Ii, MigrateCommand as In, Relation as Io, AggregateSelection as Ir, MigrationClass as Is, markMigrationApplied as It, buildIndexLine as J, AttributeQuerySchema as Ja, DelegateSelect as Ji, RegisteredFactory as Jn, RelationTableLookupSpec as Jo, QueryComparisonCondition as Jr, SchemaTableAlterOperation as Js, PersistedTableMetadata as Jt, buildEnumBlock as K, AttributeCreateInput as Ka, DelegateRow as Ki, Arkorm as Kn, RelationResult as Ko, InsertSpec as Kr, SchemaOperation as Ks, PersistedMetadataFeatures as Kt, PRISMA_MODEL_REGEX as L, SimplePaginationMeta as La, CastDefinition as Li, MakeSeederCommand as Ln, RelationTableLoader as Lo, AggregateSpec as Lr, MigrationInstanceLike as Ls, markMigrationRun as Lt, resetArkormRuntimeForTests as M, QuerySchemaUpdateData as Ma, AdapterQueryInspection as Mi, ModelsSyncCommand as Mn, HasManyRelation as Mo, AdapterModelStructure as Mr, AppliedMigrationRun as Ms, findAppliedMigration as Mt, runArkormTransaction as N, QuerySchemaWhere as Na, ArkormBootContext as Ni, MigrationHistoryCommand as Nn, BelongsToRelation as No, AdapterQueryOperation as Nr, AppliedMigrationsState as Ns, getLastMigrationRun as Nt, isDelegateLike as O, QuerySchemaRows as Oa, UpdateManySpec as Oi, EnumBuilder as On, MorphManyRelation as Oo, AdapterDatabaseCreationResult as Or, PivotModelStatic as Os, buildMigrationRunId as Ot, PrimaryKeyGenerationPlanner as P, RawSelectInput as Pa, ArkormConfig as Pi, MigrateRollbackCommand as Pn, SingleResultRelation as Po, AdapterTransactionContext as Pr, GenerateMigrationOptions as Ps, getLatestAppliedMigrations as Pt, buildPrimaryKeyLine as Q, AttributeWhereInput as Qa, DelegateWhere as Qi, RuntimePathKey as Qn, RelatedModelForRelationship as Qo, QueryExistsCondition as Qr, TimestampColumnBehavior as Qs, deletePersistedColumnMappingsState as Qt, applyAlterTableOperation as R, SoftDeleteConfig as Ra, CastHandler as Ri, MakeModelCommand as Rn, RelationAggregateConstraint as Ro, DatabaseAdapter as Rr, PrimaryKeyGeneration as Rs, readAppliedMigrationsState as Rt, getRuntimeClient as S, PrismaTransactionOptions as Sa, RelationFilterSpec as Si, ArkormErrorContext as Sn, ModelFactory as So, createPrismaCompatibilityAdapter as Sr, HasOneThroughRelationMetadata as Ss, supportsDatabaseCreation as St, getRuntimePaginationURLDriverFactory as T, QuerySchemaInclude as Ta, SelectSpec as Ti, MIGRATION_BRAND as Tn, MorphToRelation as To, createKyselyAdapter as Tr, MorphOneRelationMetadata as Ts, toMigrationFileSlug as Tt, applyMigrationToDatabase as U, ModelStatic as Ua, DelegateFindManyArgs as Ui, resolveCast as Un, RelationDefaultResolver as Uo, DeleteManySpec as Ur, SchemaForeignKey as Us, writeAppliedMigrationsState as Ut, applyMigrationRollbackToDatabase as V, TransactionContext as Va, ClientResolver as Vi, InitCommand as Vn, RelationColumnLookupSpec as Vo, DatabaseRows as Vr, SchemaColumn as Vs, resolveMigrationStateFilePath as Vt, applyMigrationToPrismaSchema as W, RelationshipModelStatic as Wa, DelegateInclude as Wi, Attribute as Wn, RelationDefaultValue as Wo, DeleteSpec as Wr, SchemaForeignKeyAction as Ws, writeAppliedMigrationsStateToStore as Wt, buildMigrationSource as X, AttributeSelect as Xa, DelegateUpdateArgs as Xi, RuntimeConstructor as Xn, JoinOn as Xo, QueryCondition as Xr, SchemaTableDropOperation as Xs, applyOperationsToPersistedColumnMappingsState as Xt, buildInverseRelationLine as Y, AttributeSchemaDelegate as Ya, DelegateUniqueWhere as Yi, RegisteredModel as Yn, EagerLoadRelations as Yo, QueryComparisonOperator as Yr, SchemaTableCreateOperation as Ys, PersistedTimestampColumn as Yt, buildModelBlock as Z, AttributeUpdateInput as Za, DelegateUpdateData as Zi, RuntimePathInput as Zn, JoinSource as Zo, QueryDayCondition as Zr, SchemaUniqueConstraint as Zs, createEmptyPersistedColumnMappingsState as Zt, ensureArkormConfigLoading as _, PrismaLikeSortOrder as _a, QuerySelectColumn as _i, QueryExecutionException as _n, QuerySchemaForModel as _o, SeederCallArgument as _r, BelongsToRelationMetadata as _s, resolveMigrationClassName as _t, getRuntimeCompatibilityAdapter as a, PaginationCurrentPageResolver as aa, QueryJoinNestedConstraint as ai, readPersistedColumnMappingsState as an, ModelDeclaredAttributeKey as ao, loadFactoriesFrom as ar, FactoryAttributeResolver as as, deriveRelationFieldName as at, getDefaultStubsPath as b, PrismaTransactionCapableClient as ba, RawQuerySpec as bi, ModelNotFoundException as bn, Model as bo, PrismaDatabaseAdapter as br, HasManyThroughRelationMetadata as bs, runPrismaCommand as bt, PrismaDelegateMap as c, PaginationURLDriver as ca, QueryJoinType as ci, resolveColumnMappingsFilePath as cn, ModelEventHandlerConstructor as co, loadSeedersFrom as cr, FactoryDefinition as cs, findEnumBlock as ct, inferDelegateName as d, PrismaDelegateLike as da, QueryJsonConditionKind as di, validatePersistedMetadataFeaturesForMigrations as dn, ModelLifecycleState as do, registerModels as dr, FactoryRelationshipResolver as ds, formatEnumDefaultValue as dt, EagerLoadMap as ea, TimestampNaming as ec, QueryGroupCondition as ei, getPersistedEnumMap as en, GlobalScope as eo, getRegisteredFactories as er, WhereCallback as es, buildUniqueConstraintLine as et, awaitConfiguredModelsRegistration as f, PrismaFindManyArgsLike as fa, QueryLogicalOperator as fi, writePersistedColumnMappingsState as fn, ModelOrderByInput as fo, registerPaths as fr, FactoryState as fs, formatRelationAction as ft, emitRuntimeDebugEvent as g, PrismaLikeSelect as ga, QueryScalarComparisonOperator as gi, RelationResolutionException as gn, ModelWhereInput as go, Seeder as gr, BelongsToManyRelationMetadata as gs, resolveEnumName as gt, defineConfig as h, PrismaLikeScalarFilter as ha, QueryRawCondition as hi, ScopeNotDefinedException as hn, ModelUpdateData as ho, SEEDER_BRAND as hr, DatabaseTablePersistedMetadataOptions as hs, pad as ht, RuntimeModuleLoader as i, NamingCase as ia, QueryJoinConstraint as ii, getPersistedTimestampColumns as in, ModelCreateData as io, getRegisteredSeeders as ir, ArkormCollection as is, deriveRelationAlias as it, loadArkormConfig as j, QuerySchemaUpdateArgs as ja, AdapterBindableModel as ji, SeedCommand as jn, HasManyThroughRelation as jo, AdapterModelIntrospectionOptions as jr, AppliedMigrationEntry as js, deleteAppliedMigrationsStateFromStore as jt, isQuerySchemaLike as k, QuerySchemaSelect as ka, UpdateSpec as ki, TableBuilder as kn, HasOneThroughRelation as ko, AdapterInspectionRequest as kr, RelationMetadata as ks, computeMigrationChecksum as kt, createPrismaAdapter as l, PaginationURLDriverFactory as la, QueryJoinValueConstraint as li, resolvePersistedMetadataFeatures as ln, ModelEventListener as lo, registerFactories as lr, FactoryDefinitionAttributes as ls, findModelBlock as lt, configureArkormRuntime as m, PrismaLikeOrderBy as ma, QueryOrderBy as mi, UniqueConstraintResolutionException as mn, ModelRelationshipResult as mo, resetRuntimeRegistryForTests as mr, DatabaseTableOptions as ms, getMigrationPlan as mt, PivotModel as n, ModelQuerySchemaLike as na, QueryJoinBoolean as ni, getPersistedPrimaryKeyGeneration as nn, ModelAttributes as no, getRegisteredModels as nr, LengthAwarePaginator as ns, deriveCollectionFieldName as nt, resolveRuntimeCompatibilityQuerySchema as o, PaginationMeta as oa, QueryJoinNullConstraint as oi, rebuildPersistedColumnMappingsState as on, ModelEventDispatcher as oo, loadMigrationsFrom as or, FactoryAttributes as os, deriveSingularFieldName as ot, bindAdapterToModels as p, PrismaLikeInclude as pa, QueryNotCondition as pi, UnsupportedAdapterFeatureException as pn, ModelRelationshipKey as po, registerSeeders as pr, MaybePromise as ps, generateMigrationFile as pt, buildFieldLine as q, AttributeOrderBy as qa, DelegateRows as qi, Arkormx as qn, RelationResultCache as qo, QueryColumnComparisonCondition as qr, SchemaPrimaryKey as qs, PersistedPrimaryKeyGeneration as qt, LoadedRuntimeModule as r, ModelTableCase as ra, QueryJoinColumnConstraint as ri, getPersistedTableMetadata as rn, ModelAttributesOf as ro, getRegisteredPaths as rr, Paginator as rs, deriveInverseRelationAlias as rt, resolveRuntimeCompatibilityQuerySchemaOrThrow as s, PaginationOptions as sa, QueryJoinRawConstraint as si, resetPersistedColumnMappingsCache as sn, ModelEventHandler as so, loadModelsFrom as sr, FactoryCallback as ss, escapeRegex as st, URLDriver as t, GetUserConfig as ta, QueryJoin as ti, getPersistedEnumTsType as tn, ModelAttributeValue as to, getRegisteredMigrations as tr, JoinClause as ts, createMigrationTimestamp as tt, createPrismaDelegateMap as u, PrismaClientLike as ua, QueryJsonCondition as ui, syncPersistedColumnMappingsFromState as un, ModelEventName as uo, registerMigrations as ur, FactoryModelConstructor as us, formatDefaultValue as ut, getActiveTransactionAdapter as v, PrismaLikeWhereInput as va, QueryTarget as vi, QueryExecutionExceptionContext as vn, QuerySchemaForModelInstance as vo, SeederConstructor as vr, ColumnMap as vs, resolvePrismaType as vt, getRuntimePaginationCurrentPageResolver as w, QuerySchemaFindManyArgs as wa, RelationLoadSpec as wi, DB as wn, SetBasedEagerLoader as wo, KyselyDatabaseAdapter as wr, MorphManyRelationMetadata as ws, supportsDatabaseReset as wt, getRuntimeAdapter as x, PrismaTransactionContext as xa, RelationAggregateSpec as xi, MissingDelegateException as xn, InlineFactory as xo, PrismaDelegateNameMapping as xr, HasOneRelationMetadata as xs, stripPrismaSchemaModelsAndEnums as xt, getActiveTransactionClient as y, PrismaTransactionCallback as ya, QueryTimeCondition as yi, QueryConstraintException as yn, RelatedModelClass as yo, SeederInput as yr, HasManyRelationMetadata as ys, runMigrationWithPrisma as yt, applyCreateTableOperation as z, TransactionCallback as za, CastMap as zi, MakeMigrationCommand as zn, RelationAggregateInput as zo, DatabasePrimitive as zr, PrismaMigrationWorkflowOptions as zs, readAppliedMigrationsStateFromStore as zt };
+export { buildRelationLine as $, GroupByAggregateSpec as $a, DelegateUniqueWhere as $i, RuntimePathInput as $n, SetBasedEagerLoader as $o, QueryDayCondition as $r, JsonExpressionNode as $s, getPersistedColumnMap as $t, isTransactionCapableClient as A, QuerySchemaOrderBy as Aa, SchemaColumn as Ac, SoftDeleteQueryMode as Ai, GeneratedColumnExpression as An, AggregateExpression as Ao, AdapterDatabaseCreationResult as Ar, JoinClause as As, createEmptyAppliedMigrationsState as At, applyDropTableOperation as B, Serializable as Ba, SchemaUniqueConstraint as Bc, ArkormDebugHandler as Bi, MakeModelCommand as Bn, expressionBuilder as Bo, DatabaseAdapter as Br, FactoryRelationshipResolver as Bs, removeAppliedMigration as Bt, getRuntimeDebugHandler as C, PrismaTransactionCallback as Ca, GenerateMigrationOptions as Cc, QueryTimeCondition as Ci, ArkormException as Cn, ModelRelationshipResult as Co, PrismaDelegateNameMapping as Cr, RelationTableLookupSpec as Cs, supportsDatabaseMigrationExecution as Ct, getUserConfig as D, QuerySchemaCreateData as Da, PrimaryKeyGeneration as Dc, RelationLoadPlan as Di, SchemaBuilder as Dn, QuerySchemaForModelInstance as Do, createKyselyAdapter as Dr, RelatedModelForRelationship as Ds, buildMigrationIdentity as Dt, getRuntimePrismaClient as E, PrismaTransactionOptions as Ea, MigrationInstanceLike as Ec, RelationFilterSpec as Ei, Migration as En, QuerySchemaForModel as Eo, KyselyDatabaseAdapter as Er, JoinSource as Es, toModelName as Et, PRISMA_ENUM_MEMBER_REGEX as F, QuerySchemaUpdateArgs as Fa, SchemaOperation as Fc, AdapterBindableModel as Fi, MigrationHistoryCommand as Fn, avg as Fo, AdapterQueryOperation as Fr, FactoryAttributes as Fs, isMigrationApplied as Ft, applyOperationsToPrismaSchema as G, TransactionContext as Ga, ClientResolver as Gi, resolveCast as Gn, min as Go, DeleteManySpec as Gr, CaseExpressionBranch as Gs, PersistedColumnMappingsState as Gt, applyMigrationRollbackToPrismaSchema as H, SoftDeleteConfig as Ha, TimestampNames as Hc, CastHandler as Hi, MakeFactoryCommand as Hn, fromExpressionNode as Ho, DatabaseRow as Hr, MaybePromise as Hs, supportsDatabaseMigrationState as Ht, PRISMA_ENUM_REGEX as I, QuerySchemaUpdateData as Ia, SchemaPrimaryKey as Ic, AdapterQueryInspection as Ii, MigrateRollbackCommand as In, caseWhen as Io, AdapterTransactionContext as Ir, FactoryCallback as Is, markMigrationApplied as It, buildIndexLine as J, RelationshipModelStatic as Ja, DelegateInclude as Ji, Arkorm as Jn, val as Jo, InsertSpec as Jr, ExpressionBinaryOperator as Js, PersistedTableMetadata as Jt, buildEnumBlock as K, TransactionOptions as Ka, DelegateCreateData as Ki, Attribute as Kn, raw as Ko, DeleteSpec as Kr, CaseExpressionNode as Ks, PersistedMetadataFeatures as Kt, PRISMA_MODEL_REGEX as L, QuerySchemaWhere as La, SchemaTableAlterOperation as Lc, ArkormBootContext as Li, MigrateFreshCommand as Ln, coalesce as Lo, AggregateOperation as Lr, FactoryDefinition as Ls, markMigrationRun as Lt, resetArkormRuntimeForTests as M, QuerySchemaRows as Ma, SchemaForeignKey as Mc, UpdateManySpec as Mi, ForeignKeyBuilder as Mn, Expression as Mo, AdapterModelFieldStructure as Mr, Paginator as Ms, findAppliedMigration as Mt, runArkormTransaction as N, QuerySchemaSelect as Na, SchemaForeignKeyAction as Nc, UpdateSpec as Ni, SeedCommand as Nn, ExpressionBuilder as No, AdapterModelIntrospectionOptions as Nr, ArkormCollection as Ns, getLastMigrationRun as Nt, isDelegateLike as O, QuerySchemaFindManyArgs as Oa, PrismaMigrationWorkflowOptions as Oc, RelationLoadSpec as Oi, EnumBuilder as On, RelatedModelClass as Oo, AdapterCapabilities as Or, RelatedModelFromResult as Os, buildMigrationRunId as Ot, PrimaryKeyGenerationPlanner as P, QuerySchemaUniqueWhere as Pa, SchemaIndex as Pc, UpsertSpec as Pi, ModelsSyncCommand as Pn, JsonExpression as Po, AdapterModelStructure as Pr, FactoryAttributeResolver as Ps, getLatestAppliedMigrations as Pt, buildPrimaryKeyLine as Q, GroupByAggregateRow as Qa, DelegateSelect as Qi, RuntimeConstructor as Qn, defineFactory as Qo, QueryCondition as Qr, InExpressionNode as Qs, deletePersistedColumnMappingsState as Qt, applyAlterTableOperation as R, RawSelectInput as Ra, SchemaTableCreateOperation as Rc, ArkormConfig as Ri, MigrateCommand as Rn, col as Ro, AggregateSelection as Rr, FactoryDefinitionAttributes as Rs, readAppliedMigrationsState as Rt, getRuntimeClient as S, PrismaLikeWhereInput as Sa, AppliedMigrationsState as Sc, QueryTarget as Si, ArkormErrorContext as Sn, ModelRelationshipKey as So, PrismaDatabaseAdapter as Sr, RelationResultCache as Ss, supportsDatabaseCreation as St, getRuntimePaginationURLDriverFactory as T, PrismaTransactionContext as Ta, MigrationClass as Tc, RelationAggregateSpec as Ti, MIGRATION_BRAND as Tn, ModelWhereInput as To, createPrismaDatabaseAdapter as Tr, JoinOn as Ts, toMigrationFileSlug as Tt, applyMigrationToDatabase as U, TransactionCallback as Ua, TimestampNaming as Uc, CastMap as Ui, InitCommand as Un, json as Uo, DatabaseRows as Ur, AggregateExpressionNode as Us, writeAppliedMigrationsState as Ut, applyMigrationRollbackToDatabase as V, SimplePaginationMeta as Va, TimestampColumnBehavior as Vc, CastDefinition as Vi, MakeMigrationCommand as Vn, fn as Vo, DatabasePrimitive as Vr, FactoryState as Vs, resolveMigrationStateFilePath as Vt, applyMigrationToPrismaSchema as W, TransactionCapableClient as Wa, CastType as Wi, CliApp as Wn, max as Wo, DatabaseValue as Wr, BinaryExpressionNode as Ws, writeAppliedMigrationsStateToStore as Wt, buildMigrationSource as X, EachCallback as Xa, DelegateRow as Xi, RegisteredFactory as Xn, InlineFactory as Xo, QueryComparisonCondition as Xr, ExpressionNode as Xs, applyOperationsToPersistedColumnMappingsState as Xt, buildInverseRelationLine as Y, ChunkCallback as Ya, DelegateOrderBy as Yi, Arkormx as Yn, where as Yo, QueryColumnComparisonCondition as Yr, ExpressionJsonCast as Ys, PersistedTimestampColumn as Yt, buildModelBlock as Z, ExpressionSelectMap as Za, DelegateRows as Zi, RegisteredModel as Zn, ModelFactory as Zo, QueryComparisonOperator as Zr, FunctionExpressionNode as Zs, createEmptyPersistedColumnMappingsState as Zt, ensureArkormConfigLoading as _, PrismaLikeInclude as _a, PivotModelStatic as _c, QueryNotCondition as _i, QueryExecutionException as _n, ModelEventHandlerConstructor as _o, SEEDER_BRAND as _r, RelationConstraint as _s, resolveMigrationClassName as _t, getRuntimeCompatibilityAdapter as a, GetUserConfig as aa, BelongsToManyRelationMetadata as ac, QueryJoin as ai, readPersistedColumnMappingsState as an, AttributeSelect as ao, getRegisteredPaths as ar, HasOneRelation as as, deriveRelationFieldName as at, getDefaultStubsPath as b, PrismaLikeSelect as ba, AppliedMigrationEntry as bc, QueryScalarComparisonOperator as bi, ModelNotFoundException as bn, ModelLifecycleState as bo, SeederConstructor as br, RelationMetadataProvider as bs, runPrismaCommand as bt, PrismaDelegateMap as c, NamingCase as ca, HasManyRelationMetadata as cc, QueryJoinConstraint as ci, resolveColumnMappingsFilePath as cn, DelegateForModelSchema as co, loadMigrationsFrom as cr, BelongsToRelation as cs, findEnumBlock as ct, inferDelegateName as d, PaginationOptions as da, HasOneThroughRelationMetadata as dc, QueryJoinRawConstraint as di, validatePersistedMetadataFeaturesForMigrations as dn, ModelAttributes as do, registerFactories as dr, Relation as ds, formatEnumDefaultValue as dt, DelegateUpdateArgs as ea, NullCheckExpressionNode as ec, QueryExistsCondition as ei, getPersistedEnumMap as en, QueryBuilder as eo, RuntimePathKey as er, MorphToRelation as es, buildUniqueConstraintLine as et, awaitConfiguredModelsRegistration as f, PaginationURLDriver as fa, ModelMetadata as fc, QueryJoinType as fi, writePersistedColumnMappingsState as fn, ModelAttributesOf as fo, registerMigrations as fr, RelationTableLoader as fs, formatRelationAction as ft, emitRuntimeDebugEvent as g, PrismaFindManyArgsLike as ga, MorphToRelationMetadata as gc, QueryLogicalOperator as gi, RelationResolutionException as gn, ModelEventHandler as go, resetRuntimeRegistryForTests as gr, RelationColumnLookupSpec as gs, resolveEnumName as gt, defineConfig as h, PrismaDelegateLike as ha, MorphToManyRelationMetadata as hc, QueryJsonConditionKind as hi, ScopeNotDefinedException as hn, ModelEventDispatcher as ho, registerSeeders as hr, RelationAggregateType as hs, pad as ht, RuntimeModuleLoader as i, EagerLoadMap as ia, DatabaseTablePersistedMetadataOptions as ic, QueryGroupCondition as ii, getPersistedTimestampColumns as in, AttributeSchemaDelegate as io, getRegisteredModels as ir, HasOneThroughRelation as is, deriveRelationAlias as it, loadArkormConfig as j, QuerySchemaRow as ja, SchemaColumnType as jc, SortDirection as ji, resolveGeneratedExpression as jn, CaseExpression as jo, AdapterInspectionRequest as jr, LengthAwarePaginator as js, deleteAppliedMigrationsStateFromStore as jt, isQuerySchemaLike as k, QuerySchemaInclude as ka, PrismaSchemaSyncOptions as kc, SelectSpec as ki, TableBuilder as kn, Model as ko, AdapterCapability as kr, WhereCallback as ks, computeMigrationChecksum as kt, createPrismaAdapter as l, PaginationCurrentPageResolver as la, HasManyThroughRelationMetadata as lc, QueryJoinNestedConstraint as li, resolvePersistedMetadataFeatures as ln, GlobalScope as lo, loadModelsFrom as lr, SingleResultRelation as ls, findModelBlock as lt, configureArkormRuntime as m, PrismaClientLike as ma, MorphOneRelationMetadata as mc, QueryJsonCondition as mi, UniqueConstraintResolutionException as mn, ModelDeclaredAttributeKey as mo, registerPaths as mr, RelationAggregateInput as ms, getMigrationPlan as mt, PivotModel as n, DelegateWhere as na, ValueExpressionNode as nc, QueryFullTextCondition as ni, getPersistedPrimaryKeyGeneration as nn, AttributeOrderBy as no, getRegisteredFactories as nr, MorphOneRelation as ns, deriveCollectionFieldName as nt, resolveRuntimeCompatibilityQuerySchema as o, ModelQuerySchemaLike as oa, BelongsToRelationMetadata as oc, QueryJoinBoolean as oi, rebuildPersistedColumnMappingsState as on, AttributeUpdateInput as oo, getRegisteredSeeders as or, HasManyThroughRelation as os, deriveSingularFieldName as ot, bindAdapterToModels as p, PaginationURLDriverFactory as pa, MorphManyRelationMetadata as pc, QueryJoinValueConstraint as pi, UnsupportedAdapterFeatureException as pn, ModelCreateData as po, registerModels as pr, RelationAggregateConstraint as ps, generateMigrationFile as pt, buildFieldLine as q, ModelStatic as qa, DelegateFindManyArgs as qi, AttributeOptions as qn, sum as qo, InsertManySpec as qr, ColumnExpressionNode as qs, PersistedPrimaryKeyGeneration as qt, LoadedRuntimeModule as r, EagerLoadConstraint as ra, DatabaseTableOptions as rc, QueryGroupByItem as ri, getPersistedTableMetadata as rn, AttributeQuerySchema as ro, getRegisteredMigrations as rr, MorphManyRelation as rs, deriveInverseRelationAlias as rt, resolveRuntimeCompatibilityQuerySchemaOrThrow as s, ModelTableCase as sa, ColumnMap as sc, QueryJoinColumnConstraint as si, resetPersistedColumnMappingsCache as sn, AttributeWhereInput as so, loadFactoriesFrom as sr, HasManyRelation as ss, escapeRegex as st, URLDriver as t, DelegateUpdateData as ta, RawExpressionNode as tc, QueryExpressionCondition as ti, getPersistedEnumTsType as tn, AttributeCreateInput as to, RuntimePathMap as tr, MorphToManyRelation as ts, createMigrationTimestamp as tt, createPrismaDelegateMap as u, PaginationMeta as ua, HasOneRelationMetadata as uc, QueryJoinNullConstraint as ui, syncPersistedColumnMappingsFromState as un, ModelAttributeValue as uo, loadSeedersFrom as ur, BelongsToManyRelation as us, formatDefaultValue as ut, getActiveTransactionAdapter as v, PrismaLikeOrderBy as va, RelationMetadata as vc, QueryOrderBy as vi, QueryExecutionExceptionContext as vn, ModelEventListener as vo, Seeder as vr, RelationDefaultResolver as vs, resolvePrismaType as vt, getRuntimePaginationCurrentPageResolver as w, PrismaTransactionCapableClient as wa, GeneratedMigrationFile as wc, RawQuerySpec as wi, DB as wn, ModelUpdateData as wo, createPrismaCompatibilityAdapter as wr, EagerLoadRelations as ws, supportsDatabaseReset as wt, getRuntimeAdapter as x, PrismaLikeSortOrder as xa, AppliedMigrationRun as xc, QuerySelectColumn as xi, MissingDelegateException as xn, ModelOrderByInput as xo, SeederInput as xr, RelationResult as xs, stripPrismaSchemaModelsAndEnums as xt, getActiveTransactionClient as y, PrismaLikeScalarFilter as ya, RelationMetadataType as yc, QueryRawCondition as yi, QueryConstraintException as yn, ModelEventName as yo, SeederCallArgument as yr, RelationDefaultValue as ys, runMigrationWithPrisma as yt, applyCreateTableOperation as z, RuntimeClientLike as za, SchemaTableDropOperation as zc, ArkormDebugEvent as zi, MakeSeederCommand as zn, count as zo, AggregateSpec as zr, FactoryModelConstructor as zs, readAppliedMigrationsStateFromStore as zt };