arkormx 2.10.1 → 2.11.0

package/dist/{index-GhBV8Kyw.d.cts → index-DggXDBiD.d.cts}

@@ -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 {
@@ -70,6 +77,8 @@ interface SchemaTableAlterOperation {
   type: 'alterTable';
   table: string;
   addColumns: SchemaColumn[];
+  /** Columns whose definition (type, nullability, default, enum values) is being redefined in place. */
+  changeColumns?: SchemaColumn[];
   dropColumns: string[];
   addIndexes: SchemaIndex[];
   addForeignKeys: SchemaForeignKey[];
@@ -106,6 +115,7 @@ interface PrismaMigrationWorkflowOptions extends PrismaSchemaSyncOptions {
 type MigrationInstanceLike = {
   up: (...args: any[]) => Promise<void> | void;
   down: (...args: any[]) => Promise<void> | void;
+  done?: (direction: 'up' | 'down') => Promise<void> | void;
 };
 interface AppliedMigrationEntry {
   id: string;
@@ -256,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>;
@@ -2321,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.
@@ -2333,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>;
@@ -2352,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;
@@ -2400,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
@@ -2632,6 +2895,17 @@ declare abstract class Model<TSchema extends ModelQuerySchemaLike | Record<strin
    */
   fill(attributes: Partial<TAttributes>): this;
   fill(attributes: Record<string, unknown>): this;
+  /**
+   * Merge already-stored (database representation) attribute values into the
+   * model without running set mutators or casts. Used to refresh the instance
+   * from a row returned by a write, where the values are already in storage
+   * form and must not be re-cast (re-applying a non-idempotent set-cast such as
+   * a money or array cast would corrupt the value).
+   *
+   * @param attributes
+   * @returns
+   */
+  protected fillRawAttributes(attributes: Record<string, unknown>): this;
   /**
    * Update the model's state in the database using data from a plain object.
    * If the model has no identifier (id), the process will be skipped and the
@@ -3232,6 +3506,45 @@ 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>;
+/** 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.
@@ -3280,6 +3593,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.
@@ -3289,6 +3603,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.
    */
@@ -3733,6 +4054,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.
    *
@@ -3989,6 +4321,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.
    *
@@ -3996,6 +4329,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.
    *
@@ -4011,8 +4345,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
@@ -4025,6 +4399,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.
    *
@@ -4035,6 +4411,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.
@@ -4621,6 +4999,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;
@@ -5070,7 +5459,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';
@@ -5094,11 +5483,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;
@@ -5165,7 +5573,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;
@@ -5244,7 +5657,7 @@ interface SelectSpec<TModel = unknown> {
   target: QueryTarget<TModel>;
   columns?: QuerySelectColumn[];
   distinct?: boolean;
-  groupBy?: string[];
+  groupBy?: QueryGroupByItem[];
   having?: QueryCondition;
   joins?: QueryJoin[];
   where?: QueryCondition;
@@ -5478,6 +5891,17 @@ declare class KyselyDatabaseAdapter implements DatabaseAdapter {
   private ensureEnumTypes;
   private executeCreateTableOperation;
   private executeAlterTableOperation;
+  private enumTypeExists;
+  /**
+   * Redefine an existing column in place using ALTER COLUMN statements: the
+   * column type (recreating the enum type when enum values change), nullability,
+   * default, and a conventionally-named unique constraint.
+   *
+   * @param table
+   * @param column
+   * @param executor
+   */
+  private executeChangeColumn;
   private executeDropTableOperation;
   private ensureMigrationStateTables;
   private writeAppliedMigrationsStateInternal;
@@ -5511,6 +5935,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;
@@ -6451,7 +6891,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
@@ -6463,8 +6904,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
    */
@@ -6641,6 +7082,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
@@ -6693,6 +7147,12 @@ declare class EnumBuilder {
    * @returns
    */
   map(name: string): this;
+  /**
+   * Marks the enum column as an in-place change to an existing column.
+   *
+   * @returns
+   */
+  change(): this;
 }
 /**
  * The TableBuilder class provides a fluent interface for defining
@@ -6704,6 +7164,7 @@ declare class EnumBuilder {
 declare class TableBuilder {
   private readonly columns;
   private readonly dropColumnNames;
+  private readonly changeColumnNames;
   private readonly indexes;
   private readonly foreignKeys;
   private readonly compositeUniqueConstraints;
@@ -6843,6 +7304,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.
    *
@@ -6920,6 +7403,20 @@ declare class TableBuilder {
    * @returns
    */
   dropColumn(name: string): this;
+  /**
+   * Marks a (re)defined column as a change to an existing column rather than an
+   * addition. Use it at the end of a normal column chain inside `alterTable` to
+   * redefine the column's type, nullability, default, or enum values in place:
+   *
+   * ```ts
+   * table.string('status').default('active').change()
+   * table.enum('role', ['admin', 'user', 'guest']).change()
+   * ```
+   *
+   * @param columnName Optional explicit column name. When omitted, applies to the latest defined column.
+   * @returns          The current TableBuilder instance for chaining.
+   */
+  change(columnName?: string): this;
   /**
    * Marks a column as nullable.
    *
@@ -6988,6 +7485,12 @@ declare class TableBuilder {
    * @returns
    */
   getColumns(): SchemaColumn[];
+  /**
+   * Returns a deep copy of the columns flagged for in-place change via `change()`.
+   *
+   * @returns
+   */
+  getChangeColumns(): SchemaColumn[];
   /**
    * Returns a copy of the defined column names to be dropped from the table.
    *
@@ -7141,6 +7644,14 @@ declare abstract class Migration {
    * @param schema A SchemaBuilder instance.
    */
   abstract down(schema: SchemaBuilder): Promise<void> | void;
+  /**
+   * Optional lifecycle hook invoked after the migration's schema operations
+   * have been applied to the database, for either direction. Override it to run
+   * extra logic such as seeding or data backfills once the schema is in place.
+   *
+   * @param direction The direction that just ran (`'up'` or `'down'`).
+   */
+  done(_direction: 'up' | 'down'): Promise<void> | void;
 }
 //#endregion
 //#region src/DB.d.ts
@@ -7590,15 +8101,15 @@ declare const generateMigrationFile: (name: string, options?: GenerateMigrationO
  * @param direction The direction of the migration to plan for ('up' or 'down').
  * @returns         A promise that resolves to an array of schema operations that would be performed.
  */
-declare const getMigrationPlan: (migration: Migration | (new () => Migration), direction?: "up" | "down") => Promise<SchemaOperation[]>;
+declare const getMigrationPlan: (migration: MigrationInstanceLike | (new () => MigrationInstanceLike), direction?: "up" | "down") => Promise<SchemaOperation[]>;
 declare const supportsDatabaseMigrationExecution: (adapter?: DatabaseAdapter) => adapter is DatabaseAdapter & Required<Pick<DatabaseAdapter, "executeSchemaOperations">>;
 declare const supportsDatabaseCreation: (adapter?: DatabaseAdapter) => adapter is DatabaseAdapter & Required<Pick<DatabaseAdapter, "createDatabaseFromError">>;
 declare const supportsDatabaseReset: (adapter?: DatabaseAdapter) => adapter is DatabaseAdapter & Required<Pick<DatabaseAdapter, "resetDatabase">>;
 declare const stripPrismaSchemaModelsAndEnums: (schema: string) => string;
-declare const applyMigrationToDatabase: (adapter: DatabaseAdapter, migration: Migration | (new () => Migration)) => Promise<{
+declare const applyMigrationToDatabase: (adapter: DatabaseAdapter, migration: MigrationInstanceLike | (new () => MigrationInstanceLike)) => Promise<{
   operations: SchemaOperation[];
 }>;
-declare const applyMigrationRollbackToDatabase: (adapter: DatabaseAdapter, migration: Migration | (new () => Migration)) => Promise<{
+declare const applyMigrationRollbackToDatabase: (adapter: DatabaseAdapter, migration: MigrationInstanceLike | (new () => MigrationInstanceLike)) => Promise<{
   operations: SchemaOperation[];
 }>;
 /**
@@ -7610,7 +8121,7 @@ declare const applyMigrationRollbackToDatabase: (adapter: DatabaseAdapter, migra
  * @param options   Options for applying the migration, including schema path and write flag.
  * @returns         A promise that resolves to an object containing the updated schema, schema path, and list of operations applied.
  */
-declare const applyMigrationToPrismaSchema: (migration: Migration | (new () => Migration), options?: PrismaSchemaSyncOptions) => Promise<{
+declare const applyMigrationToPrismaSchema: (migration: MigrationInstanceLike | (new () => MigrationInstanceLike), options?: PrismaSchemaSyncOptions) => Promise<{
   schema: string;
   schemaPath: string;
   operations: SchemaOperation[];
@@ -7622,7 +8133,7 @@ declare const applyMigrationToPrismaSchema: (migration: Migration | (new () => M
  * @param options   Options for applying the rollback, including schema path and write flag.
  * @returns         A promise that resolves to an object containing the updated schema, schema path, and rollback operations applied.
  */
-declare const applyMigrationRollbackToPrismaSchema: (migration: Migration | (new () => Migration), options?: PrismaSchemaSyncOptions) => Promise<{
+declare const applyMigrationRollbackToPrismaSchema: (migration: MigrationInstanceLike | (new () => MigrationInstanceLike), options?: PrismaSchemaSyncOptions) => Promise<{
   schema: string;
   schemaPath: string;
   operations: SchemaOperation[];
@@ -7636,7 +8147,7 @@ declare const applyMigrationRollbackToPrismaSchema: (migration: Migration | (new
  * @param options   Options for running the migration, including schema path, write flag, and Prisma commands.
  * @returns         A promise that resolves to an object containing the schema path and list of operations applied.
  */
-declare const runMigrationWithPrisma: (migration: Migration | (new () => Migration), options?: PrismaMigrationWorkflowOptions) => Promise<{
+declare const runMigrationWithPrisma: (migration: MigrationInstanceLike | (new () => MigrationInstanceLike), options?: PrismaMigrationWorkflowOptions) => Promise<{
   schemaPath: string;
   operations: SchemaOperation[];
 }>;
@@ -7846,4 +8357,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 $, AttributeCreateInput as $a, DelegateUniqueWhere as $i, RuntimePathInput as $n, MorphToManyRelation as $o, QueryDayCondition as $r, RawExpressionNode as $s, getPersistedColumnMap as $t, isTransactionCapableClient as A, QuerySchemaOrderBy as Aa, SchemaForeignKey as Ac, SoftDeleteQueryMode as Ai, GeneratedColumnExpression as An, Expression as Ao, AdapterDatabaseCreationResult as Ar, Paginator as As, createEmptyAppliedMigrationsState as At, applyDropTableOperation as B, Serializable as Ba, TimestampNames as Bc, ArkormDebugHandler as Bi, MakeModelCommand as Bn, fromExpressionNode as Bo, DatabaseAdapter as Br, MaybePromise as Bs, removeAppliedMigration as Bt, getRuntimeDebugHandler as C, PrismaTransactionCallback as Ca, MigrationClass as Cc, QueryTimeCondition as Ci, ArkormException as Cn, ModelWhereInput as Co, PrismaDelegateNameMapping as Cr, JoinOn as Cs, supportsDatabaseMigrationExecution as Ct, getUserConfig as D, QuerySchemaCreateData as Da, PrismaSchemaSyncOptions as Dc, RelationLoadPlan as Di, SchemaBuilder as Dn, Model as Do, createKyselyAdapter as Dr, WhereCallback as Ds, buildMigrationIdentity as Dt, getRuntimePrismaClient as E, PrismaTransactionOptions as Ea, PrismaMigrationWorkflowOptions as Ec, RelationFilterSpec as Ei, Migration as En, RelatedModelClass as Eo, KyselyDatabaseAdapter as Er, RelatedModelFromResult as Es, toModelName as Et, PRISMA_ENUM_MEMBER_REGEX as F, QuerySchemaUpdateArgs as Fa, SchemaTableAlterOperation as Fc, AdapterBindableModel as Fi, MigrationHistoryCommand as Fn, coalesce as Fo, AdapterQueryOperation as Fr, FactoryDefinition as Fs, isMigrationApplied as Ft, applyOperationsToPrismaSchema as G, TransactionContext as Ga, ClientResolver as Gi, resolveCast as Gn, sum as Go, DeleteManySpec as Gr, ColumnExpressionNode as Gs, PersistedColumnMappingsState as Gt, applyMigrationRollbackToPrismaSchema as H, SoftDeleteConfig as Ha, CastHandler as Hi, MakeFactoryCommand as Hn, max as Ho, DatabaseRow as Hr, BinaryExpressionNode as Hs, supportsDatabaseMigrationState as Ht, PRISMA_ENUM_REGEX as I, QuerySchemaUpdateData as Ia, SchemaTableCreateOperation as Ic, AdapterQueryInspection as Ii, MigrateRollbackCommand as In, col as Io, AdapterTransactionContext as Ir, FactoryDefinitionAttributes as Is, markMigrationApplied as It, buildIndexLine as J, RelationshipModelStatic as Ja, DelegateInclude as Ji, Arkorm as Jn, InlineFactory as Jo, InsertSpec as Jr, ExpressionNode as Js, PersistedTableMetadata as Jt, buildEnumBlock as K, TransactionOptions as Ka, DelegateCreateData as Ki, Attribute as Kn, val as Ko, DeleteSpec as Kr, ExpressionBinaryOperator as Ks, PersistedMetadataFeatures as Kt, PRISMA_MODEL_REGEX as L, QuerySchemaWhere as La, SchemaTableDropOperation as Lc, ArkormBootContext as Li, MigrateFreshCommand as Ln, count as Lo, AggregateOperation as Lr, FactoryModelConstructor as Ls, markMigrationRun as Lt, resetArkormRuntimeForTests as M, QuerySchemaRows as Ma, SchemaIndex as Mc, UpdateManySpec as Mi, ForeignKeyBuilder as Mn, JsonExpression as Mo, AdapterModelFieldStructure as Mr, FactoryAttributeResolver as Ms, findAppliedMigration as Mt, runArkormTransaction as N, QuerySchemaSelect as Na, SchemaOperation as Nc, UpdateSpec as Ni, SeedCommand as Nn, avg as No, AdapterModelIntrospectionOptions as Nr, FactoryAttributes as Ns, getLastMigrationRun as Nt, isDelegateLike as O, QuerySchemaFindManyArgs as Oa, SchemaColumn as Oc, RelationLoadSpec as Oi, EnumBuilder as On, AggregateExpression as Oo, AdapterCapabilities as Or, JoinClause as Os, buildMigrationRunId as Ot, PrimaryKeyGenerationPlanner as P, QuerySchemaUniqueWhere as Pa, SchemaPrimaryKey as Pc, UpsertSpec as Pi, ModelsSyncCommand as Pn, caseWhen as Po, AdapterModelStructure as Pr, FactoryCallback as Ps, getLatestAppliedMigrations as Pt, buildPrimaryKeyLine as Q, QueryBuilder as Qa, DelegateSelect as Qi, RuntimeConstructor as Qn, MorphToRelation as Qo, QueryCondition as Qr, NullCheckExpressionNode as Qs, deletePersistedColumnMappingsState as Qt, applyAlterTableOperation as R, RawSelectInput as Ra, SchemaUniqueConstraint as Rc, ArkormConfig as Ri, MigrateCommand as Rn, expressionBuilder as Ro, AggregateSelection as Rr, FactoryRelationshipResolver as Rs, readAppliedMigrationsState as Rt, getRuntimeClient as S, PrismaLikeWhereInput as Sa, GeneratedMigrationFile as Sc, QueryTarget as Si, ArkormErrorContext as Sn, ModelUpdateData as So, PrismaDatabaseAdapter as Sr, EagerLoadRelations as Ss, supportsDatabaseCreation as St, getRuntimePaginationURLDriverFactory as T, PrismaTransactionContext as Ta, PrimaryKeyGeneration as Tc, RelationAggregateSpec as Ti, MIGRATION_BRAND as Tn, QuerySchemaForModelInstance as To, createPrismaDatabaseAdapter as Tr, RelatedModelForRelationship as Ts, toMigrationFileSlug as Tt, applyMigrationToDatabase as U, TransactionCallback as Ua, CastMap as Ui, InitCommand as Un, min as Uo, DatabaseRows as Ur, CaseExpressionBranch as Us, writeAppliedMigrationsState as Ut, applyMigrationRollbackToDatabase as V, SimplePaginationMeta as Va, TimestampNaming as Vc, CastDefinition as Vi, MakeMigrationCommand as Vn, json as Vo, DatabasePrimitive as Vr, AggregateExpressionNode as Vs, resolveMigrationStateFilePath as Vt, applyMigrationToPrismaSchema as W, TransactionCapableClient as Wa, CastType as Wi, CliApp as Wn, raw as Wo, DatabaseValue as Wr, CaseExpressionNode as Ws, writeAppliedMigrationsStateToStore as Wt, buildMigrationSource as X, GroupByAggregateRow as Xa, DelegateRow as Xi, RegisteredFactory as Xn, defineFactory as Xo, QueryComparisonCondition as Xr, InExpressionNode as Xs, applyOperationsToPersistedColumnMappingsState as Xt, buildInverseRelationLine as Y, ExpressionSelectMap as Ya, DelegateOrderBy as Yi, Arkormx as Yn, ModelFactory as Yo, QueryColumnComparisonCondition as Yr, FunctionExpressionNode as Ys, PersistedTimestampColumn as Yt, buildModelBlock as Z, GroupByAggregateSpec as Za, DelegateRows as Zi, RegisteredModel as Zn, SetBasedEagerLoader as Zo, QueryComparisonOperator as Zr, JsonExpressionNode as Zs, createEmptyPersistedColumnMappingsState as Zt, ensureArkormConfigLoading as _, PrismaLikeInclude as _a, RelationMetadataType as _c, QueryNotCondition as _i, QueryExecutionException as _n, ModelEventName as _o, SEEDER_BRAND as _r, RelationDefaultValue as _s, resolveMigrationClassName as _t, getRuntimeCompatibilityAdapter as a, GetUserConfig as aa, ColumnMap as ac, QueryJoin as ai, readPersistedColumnMappingsState as an, AttributeWhereInput as ao, getRegisteredPaths as ar, HasManyRelation as as, deriveRelationFieldName as at, getDefaultStubsPath as b, PrismaLikeSelect as ba, AppliedMigrationsState as bc, QueryScalarComparisonOperator as bi, ModelNotFoundException as bn, ModelRelationshipKey as bo, SeederConstructor as br, RelationResultCache as bs, runPrismaCommand as bt, PrismaDelegateMap as c, NamingCase as ca, HasOneRelationMetadata as cc, QueryJoinConstraint as ci, resolveColumnMappingsFilePath as cn, ModelAttributeValue as co, loadMigrationsFrom as cr, BelongsToManyRelation as cs, findEnumBlock as ct, inferDelegateName as d, PaginationOptions as da, MorphManyRelationMetadata as dc, QueryJoinRawConstraint as di, validatePersistedMetadataFeaturesForMigrations as dn, ModelCreateData as do, registerFactories as dr, RelationAggregateConstraint as ds, formatEnumDefaultValue as dt, DelegateUpdateArgs as ea, ValueExpressionNode as ec, QueryExistsCondition as ei, getPersistedEnumMap as en, AttributeOrderBy as eo, RuntimePathKey as er, MorphOneRelation as es, buildUniqueConstraintLine as et, awaitConfiguredModelsRegistration as f, PaginationURLDriver as fa, MorphOneRelationMetadata as fc, QueryJoinType as fi, writePersistedColumnMappingsState as fn, ModelDeclaredAttributeKey as fo, registerMigrations as fr, RelationAggregateInput as fs, formatRelationAction as ft, emitRuntimeDebugEvent as g, PrismaFindManyArgsLike as ga, RelationMetadata as gc, QueryLogicalOperator as gi, RelationResolutionException as gn, ModelEventListener as go, resetRuntimeRegistryForTests as gr, RelationDefaultResolver as gs, resolveEnumName as gt, defineConfig as h, PrismaDelegateLike as ha, PivotModelStatic as hc, QueryJsonConditionKind as hi, ScopeNotDefinedException as hn, ModelEventHandlerConstructor as ho, registerSeeders as hr, RelationConstraint as hs, pad as ht, RuntimeModuleLoader as i, EagerLoadMap as ia, BelongsToRelationMetadata as ic, QueryGroupCondition as ii, getPersistedTimestampColumns as in, AttributeUpdateInput as io, getRegisteredModels as ir, HasManyThroughRelation as is, deriveRelationAlias as it, loadArkormConfig as j, QuerySchemaRow as ja, SchemaForeignKeyAction as jc, SortDirection as ji, resolveGeneratedExpression as jn, ExpressionBuilder as jo, AdapterInspectionRequest as jr, ArkormCollection as js, deleteAppliedMigrationsStateFromStore as jt, isQuerySchemaLike as k, QuerySchemaInclude as ka, SchemaColumnType as kc, SelectSpec as ki, TableBuilder as kn, CaseExpression as ko, AdapterCapability as kr, LengthAwarePaginator as ks, computeMigrationChecksum as kt, createPrismaAdapter as l, PaginationCurrentPageResolver as la, HasOneThroughRelationMetadata as lc, QueryJoinNestedConstraint as li, resolvePersistedMetadataFeatures as ln, ModelAttributes as lo, loadModelsFrom as lr, Relation as ls, findModelBlock as lt, configureArkormRuntime as m, PrismaClientLike as ma, MorphToRelationMetadata as mc, QueryJsonCondition as mi, UniqueConstraintResolutionException as mn, ModelEventHandler as mo, registerPaths as mr, RelationColumnLookupSpec as ms, getMigrationPlan as mt, PivotModel as n, DelegateWhere as na, DatabaseTablePersistedMetadataOptions as nc, QueryFullTextCondition as ni, getPersistedPrimaryKeyGeneration as nn, AttributeSchemaDelegate as no, getRegisteredFactories as nr, HasOneThroughRelation as ns, deriveCollectionFieldName as nt, resolveRuntimeCompatibilityQuerySchema as o, ModelQuerySchemaLike as oa, HasManyRelationMetadata as oc, QueryJoinBoolean as oi, rebuildPersistedColumnMappingsState as on, DelegateForModelSchema as oo, getRegisteredSeeders as or, BelongsToRelation as os, deriveSingularFieldName as ot, bindAdapterToModels as p, PaginationURLDriverFactory as pa, MorphToManyRelationMetadata as pc, QueryJoinValueConstraint as pi, UnsupportedAdapterFeatureException as pn, ModelEventDispatcher as po, registerModels as pr, RelationAggregateType as ps, generateMigrationFile as pt, buildFieldLine as q, ModelStatic as qa, DelegateFindManyArgs as qi, AttributeOptions as qn, where as qo, InsertManySpec as qr, ExpressionJsonCast as qs, PersistedPrimaryKeyGeneration as qt, LoadedRuntimeModule as r, EagerLoadConstraint as ra, BelongsToManyRelationMetadata as rc, QueryGroupByItem as ri, getPersistedTableMetadata as rn, AttributeSelect as ro, getRegisteredMigrations as rr, HasOneRelation as rs, deriveInverseRelationAlias as rt, resolveRuntimeCompatibilityQuerySchemaOrThrow as s, ModelTableCase as sa, HasManyThroughRelationMetadata as sc, QueryJoinColumnConstraint as si, resetPersistedColumnMappingsCache as sn, GlobalScope as so, loadFactoriesFrom as sr, SingleResultRelation as ss, escapeRegex as st, URLDriver as t, DelegateUpdateData as ta, DatabaseTableOptions as tc, QueryExpressionCondition as ti, getPersistedEnumTsType as tn, AttributeQuerySchema as to, RuntimePathMap as tr, MorphManyRelation as ts, createMigrationTimestamp as tt, createPrismaDelegateMap as u, PaginationMeta as ua, ModelMetadata as uc, QueryJoinNullConstraint as ui, syncPersistedColumnMappingsFromState as un, ModelAttributesOf as uo, loadSeedersFrom as ur, RelationTableLoader as us, formatDefaultValue as ut, getActiveTransactionAdapter as v, PrismaLikeOrderBy as va, AppliedMigrationEntry as vc, QueryOrderBy as vi, QueryExecutionExceptionContext as vn, ModelLifecycleState as vo, Seeder as vr, RelationMetadataProvider as vs, resolvePrismaType as vt, getRuntimePaginationCurrentPageResolver as w, PrismaTransactionCapableClient as wa, MigrationInstanceLike as wc, RawQuerySpec as wi, DB as wn, QuerySchemaForModel as wo, createPrismaCompatibilityAdapter as wr, JoinSource as ws, supportsDatabaseReset as wt, getRuntimeAdapter as x, PrismaLikeSortOrder as xa, GenerateMigrationOptions as xc, QuerySelectColumn as xi, MissingDelegateException as xn, ModelRelationshipResult as xo, SeederInput as xr, RelationTableLookupSpec as xs, stripPrismaSchemaModelsAndEnums as xt, getActiveTransactionClient as y, PrismaLikeScalarFilter as ya, AppliedMigrationRun as yc, QueryRawCondition as yi, QueryConstraintException as yn, ModelOrderByInput as yo, SeederCallArgument as yr, RelationResult as ys, runMigrationWithPrisma as yt, applyCreateTableOperation as z, RuntimeClientLike as za, TimestampColumnBehavior as zc, ArkormDebugEvent as zi, MakeSeederCommand as zn, fn as zo, AggregateSpec as zr, FactoryState as zs, readAppliedMigrationsStateFromStore as zt };