arkormx 2.11.0 → 2.11.2

package/dist/cli.mjs

@@ -251,27 +251,48 @@ const markMigrationRun = (state, run) => {
 		runs: nextRuns
 	};
 };
-const getLastMigrationRun = (state) => {
+/**
+* Groups the applied migrations into batches, oldest batch first, each batch
+* holding its migration ids in application order.
+*
+* A "batch" is one `migrate` run. When no runs were recorded (e.g. legacy state
+* written before run tracking), each applied migration is treated as its own
+* batch so `--step` still behaves predictably.
+*
+* @param state
+* @returns
+*/
+const resolveAppliedBatches = (state) => {
 	const runs = state.runs ?? [];
-	if (runs.length === 0) return void 0;
-	return runs.map((run, index) => ({
+	if (runs.length > 0) return runs.map((run, index) => ({
 		run,
 		index
 	})).sort((left, right) => {
-		const appliedAtOrder = right.run.appliedAt.localeCompare(left.run.appliedAt);
+		const appliedAtOrder = left.run.appliedAt.localeCompare(right.run.appliedAt);
 		if (appliedAtOrder !== 0) return appliedAtOrder;
-		return right.index - left.index;
-	})[0]?.run;
+		return left.index - right.index;
+	}).map((entry) => entry.run.migrationIds);
+	return state.migrations.map((migration) => [migration.id]);
 };
-const getLatestAppliedMigrations = (state, steps) => {
-	return state.migrations.map((migration, index) => ({
-		migration,
-		index
-	})).sort((left, right) => {
-		const appliedAtOrder = right.migration.appliedAt.localeCompare(left.migration.appliedAt);
-		if (appliedAtOrder !== 0) return appliedAtOrder;
-		return right.index - left.index;
-	}).slice(0, Math.max(0, steps)).map((entry) => entry.migration);
+/**
+* Resolves the migrations belonging to the most recent `batches` batches, ordered
+* for rollback — **reverse of the order they were applied** (most recent batch
+* first, and within each batch the migration that ran `up()` last runs `down()`
+* first), so a rollback exactly reverses how the migrations were applied.
+*
+* Defaults to a single batch (`migrate:rollback` with no `--step`); `--step=N`
+* rolls back the last N batches.
+*
+* @param state
+* @param batches
+* @returns
+*/
+const getLastBatchMigrations = (state, batches = 1) => {
+	if (batches < 1) return [];
+	const allBatches = resolveAppliedBatches(state);
+	const selected = allBatches.slice(Math.max(0, allBatches.length - batches));
+	const byId = new Map(state.migrations.map((migration) => [migration.id, migration]));
+	return selected.reverse().flatMap((migrationIds) => [...migrationIds].reverse()).map((id) => byId.get(id)).filter((migration) => Boolean(migration));
 };
 
 //#endregion
@@ -3148,6 +3169,32 @@ const getRuntimeAdapter = () => {
 	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
 	return runtimeAdapter;
 };
+/**
+* Releases the database resources held by the configured runtime — the adapter's
+* connection pool and/or the configured client. Intended for short-lived
+* processes (the CLI) so the Node event loop drains and the process exits
+* promptly instead of hanging on pool idle timeouts. Teardown failures are
+* swallowed because the process is shutting down anyway.
+*/
+const disposeArkormRuntime = async () => {
+	let adapterDisposed = false;
+	try {
+		if (runtimeAdapter && typeof runtimeAdapter.dispose === "function") {
+			await runtimeAdapter.dispose();
+			adapterDisposed = true;
+		}
+	} catch {}
+	const client = getRuntimeClient();
+	if (!client) return;
+	try {
+		if (typeof client.$disconnect === "function") await client.$disconnect();
+		else if (!adapterDisposed && typeof client.destroy === "function") await client.destroy();
+		else if (!adapterDisposed && typeof client.end === "function") await client.end();
+	} catch {}
+};
+const getActiveTransactionClient = () => {
+	return transactionClientStorage.getStore();
+};
 const isTransactionCapableClient = (value) => {
 	if (!value || typeof value !== "object") return false;
 	return typeof value.$transaction === "function";
@@ -3263,6 +3310,14 @@ var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
 			returning: false
 		};
 	}
+	/**
+	* Disconnects the underlying Prisma client so a short-lived process (e.g. the
+	* CLI) can exit promptly instead of waiting for the connection to idle out.
+	*/
+	async dispose() {
+		const disconnectable = this.prisma;
+		if (typeof disconnectable.$disconnect === "function") await disconnectable.$disconnect();
+	}
 	hasTransactionSupport(client) {
 		return Boolean(client) && typeof client.$transaction === "function";
 	}
@@ -3722,6 +3777,26 @@ var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
 		});
 	}
 };
+/**
+* Factory function to create a PrismaDatabaseAdapter instance with the given
+* Prisma client and optional delegate name mapping.
+*
+* @param prisma    The Prisma client instance to be used by the adapter.
+* @param mapping   Optional mapping of delegate names.
+* @returns         A new instance of PrismaDatabaseAdapter.
+*/
+const createPrismaDatabaseAdapter = (prisma, mapping = {}) => {
+	return new PrismaDatabaseAdapter(prisma, mapping);
+};
+/**
+* Alias for createPrismaDatabaseAdapter to maintain backward compatibility with
+* previous versions of Arkorm that exported the adapter factory under a different name.
+*
+* @param prisma    The Prisma client instance to be used by the adapter.
+* @param mapping   Optional mapping of delegate names.
+* @returns         A new instance of PrismaDatabaseAdapter.
+*/
+const createPrismaCompatibilityAdapter = createPrismaDatabaseAdapter;
 
 //#endregion
 //#region src/cli/CliApp.ts
@@ -4493,6 +4568,143 @@ var CliApp = class {
 	}
 };
 
+//#endregion
+//#region src/helpers/runtime-compatibility.ts
+const isCompatibilityClient = (value) => {
+	return Boolean(value) && typeof value === "object";
+};
+const getCompatibilitySources = (preferredClient) => {
+	const activeTransactionClient = getActiveTransactionClient();
+	const runtimeClient = getRuntimeClient();
+	return activeTransactionClient ? [
+		activeTransactionClient,
+		preferredClient,
+		runtimeClient
+	] : [preferredClient, runtimeClient];
+};
+const getRuntimeCompatibilityAdapter = (preferredClient) => {
+	const client = getCompatibilitySources(preferredClient).find((source) => isCompatibilityClient(source));
+	if (!client) return void 0;
+	return createPrismaCompatibilityAdapter(client);
+};
+
+//#endregion
+//#region src/cli/commands/DbCommand.ts
+/**
+* Executes a raw SQL statement against the configured database adapter and prints
+* the result — Arkorm's equivalent of `artisan db`.
+*
+* @author Legacy (3m1n3nc3)
+*/
+var DbCommand = class extends Command {
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `db
+        {sql? : Raw SQL statement to execute (prompts for it when omitted)}
+        {--file= : Read the SQL statement from a file instead of the argument}
+        {--bindings= : JSON array of positional bindings for ? placeholders}
+        {--json : Print result rows as JSON instead of a table}
+    `;
+		this.description = "Execute a raw SQL statement against the configured database";
+	}
+	async handle() {
+		this.app.command = this;
+		await loadArkormConfig();
+		const sql = await this.resolveSql();
+		if (sql === null) return;
+		if (sql.trim().length === 0) return void this.error("Error: No SQL statement provided.");
+		const bindings = this.resolveBindings();
+		if (bindings === null) return;
+		const adapter = getRuntimeAdapter() ?? getRuntimeCompatibilityAdapter();
+		if (!adapter) return void this.error("Error: No database driver configured. Set an adapter or client in arkormx.config.");
+		if (typeof adapter.rawQuery !== "function") return void this.error("Error: The configured adapter does not support raw queries. Use a SQL-backed adapter (e.g. the Kysely/PostgreSQL adapter).");
+		let rows;
+		try {
+			rows = await adapter.rawQuery({
+				sql,
+				bindings
+			});
+		} catch (error) {
+			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		this.render(rows);
+	}
+	/**
+	* Resolves the SQL to run. Priority: the positional argument, then `--file`,
+	* then an interactive editor prompt (so a bare `arkorm db` lets you compose a
+	* statement). Returns `null` (after emitting an error) when a referenced file is
+	* missing.
+	*/
+	async resolveSql() {
+		const argument = this.argument("sql");
+		if (typeof argument === "string" && argument.trim().length > 0) return argument;
+		const filePath = this.option("file") ? String(this.option("file")) : void 0;
+		if (filePath) {
+			const resolved = resolve(filePath);
+			if (!existsSync$1(resolved)) {
+				this.error(`Error: SQL file not found: ${this.app.formatPathForLog(resolved)}`);
+				return null;
+			}
+			return readFileSync$1(resolved, "utf-8");
+		}
+		return await this.multiline("Query", "Enter the SQL to execute");
+	}
+	/**
+	* Parses `--bindings` as a JSON array. Returns `null` (after emitting an error)
+	* when the value is present but not a valid JSON array.
+	*/
+	resolveBindings() {
+		const raw = this.option("bindings");
+		if (raw == null || raw === "") return [];
+		try {
+			const parsed = JSON.parse(String(raw));
+			if (!Array.isArray(parsed)) {
+				this.error("Error: --bindings must be a JSON array, e.g. --bindings=\"[1, \\\"active\\\"]\".");
+				return null;
+			}
+			return parsed;
+		} catch {
+			this.error("Error: --bindings must be valid JSON, e.g. --bindings=\"[1, \\\"active\\\"]\".");
+			return null;
+		}
+	}
+	render(rows) {
+		if (this.option("json")) {
+			this.line(JSON.stringify(rows, null, 2));
+			return;
+		}
+		if (rows.length === 0) {
+			this.success("Statement executed successfully. (0 rows returned)");
+			return;
+		}
+		this.renderTable(rows);
+		this.success(`(${rows.length} row${rows.length === 1 ? "" : "s"})`);
+	}
+	renderTable(rows) {
+		const columns = rows.reduce((accumulator, row) => {
+			Object.keys(row).forEach((key) => {
+				if (!accumulator.includes(key)) accumulator.push(key);
+			});
+			return accumulator;
+		}, []);
+		const cell = (value) => {
+			if (value === null || value === void 0) return "NULL";
+			if (value instanceof Date) return value.toISOString();
+			if (typeof value === "object") return JSON.stringify(value);
+			return String(value);
+		};
+		const widths = columns.map((column) => rows.reduce((max, row) => Math.max(max, cell(row[column]).length), column.length));
+		const separator = `+${widths.map((width) => "-".repeat(width + 2)).join("+")}+`;
+		const formatRow = (values) => `| ${values.map((value, index) => value.padEnd(widths[index])).join(" | ")} |`;
+		this.line(separator);
+		this.line(formatRow(columns));
+		this.line(separator);
+		rows.forEach((row) => this.line(formatRow(columns.map((column) => cell(row[column])))));
+		this.line(separator);
+	}
+};
+
 //#endregion
 //#region src/cli/commands/InitCommand.ts
 /**
@@ -5090,7 +5302,7 @@ var MigrateRollbackCommand = class extends Command {
 	constructor(..._args) {
 		super(..._args);
 		this.signature = `migrate:rollback
-        {--step= : Number of latest applied migration classes to rollback}
+        {--step= : Number of batches to rollback (defaults to 1, the last batch)}
         {--dry-run : Preview rollback targets without applying changes}
         {--deploy : Use prisma migrate deploy instead of migrate dev (Prisma compatibility driver only)}
         {--skip-generate : Skip prisma generate (Prisma compatibility driver only)}
@@ -5112,14 +5324,10 @@ var MigrateRollbackCommand = class extends Command {
 		const useDatabaseMigrations = supportsDatabaseMigrationExecution(adapter);
 		const persistedFeatures = resolvePersistedMetadataFeatures(this.app.getConfig("features"));
 		let appliedState = await readAppliedMigrationsStateFromStore(adapter, stateFilePath);
-		const stepOption = this.option("step", 1);
-		const stepCount = stepOption == null ? void 0 : Number(stepOption);
-		if (stepCount != null && (!Number.isFinite(stepCount) || stepCount <= 0 || !Number.isInteger(stepCount))) return void this.error("Error: --step must be a positive integer.");
-		const targets = stepCount ? getLatestAppliedMigrations(appliedState, stepCount) : (() => {
-			const lastRun = getLastMigrationRun(appliedState);
-			if (!lastRun) return [];
-			return lastRun.migrationIds.map((id) => appliedState.migrations.find((migration) => migration.id === id)).filter((migration) => Boolean(migration));
-		})();
+		const stepOption = this.option("step");
+		const stepCount = stepOption == null ? 1 : Number(stepOption);
+		if (!Number.isFinite(stepCount) || stepCount <= 0 || !Number.isInteger(stepCount)) return void this.error("Error: --step must be a positive integer.");
+		const targets = getLastBatchMigrations(appliedState, stepCount);
 		if (targets.length === 0) return void this.error("Error: No tracked migrations available to rollback.");
 		const available = await this.loadAllMigrations(migrationDirs);
 		const rollbackClasses = targets.map((target) => {
@@ -5458,26 +5666,31 @@ var logo_default = String.raw`
 //#endregion
 //#region src/cli/index.ts
 const app = new CliApp();
-await Kernel.init(app, {
-	logo: logo_default,
-	name: "Arkormˣ CLI",
-	baseCommands: [
-		InitCommand,
-		MakeModelCommand,
-		MakeFactoryCommand,
-		MakeSeederCommand,
-		MakeMigrationCommand,
-		ModelsSyncCommand,
-		SeedCommand,
-		MigrateCommand,
-		MigrateFreshCommand,
-		MigrateRollbackCommand,
-		MigrationHistoryCommand
-	],
-	exceptionHandler(exception) {
-		throw exception;
-	}
-});
+try {
+	await Kernel.init(app, {
+		logo: logo_default,
+		name: "Arkormˣ CLI",
+		baseCommands: [
+			DbCommand,
+			InitCommand,
+			MakeModelCommand,
+			MakeFactoryCommand,
+			MakeSeederCommand,
+			MakeMigrationCommand,
+			ModelsSyncCommand,
+			SeedCommand,
+			MigrateCommand,
+			MigrateFreshCommand,
+			MigrateRollbackCommand,
+			MigrationHistoryCommand
+		],
+		exceptionHandler(exception) {
+			throw exception;
+		}
+	});
+} finally {
+	await disposeArkormRuntime();
+}
 
 //#endregion
 export {  };

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

@@ -1,7 +1,7 @@
-import { Kysely, Transaction } from "kysely";
-import { PrismaClient } from "@prisma/client";
 import { Collection } from "@h3ravel/collect.js";
+import { Kysely, Transaction } from "kysely";
 import { Command } from "@h3ravel/musket";
+import { PrismaClient } from "@prisma/client";
 
 //#region src/types/migrations.d.ts
 type SchemaColumnType = 'id' | 'uuid' | 'enum' | 'string' | 'text' | 'integer' | 'bigInteger' | 'float' | 'decimal' | 'boolean' | 'json' | 'date' | 'dateTime' | 'timestamp';
@@ -3508,6 +3508,10 @@ type ModelLifecycleState = {
 //#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>>;
 /**
@@ -4640,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.
@@ -5808,6 +5894,12 @@ interface DatabaseAdapter {
   readAppliedMigrationsState?: () => Promise<AppliedMigrationsState>;
   writeAppliedMigrationsState?: (state: AppliedMigrationsState) => Promise<void>;
   transaction: <TResult = unknown>(callback: (adapter: DatabaseAdapter) => TResult | Promise<TResult>, context?: AdapterTransactionContext) => Promise<TResult>;
+  /**
+   * Releases any resources the adapter holds (connection pools, clients). Called
+   * by short-lived processes such as the CLI so the event loop can drain and the
+   * process exits promptly instead of waiting for pool idle timeouts.
+   */
+  dispose?: () => Promise<void>;
 }
 //#endregion
 //#region src/adapters/KyselyDatabaseAdapter.d.ts
@@ -5827,6 +5919,12 @@ declare class KyselyDatabaseAdapter implements DatabaseAdapter {
   private static readonly migrationRunTable;
   readonly capabilities: AdapterCapabilities;
   constructor(db: KyselyExecutor, mapping?: KyselyTableMapping);
+  /**
+   * Destroys the underlying Kysely instance, which ends its connection pool so a
+   * short-lived process (e.g. the CLI) can exit promptly. A no-op when `db` is a
+   * transaction executor, which does not own the pool.
+   */
+  dispose(): Promise<void>;
   private resolveConfiguredDatabaseName;
   private createMaintenanceConnectionString;
   private getMissingDatabaseNameFromError;
@@ -6125,6 +6223,11 @@ declare class PrismaDatabaseAdapter implements DatabaseAdapter {
   readonly capabilities: AdapterCapabilities;
   private readonly delegates;
   constructor(prisma: PrismaClientLike, mapping?: PrismaDelegateNameMapping);
+  /**
+   * Disconnects the underlying Prisma client so a short-lived process (e.g. the
+   * CLI) can exit promptly instead of waiting for the connection to idle out.
+   */
+  dispose(): Promise<void>;
   private hasTransactionSupport;
   private normalizeCandidate;
   private unique;
@@ -6800,6 +6903,33 @@ declare class CliApp {
   };
 }
 //#endregion
+//#region src/cli/commands/DbCommand.d.ts
+/**
+ * Executes a raw SQL statement against the configured database adapter and prints
+ * the result — Arkorm's equivalent of `artisan db`.
+ *
+ * @author Legacy (3m1n3nc3)
+ */
+declare class DbCommand extends Command<CliApp> {
+  protected signature: string;
+  protected description: string;
+  handle(): Promise<undefined>;
+  /**
+   * Resolves the SQL to run. Priority: the positional argument, then `--file`,
+   * then an interactive editor prompt (so a bare `arkorm db` lets you compose a
+   * statement). Returns `null` (after emitting an error) when a referenced file is
+   * missing.
+   */
+  private resolveSql;
+  /**
+   * Parses `--bindings` as a JSON array. Returns `null` (after emitting an error)
+   * when the value is present but not a valid JSON array.
+   */
+  private resolveBindings;
+  private render;
+  private renderTable;
+}
+//#endregion
 //#region src/cli/commands/InitCommand.d.ts
 /**
  * The InitCommand class implements the CLI command for initializing Arkormˣ by creating
@@ -7842,6 +7972,20 @@ declare const buildMigrationRunId: () => string;
 declare const markMigrationRun: (state: AppliedMigrationsState, run: AppliedMigrationRun) => AppliedMigrationsState;
 declare const getLastMigrationRun: (state: AppliedMigrationsState) => AppliedMigrationRun | undefined;
 declare const getLatestAppliedMigrations: (state: AppliedMigrationsState, steps: number) => AppliedMigrationEntry[];
+/**
+ * Resolves the migrations belonging to the most recent `batches` batches, ordered
+ * for rollback — **reverse of the order they were applied** (most recent batch
+ * first, and within each batch the migration that ran `up()` last runs `down()`
+ * first), so a rollback exactly reverses how the migrations were applied.
+ *
+ * Defaults to a single batch (`migrate:rollback` with no `--step`); `--step=N`
+ * rolls back the last N batches.
+ *
+ * @param state
+ * @param batches
+ * @returns
+ */
+declare const getLastBatchMigrations: (state: AppliedMigrationsState, batches?: number) => AppliedMigrationEntry[];
 //#endregion
 //#region src/helpers/migrations.d.ts
 declare const PRISMA_MODEL_REGEX: RegExp;
@@ -8228,6 +8372,14 @@ declare const getRuntimePrismaClient: () => RuntimeClientLike | undefined;
  * @returns
  */
 declare const getRuntimeAdapter: () => DatabaseAdapter | undefined;
+/**
+ * Releases the database resources held by the configured runtime — the adapter's
+ * connection pool and/or the configured client. Intended for short-lived
+ * processes (the CLI) so the Node event loop drains and the process exits
+ * promptly instead of hanging on pool idle timeouts. Teardown failures are
+ * swallowed because the process is shutting down anyway.
+ */
+declare const disposeArkormRuntime: () => Promise<void>;
 declare const getActiveTransactionClient: () => RuntimeClientLike | undefined;
 declare const getActiveTransactionAdapter: () => DatabaseAdapter | undefined;
 declare const isTransactionCapableClient: (value: unknown) => value is TransactionCapableClient;
@@ -8357,4 +8509,4 @@ declare class URLDriver {
   url(page: number): string;
 }
 //#endregion
-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 };
+export { buildPrimaryKeyLine as $, EachCallback as $a, DelegateRow as $i, RegisteredFactory as $n, InlineFactory as $o, QueryComparisonCondition as $r, ExpressionNode as $s, createEmptyPersistedColumnMappingsState as $t, isQuerySchemaLike as A, QuerySchemaCreateData as Aa, PrimaryKeyGeneration as Ac, RelationLoadPlan as Ai, EnumBuilder as An, QuerySchemaForModelInstance as Ao, createKyselyAdapter as Ar, RelatedModelForRelationship as As, computeMigrationChecksum as At, applyCreateTableOperation as B, QuerySchemaWhere as Ba, SchemaTableAlterOperation as Bc, ArkormBootContext as Bi, MigrateCommand as Bn, coalesce as Bo, AggregateOperation as Br, FactoryDefinition as Bs, readAppliedMigrationsState as Bt, getRuntimeClient as C, PrismaLikeSelect as Ca, AppliedMigrationEntry as Cc, QueryScalarComparisonOperator as Ci, MissingDelegateException as Cn, ModelLifecycleState as Co, SeederConstructor as Cr, RelationMetadataProvider as Cs, supportsDatabaseCreation as Ct, getRuntimePrismaClient as D, PrismaTransactionCapableClient as Da, GeneratedMigrationFile as Dc, RawQuerySpec as Di, MIGRATION_BRAND as Dn, ModelUpdateData as Do, createPrismaCompatibilityAdapter as Dr, EagerLoadRelations as Ds, toModelName as Dt, getRuntimePaginationURLDriverFactory as E, PrismaTransactionCallback as Ea, GenerateMigrationOptions as Ec, QueryTimeCondition as Ei, DB as En, ModelRelationshipResult as Eo, PrismaDelegateNameMapping as Er, RelationTableLookupSpec as Es, toMigrationFileSlug as Et, PrimaryKeyGenerationPlanner as F, QuerySchemaRows as Fa, SchemaForeignKey as Fc, UpdateManySpec as Fi, SeedCommand as Fn, Expression as Fo, AdapterModelFieldStructure as Fr, Paginator as Fs, getLastMigrationRun as Ft, applyMigrationToPrismaSchema as G, SoftDeleteConfig as Ga, TimestampNames as Gc, CastHandler as Gi, InitCommand as Gn, fromExpressionNode as Go, DatabaseRow as Gr, MaybePromise as Gs, writeAppliedMigrationsState as Gt, applyMigrationRollbackToDatabase as H, RuntimeClientLike as Ha, SchemaTableDropOperation as Hc, ArkormDebugEvent as Hi, MakeModelCommand as Hn, count as Ho, AggregateSpec as Hr, FactoryModelConstructor as Hs, removeAppliedMigration as Ht, PRISMA_ENUM_MEMBER_REGEX as I, QuerySchemaSelect as Ia, SchemaForeignKeyAction as Ic, UpdateSpec as Ii, ModelsSyncCommand as In, ExpressionBuilder as Io, AdapterModelIntrospectionOptions as Ir, ArkormCollection as Is, getLatestAppliedMigrations as It, buildFieldLine as J, TransactionContext as Ja, ClientResolver as Ji, resolveCast as Jn, min as Jo, DeleteManySpec as Jr, CaseExpressionBranch as Js, PersistedMetadataFeatures as Jt, applyOperationsToPrismaSchema as K, TransactionCallback as Ka, TimestampNaming as Kc, CastMap as Ki, DbCommand as Kn, json as Ko, DatabaseRows as Kr, AggregateExpressionNode as Ks, writeAppliedMigrationsStateToStore as Kt, PRISMA_ENUM_REGEX as L, QuerySchemaUniqueWhere as La, SchemaIndex as Lc, UpsertSpec as Li, MigrationHistoryCommand as Ln, JsonExpression as Lo, AdapterModelStructure as Lr, FactoryAttributeResolver as Ls, isMigrationApplied as Lt, loadArkormConfig as M, QuerySchemaInclude as Ma, PrismaSchemaSyncOptions as Mc, SelectSpec as Mi, GeneratedColumnExpression as Mn, Model as Mo, AdapterCapability as Mr, WhereCallback as Ms, deleteAppliedMigrationsStateFromStore as Mt, resetArkormRuntimeForTests as N, QuerySchemaOrderBy as Na, SchemaColumn as Nc, SoftDeleteQueryMode as Ni, resolveGeneratedExpression as Nn, AggregateExpression as No, AdapterDatabaseCreationResult as Nr, JoinClause as Ns, findAppliedMigration as Nt, getUserConfig as O, PrismaTransactionContext as Oa, MigrationClass as Oc, RelationAggregateSpec as Oi, Migration as On, ModelWhereInput as Oo, createPrismaDatabaseAdapter as Or, JoinOn as Os, buildMigrationIdentity as Ot, runArkormTransaction as P, QuerySchemaRow as Pa, SchemaColumnType as Pc, SortDirection as Pi, ForeignKeyBuilder as Pn, CaseExpression as Po, AdapterInspectionRequest as Pr, LengthAwarePaginator as Ps, getLastBatchMigrations as Pt, buildModelBlock as Q, ChunkCallback as Qa, DelegateOrderBy as Qi, Arkormx as Qn, where as Qo, QueryColumnComparisonCondition as Qr, ExpressionJsonCast as Qs, applyOperationsToPersistedColumnMappingsState as Qt, PRISMA_MODEL_REGEX as R, QuerySchemaUpdateArgs as Ra, SchemaOperation as Rc, AdapterBindableModel as Ri, MigrateRollbackCommand as Rn, avg as Ro, AdapterQueryOperation as Rr, FactoryAttributes as Rs, markMigrationApplied as Rt, getRuntimeAdapter as S, PrismaLikeScalarFilter as Sa, RelationMetadataType as Sc, QueryRawCondition as Si, ModelNotFoundException as Sn, ModelEventName as So, SeederCallArgument as Sr, RelationDefaultValue as Ss, stripPrismaSchemaModelsAndEnums as St, getRuntimePaginationCurrentPageResolver as T, PrismaLikeWhereInput as Ta, AppliedMigrationsState as Tc, QueryTarget as Ti, ArkormException as Tn, ModelRelationshipKey as To, PrismaDatabaseAdapter as Tr, RelationResultCache as Ts, supportsDatabaseReset as Tt, applyMigrationRollbackToPrismaSchema as U, Serializable as Ua, SchemaUniqueConstraint as Uc, ArkormDebugHandler as Ui, MakeMigrationCommand as Un, expressionBuilder as Uo, DatabaseAdapter as Ur, FactoryRelationshipResolver as Us, resolveMigrationStateFilePath as Ut, applyDropTableOperation as V, RawSelectInput as Va, SchemaTableCreateOperation as Vc, ArkormConfig as Vi, MakeSeederCommand as Vn, col as Vo, AggregateSelection as Vr, FactoryDefinitionAttributes as Vs, readAppliedMigrationsStateFromStore as Vt, applyMigrationToDatabase as W, SimplePaginationMeta as Wa, TimestampColumnBehavior as Wc, CastDefinition as Wi, MakeFactoryCommand as Wn, fn as Wo, DatabasePrimitive as Wr, FactoryState as Ws, supportsDatabaseMigrationState as Wt, buildInverseRelationLine as X, ModelStatic as Xa, DelegateFindManyArgs as Xi, AttributeOptions as Xn, sum as Xo, InsertManySpec as Xr, ColumnExpressionNode as Xs, PersistedTableMetadata as Xt, buildIndexLine as Y, TransactionOptions as Ya, DelegateCreateData as Yi, Attribute as Yn, raw as Yo, DeleteSpec as Yr, CaseExpressionNode as Ys, PersistedPrimaryKeyGeneration as Yt, buildMigrationSource as Z, RelationshipModelStatic as Za, DelegateInclude as Zi, Arkorm as Zn, val as Zo, InsertSpec as Zr, ExpressionBinaryOperator as Zs, PersistedTimestampColumn as Zt, emitRuntimeDebugEvent as _, PrismaClientLike as _a, MorphOneRelationMetadata as _c, QueryJsonCondition as _i, ScopeNotDefinedException as _n, ModelDeclaredAttributeKey as _o, registerPaths as _r, RelationAggregateInput as _s, resolveEnumName as _t, getRuntimeCompatibilityAdapter as a, DelegateWhere as aa, ValueExpressionNode as ac, QueryFullTextCondition as ai, getPersistedTableMetadata as an, AttributeOrderBy as ao, getRegisteredFactories as ar, MorphOneRelation as as, deriveRelationAlias as at, getActiveTransactionClient as b, PrismaLikeInclude as ba, PivotModelStatic as bc, QueryNotCondition as bi, QueryExecutionExceptionContext as bn, ModelEventHandlerConstructor as bo, SEEDER_BRAND as br, RelationConstraint as bs, runMigrationWithPrisma as bt, PrismaDelegateMap as c, GetUserConfig as ca, BelongsToManyRelationMetadata as cc, QueryJoin as ci, rebuildPersistedColumnMappingsState as cn, AttributeSelect as co, getRegisteredPaths as cr, HasOneRelation as cs, escapeRegex as ct, inferDelegateName as d, NamingCase as da, HasManyRelationMetadata as dc, QueryJoinConstraint as di, resolvePersistedMetadataFeatures as dn, DelegateForModelSchema as do, loadMigrationsFrom as dr, BelongsToRelation as ds, formatDefaultValue as dt, DelegateRows as ea, FunctionExpressionNode as ec, QueryComparisonOperator as ei, deletePersistedColumnMappingsState as en, ExpressionSelectMap as eo, RegisteredModel as er, ModelFactory as es, buildRelationLine as et, awaitConfiguredModelsRegistration as f, PaginationCurrentPageResolver as fa, HasManyThroughRelationMetadata as fc, QueryJoinNestedConstraint as fi, syncPersistedColumnMappingsFromState as fn, GlobalScope as fo, loadModelsFrom as fr, SingleResultRelation as fs, formatEnumDefaultValue as ft, disposeArkormRuntime as g, PaginationURLDriverFactory as ga, MorphManyRelationMetadata as gc, QueryJoinValueConstraint as gi, UniqueConstraintResolutionException as gn, ModelCreateData as go, registerModels as gr, RelationAggregateConstraint as gs, pad as gt, defineConfig as h, PaginationURLDriver as ha, ModelMetadata as hc, QueryJoinType as hi, UnsupportedAdapterFeatureException as hn, ModelAttributesOf as ho, registerMigrations as hr, RelationTableLoader as hs, getMigrationPlan as ht, RuntimeModuleLoader as i, DelegateUpdateData as ia, RawExpressionNode as ic, QueryExpressionCondition as ii, getPersistedPrimaryKeyGeneration as in, AttributeCreateInput as io, RuntimePathMap as ir, MorphToManyRelation as is, deriveInverseRelationAlias as it, isTransactionCapableClient as j, QuerySchemaFindManyArgs as ja, PrismaMigrationWorkflowOptions as jc, RelationLoadSpec as ji, TableBuilder as jn, RelatedModelClass as jo, AdapterCapabilities as jr, RelatedModelFromResult as js, createEmptyAppliedMigrationsState as jt, isDelegateLike as k, PrismaTransactionOptions as ka, MigrationInstanceLike as kc, RelationFilterSpec as ki, SchemaBuilder as kn, QuerySchemaForModel as ko, KyselyDatabaseAdapter as kr, JoinSource as ks, buildMigrationRunId as kt, createPrismaAdapter as l, ModelQuerySchemaLike as la, BelongsToRelationMetadata as lc, QueryJoinBoolean as li, resetPersistedColumnMappingsCache as ln, AttributeUpdateInput as lo, getRegisteredSeeders as lr, HasManyThroughRelation as ls, findEnumBlock as lt, configureArkormRuntime as m, PaginationOptions as ma, HasOneThroughRelationMetadata as mc, QueryJoinRawConstraint as mi, writePersistedColumnMappingsState as mn, ModelAttributes as mo, registerFactories as mr, Relation as ms, generateMigrationFile as mt, PivotModel as n, DelegateUniqueWhere as na, JsonExpressionNode as nc, QueryDayCondition as ni, getPersistedEnumMap as nn, GroupByAggregateSpec as no, RuntimePathInput as nr, SetBasedEagerLoader as ns, createMigrationTimestamp as nt, resolveRuntimeCompatibilityQuerySchema as o, EagerLoadConstraint as oa, DatabaseTableOptions as oc, QueryGroupByItem as oi, getPersistedTimestampColumns as on, AttributeQuerySchema as oo, getRegisteredMigrations as or, MorphManyRelation as os, deriveRelationFieldName as ot, bindAdapterToModels as p, PaginationMeta as pa, HasOneRelationMetadata as pc, QueryJoinNullConstraint as pi, validatePersistedMetadataFeaturesForMigrations as pn, ModelAttributeValue as po, loadSeedersFrom as pr, BelongsToManyRelation as ps, formatRelationAction as pt, buildEnumBlock as q, TransactionCapableClient as qa, CastType as qi, CliApp as qn, max as qo, DatabaseValue as qr, BinaryExpressionNode as qs, PersistedColumnMappingsState as qt, LoadedRuntimeModule as r, DelegateUpdateArgs as ra, NullCheckExpressionNode as rc, QueryExistsCondition as ri, getPersistedEnumTsType as rn, QueryBuilder as ro, RuntimePathKey as rr, MorphToRelation as rs, deriveCollectionFieldName as rt, resolveRuntimeCompatibilityQuerySchemaOrThrow as s, EagerLoadMap as sa, DatabaseTablePersistedMetadataOptions as sc, QueryGroupCondition as si, readPersistedColumnMappingsState as sn, AttributeSchemaDelegate as so, getRegisteredModels as sr, HasOneThroughRelation as ss, deriveSingularFieldName as st, URLDriver as t, DelegateSelect as ta, InExpressionNode as tc, QueryCondition as ti, getPersistedColumnMap as tn, GroupByAggregateRow as to, RuntimeConstructor as tr, defineFactory as ts, buildUniqueConstraintLine as tt, createPrismaDelegateMap as u, ModelTableCase as ua, ColumnMap as uc, QueryJoinColumnConstraint as ui, resolveColumnMappingsFilePath as un, AttributeWhereInput as uo, loadFactoriesFrom as ur, HasManyRelation as us, findModelBlock as ut, ensureArkormConfigLoading as v, PrismaDelegateLike as va, MorphToManyRelationMetadata as vc, QueryJsonConditionKind as vi, RelationResolutionException as vn, ModelEventDispatcher as vo, registerSeeders as vr, RelationAggregateType as vs, resolveMigrationClassName as vt, getRuntimeDebugHandler as w, PrismaLikeSortOrder as wa, AppliedMigrationRun as wc, QuerySelectColumn as wi, ArkormErrorContext as wn, ModelOrderByInput as wo, SeederInput as wr, RelationResult as ws, supportsDatabaseMigrationExecution as wt, getDefaultStubsPath as x, PrismaLikeOrderBy as xa, RelationMetadata as xc, QueryOrderBy as xi, QueryConstraintException as xn, ModelEventListener as xo, Seeder as xr, RelationDefaultResolver as xs, runPrismaCommand as xt, getActiveTransactionAdapter as y, PrismaFindManyArgsLike as ya, MorphToRelationMetadata as yc, QueryLogicalOperator as yi, QueryExecutionException as yn, ModelEventHandler as yo, resetRuntimeRegistryForTests as yr, RelationColumnLookupSpec as ys, resolvePrismaType as yt, applyAlterTableOperation as z, QuerySchemaUpdateData as za, SchemaPrimaryKey as zc, AdapterQueryInspection as zi, MigrateFreshCommand as zn, caseWhen as zo, AdapterTransactionContext as zr, FactoryCallback as zs, markMigrationRun as zt };