arkormx 2.11.1 → 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-43R9yWVX.d.mts → index-KPekH7gI.d.mts}

@@ -5894,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
@@ -5913,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;
@@ -6211,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;
@@ -6886,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
@@ -7928,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;
@@ -8314,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;
@@ -8443,4 +8509,4 @@ declare class URLDriver {
   url(page: number): string;
 }
 //#endregion
-export { buildRelationLine as $, GroupByAggregateSpec as $a, DelegateUniqueWhere as $i, RuntimePathInput as $n, SetBasedEagerLoader as $o, QueryDayCondition as $r, JsonExpressionNode as $s, getPersistedColumnMap as $t, isTransactionCapableClient as A, QuerySchemaOrderBy as Aa, SchemaColumn as Ac, SoftDeleteQueryMode as Ai, GeneratedColumnExpression as An, AggregateExpression as Ao, AdapterDatabaseCreationResult as Ar, JoinClause as As, createEmptyAppliedMigrationsState as At, applyDropTableOperation as B, Serializable as Ba, SchemaUniqueConstraint as Bc, ArkormDebugHandler as Bi, MakeModelCommand as Bn, expressionBuilder as Bo, DatabaseAdapter as Br, FactoryRelationshipResolver as Bs, removeAppliedMigration as Bt, getRuntimeDebugHandler as C, PrismaTransactionCallback as Ca, GenerateMigrationOptions as Cc, QueryTimeCondition as Ci, ArkormException as Cn, ModelRelationshipResult as Co, PrismaDelegateNameMapping as Cr, RelationTableLookupSpec as Cs, supportsDatabaseMigrationExecution as Ct, getUserConfig as D, QuerySchemaCreateData as Da, PrimaryKeyGeneration as Dc, RelationLoadPlan as Di, SchemaBuilder as Dn, QuerySchemaForModelInstance as Do, createKyselyAdapter as Dr, RelatedModelForRelationship as Ds, buildMigrationIdentity as Dt, getRuntimePrismaClient as E, PrismaTransactionOptions as Ea, MigrationInstanceLike as Ec, RelationFilterSpec as Ei, Migration as En, QuerySchemaForModel as Eo, KyselyDatabaseAdapter as Er, JoinSource as Es, toModelName as Et, PRISMA_ENUM_MEMBER_REGEX as F, QuerySchemaUpdateArgs as Fa, SchemaOperation as Fc, AdapterBindableModel as Fi, MigrationHistoryCommand as Fn, avg as Fo, AdapterQueryOperation as Fr, FactoryAttributes as Fs, isMigrationApplied as Ft, applyOperationsToPrismaSchema as G, TransactionContext as Ga, ClientResolver as Gi, resolveCast as Gn, min as Go, DeleteManySpec as Gr, CaseExpressionBranch as Gs, PersistedColumnMappingsState as Gt, applyMigrationRollbackToPrismaSchema as H, SoftDeleteConfig as Ha, TimestampNames as Hc, CastHandler as Hi, MakeFactoryCommand as Hn, fromExpressionNode as Ho, DatabaseRow as Hr, MaybePromise as Hs, supportsDatabaseMigrationState as Ht, PRISMA_ENUM_REGEX as I, QuerySchemaUpdateData as Ia, SchemaPrimaryKey as Ic, AdapterQueryInspection as Ii, MigrateRollbackCommand as In, caseWhen as Io, AdapterTransactionContext as Ir, FactoryCallback as Is, markMigrationApplied as It, buildIndexLine as J, RelationshipModelStatic as Ja, DelegateInclude as Ji, Arkorm as Jn, val as Jo, InsertSpec as Jr, ExpressionBinaryOperator as Js, PersistedTableMetadata as Jt, buildEnumBlock as K, TransactionOptions as Ka, DelegateCreateData as Ki, Attribute as Kn, raw as Ko, DeleteSpec as Kr, CaseExpressionNode as Ks, PersistedMetadataFeatures as Kt, PRISMA_MODEL_REGEX as L, QuerySchemaWhere as La, SchemaTableAlterOperation as Lc, ArkormBootContext as Li, MigrateFreshCommand as Ln, coalesce as Lo, AggregateOperation as Lr, FactoryDefinition as Ls, markMigrationRun as Lt, resetArkormRuntimeForTests as M, QuerySchemaRows as Ma, SchemaForeignKey as Mc, UpdateManySpec as Mi, ForeignKeyBuilder as Mn, Expression as Mo, AdapterModelFieldStructure as Mr, Paginator as Ms, findAppliedMigration as Mt, runArkormTransaction as N, QuerySchemaSelect as Na, SchemaForeignKeyAction as Nc, UpdateSpec as Ni, SeedCommand as Nn, ExpressionBuilder as No, AdapterModelIntrospectionOptions as Nr, ArkormCollection as Ns, getLastMigrationRun as Nt, isDelegateLike as O, QuerySchemaFindManyArgs as Oa, PrismaMigrationWorkflowOptions as Oc, RelationLoadSpec as Oi, EnumBuilder as On, RelatedModelClass as Oo, AdapterCapabilities as Or, RelatedModelFromResult as Os, buildMigrationRunId as Ot, PrimaryKeyGenerationPlanner as P, QuerySchemaUniqueWhere as Pa, SchemaIndex as Pc, UpsertSpec as Pi, ModelsSyncCommand as Pn, JsonExpression as Po, AdapterModelStructure as Pr, FactoryAttributeResolver as Ps, getLatestAppliedMigrations as Pt, buildPrimaryKeyLine as Q, GroupByAggregateRow as Qa, DelegateSelect as Qi, RuntimeConstructor as Qn, defineFactory as Qo, QueryCondition as Qr, InExpressionNode as Qs, deletePersistedColumnMappingsState as Qt, applyAlterTableOperation as R, RawSelectInput as Ra, SchemaTableCreateOperation as Rc, ArkormConfig as Ri, MigrateCommand as Rn, col as Ro, AggregateSelection as Rr, FactoryDefinitionAttributes as Rs, readAppliedMigrationsState as Rt, getRuntimeClient as S, PrismaLikeWhereInput as Sa, AppliedMigrationsState as Sc, QueryTarget as Si, ArkormErrorContext as Sn, ModelRelationshipKey as So, PrismaDatabaseAdapter as Sr, RelationResultCache as Ss, supportsDatabaseCreation as St, getRuntimePaginationURLDriverFactory as T, PrismaTransactionContext as Ta, MigrationClass as Tc, RelationAggregateSpec as Ti, MIGRATION_BRAND as Tn, ModelWhereInput as To, createPrismaDatabaseAdapter as Tr, JoinOn as Ts, toMigrationFileSlug as Tt, applyMigrationToDatabase as U, TransactionCallback as Ua, TimestampNaming as Uc, CastMap as Ui, InitCommand as Un, json as Uo, DatabaseRows as Ur, AggregateExpressionNode as Us, writeAppliedMigrationsState as Ut, applyMigrationRollbackToDatabase as V, SimplePaginationMeta as Va, TimestampColumnBehavior as Vc, CastDefinition as Vi, MakeMigrationCommand as Vn, fn as Vo, DatabasePrimitive as Vr, FactoryState as Vs, resolveMigrationStateFilePath as Vt, applyMigrationToPrismaSchema as W, TransactionCapableClient as Wa, CastType as Wi, CliApp as Wn, max as Wo, DatabaseValue as Wr, BinaryExpressionNode as Ws, writeAppliedMigrationsStateToStore as Wt, buildMigrationSource as X, EachCallback as Xa, DelegateRow as Xi, RegisteredFactory as Xn, InlineFactory as Xo, QueryComparisonCondition as Xr, ExpressionNode as Xs, applyOperationsToPersistedColumnMappingsState as Xt, buildInverseRelationLine as Y, ChunkCallback as Ya, DelegateOrderBy as Yi, Arkormx as Yn, where as Yo, QueryColumnComparisonCondition as Yr, ExpressionJsonCast as Ys, PersistedTimestampColumn as Yt, buildModelBlock as Z, ExpressionSelectMap as Za, DelegateRows as Zi, RegisteredModel as Zn, ModelFactory as Zo, QueryComparisonOperator as Zr, FunctionExpressionNode as Zs, createEmptyPersistedColumnMappingsState as Zt, ensureArkormConfigLoading as _, PrismaLikeInclude as _a, PivotModelStatic as _c, QueryNotCondition as _i, QueryExecutionException as _n, ModelEventHandlerConstructor as _o, SEEDER_BRAND as _r, RelationConstraint as _s, resolveMigrationClassName as _t, getRuntimeCompatibilityAdapter as a, GetUserConfig as aa, BelongsToManyRelationMetadata as ac, QueryJoin as ai, readPersistedColumnMappingsState as an, AttributeSelect as ao, getRegisteredPaths as ar, HasOneRelation as as, deriveRelationFieldName as at, getDefaultStubsPath as b, PrismaLikeSelect as ba, AppliedMigrationEntry as bc, QueryScalarComparisonOperator as bi, ModelNotFoundException as bn, ModelLifecycleState as bo, SeederConstructor as br, RelationMetadataProvider as bs, runPrismaCommand as bt, PrismaDelegateMap as c, NamingCase as ca, HasManyRelationMetadata as cc, QueryJoinConstraint as ci, resolveColumnMappingsFilePath as cn, DelegateForModelSchema as co, loadMigrationsFrom as cr, BelongsToRelation as cs, findEnumBlock as ct, inferDelegateName as d, PaginationOptions as da, HasOneThroughRelationMetadata as dc, QueryJoinRawConstraint as di, validatePersistedMetadataFeaturesForMigrations as dn, ModelAttributes as do, registerFactories as dr, Relation as ds, formatEnumDefaultValue as dt, DelegateUpdateArgs as ea, NullCheckExpressionNode as ec, QueryExistsCondition as ei, getPersistedEnumMap as en, QueryBuilder as eo, RuntimePathKey as er, MorphToRelation as es, buildUniqueConstraintLine as et, awaitConfiguredModelsRegistration as f, PaginationURLDriver as fa, ModelMetadata as fc, QueryJoinType as fi, writePersistedColumnMappingsState as fn, ModelAttributesOf as fo, registerMigrations as fr, RelationTableLoader as fs, formatRelationAction as ft, emitRuntimeDebugEvent as g, PrismaFindManyArgsLike as ga, MorphToRelationMetadata as gc, QueryLogicalOperator as gi, RelationResolutionException as gn, ModelEventHandler as go, resetRuntimeRegistryForTests as gr, RelationColumnLookupSpec as gs, resolveEnumName as gt, defineConfig as h, PrismaDelegateLike as ha, MorphToManyRelationMetadata as hc, QueryJsonConditionKind as hi, ScopeNotDefinedException as hn, ModelEventDispatcher as ho, registerSeeders as hr, RelationAggregateType as hs, pad as ht, RuntimeModuleLoader as i, EagerLoadMap as ia, DatabaseTablePersistedMetadataOptions as ic, QueryGroupCondition as ii, getPersistedTimestampColumns as in, AttributeSchemaDelegate as io, getRegisteredModels as ir, HasOneThroughRelation as is, deriveRelationAlias as it, loadArkormConfig as j, QuerySchemaRow as ja, SchemaColumnType as jc, SortDirection as ji, resolveGeneratedExpression as jn, CaseExpression as jo, AdapterInspectionRequest as jr, LengthAwarePaginator as js, deleteAppliedMigrationsStateFromStore as jt, isQuerySchemaLike as k, QuerySchemaInclude as ka, PrismaSchemaSyncOptions as kc, SelectSpec as ki, TableBuilder as kn, Model as ko, AdapterCapability as kr, WhereCallback as ks, computeMigrationChecksum as kt, createPrismaAdapter as l, PaginationCurrentPageResolver as la, HasManyThroughRelationMetadata as lc, QueryJoinNestedConstraint as li, resolvePersistedMetadataFeatures as ln, GlobalScope as lo, loadModelsFrom as lr, SingleResultRelation as ls, findModelBlock as lt, configureArkormRuntime as m, PrismaClientLike as ma, MorphOneRelationMetadata as mc, QueryJsonCondition as mi, UniqueConstraintResolutionException as mn, ModelDeclaredAttributeKey as mo, registerPaths as mr, RelationAggregateInput as ms, getMigrationPlan as mt, PivotModel as n, DelegateWhere as na, ValueExpressionNode as nc, QueryFullTextCondition as ni, getPersistedPrimaryKeyGeneration as nn, AttributeOrderBy as no, getRegisteredFactories as nr, MorphOneRelation as ns, deriveCollectionFieldName as nt, resolveRuntimeCompatibilityQuerySchema as o, ModelQuerySchemaLike as oa, BelongsToRelationMetadata as oc, QueryJoinBoolean as oi, rebuildPersistedColumnMappingsState as on, AttributeUpdateInput as oo, getRegisteredSeeders as or, HasManyThroughRelation as os, deriveSingularFieldName as ot, bindAdapterToModels as p, PaginationURLDriverFactory as pa, MorphManyRelationMetadata as pc, QueryJoinValueConstraint as pi, UnsupportedAdapterFeatureException as pn, ModelCreateData as po, registerModels as pr, RelationAggregateConstraint as ps, generateMigrationFile as pt, buildFieldLine as q, ModelStatic as qa, DelegateFindManyArgs as qi, AttributeOptions as qn, sum as qo, InsertManySpec as qr, ColumnExpressionNode as qs, PersistedPrimaryKeyGeneration as qt, LoadedRuntimeModule as r, EagerLoadConstraint as ra, DatabaseTableOptions as rc, QueryGroupByItem as ri, getPersistedTableMetadata as rn, AttributeQuerySchema as ro, getRegisteredMigrations as rr, MorphManyRelation as rs, deriveInverseRelationAlias as rt, resolveRuntimeCompatibilityQuerySchemaOrThrow as s, ModelTableCase as sa, ColumnMap as sc, QueryJoinColumnConstraint as si, resetPersistedColumnMappingsCache as sn, AttributeWhereInput as so, loadFactoriesFrom as sr, HasManyRelation as ss, escapeRegex as st, URLDriver as t, DelegateUpdateData as ta, RawExpressionNode as tc, QueryExpressionCondition as ti, getPersistedEnumTsType as tn, AttributeCreateInput as to, RuntimePathMap as tr, MorphToManyRelation as ts, createMigrationTimestamp as tt, createPrismaDelegateMap as u, PaginationMeta as ua, HasOneRelationMetadata as uc, QueryJoinNullConstraint as ui, syncPersistedColumnMappingsFromState as un, ModelAttributeValue as uo, loadSeedersFrom as ur, BelongsToManyRelation as us, formatDefaultValue as ut, getActiveTransactionAdapter as v, PrismaLikeOrderBy as va, RelationMetadata as vc, QueryOrderBy as vi, QueryExecutionExceptionContext as vn, ModelEventListener as vo, Seeder as vr, RelationDefaultResolver as vs, resolvePrismaType as vt, getRuntimePaginationCurrentPageResolver as w, PrismaTransactionCapableClient as wa, GeneratedMigrationFile as wc, RawQuerySpec as wi, DB as wn, ModelUpdateData as wo, createPrismaCompatibilityAdapter as wr, EagerLoadRelations as ws, supportsDatabaseReset as wt, getRuntimeAdapter as x, PrismaLikeSortOrder as xa, AppliedMigrationRun as xc, QuerySelectColumn as xi, MissingDelegateException as xn, ModelOrderByInput as xo, SeederInput as xr, RelationResult as xs, stripPrismaSchemaModelsAndEnums as xt, getActiveTransactionClient as y, PrismaLikeScalarFilter as ya, RelationMetadataType as yc, QueryRawCondition as yi, QueryConstraintException as yn, ModelEventName as yo, SeederCallArgument as yr, RelationDefaultValue as ys, runMigrationWithPrisma as yt, applyCreateTableOperation as z, RuntimeClientLike as za, SchemaTableDropOperation as zc, ArkormDebugEvent as zi, MakeSeederCommand as zn, count as zo, AggregateSpec as zr, FactoryModelConstructor as zs, readAppliedMigrationsStateFromStore as zt };
+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 };