arkormx 2.0.0-next.8 → 2.0.0

package/dist/index.d.mts

@@ -1,6 +1,6 @@
+import { Collection } from "@h3ravel/collect.js";
 import { Kysely, Transaction } from "kysely";
 import { Command } from "@h3ravel/musket";
-import { Collection } from "@h3ravel/collect.js";
 import { PrismaClient } from "@prisma/client";
 
 //#region src/types/migrations.d.ts
@@ -118,27 +118,80 @@ interface CastHandler<T = unknown> {
 }
 type CastDefinition = CastType | CastHandler;
 type CastMap = Record<string, CastDefinition>;
-type PrismaClientLike = PrismaClient | Record<string, unknown>;
-interface PrismaTransactionOptions {
+type RuntimeClientLike = PrismaClient | Record<string, unknown>;
+interface TransactionOptions {
   maxWait?: number;
   timeout?: number;
   isolationLevel?: string;
 }
-type PrismaTransactionCallback<TResult = unknown> = (client: PrismaClientLike) => TResult | Promise<TResult>;
-interface PrismaTransactionCapableClient {
-  $transaction: <TResult>(callback: PrismaTransactionCallback<TResult>, options?: PrismaTransactionOptions) => Promise<TResult>;
+interface TransactionContext {
+  client?: RuntimeClientLike;
+  adapter?: DatabaseAdapter;
+}
+type TransactionCallback<TResult = unknown> = (context: TransactionContext) => TResult | Promise<TResult>;
+interface TransactionCapableClient {
+  $transaction: <TResult>(callback: (client: RuntimeClientLike) => TResult | Promise<TResult>, options?: TransactionOptions) => Promise<TResult>;
 }
-type ClientResolver = PrismaClientLike | (() => PrismaClientLike);
+/**
+ * @deprecated Use RuntimeClientLike instead.
+ */
+type PrismaClientLike = RuntimeClientLike;
+/**
+ * @deprecated Use TransactionOptions instead.
+ */
+type PrismaTransactionOptions = TransactionOptions;
+/**
+ * @deprecated Use TransactionContext instead.
+ */
+type PrismaTransactionContext = TransactionContext;
+/**
+ * @deprecated Use TransactionCallback instead.
+ */
+type PrismaTransactionCallback<TResult = unknown> = TransactionCallback<TResult>;
+/**
+ * @deprecated Use TransactionCapableClient instead.
+ */
+type PrismaTransactionCapableClient = TransactionCapableClient;
+type ClientResolver = RuntimeClientLike | (() => RuntimeClientLike);
 interface AdapterBindableModel {
   setAdapter: (adapter?: DatabaseAdapter) => void;
 }
 interface ArkormBootContext {
-  prisma?: PrismaClientLike;
+  client?: RuntimeClientLike;
+  /**
+   * @deprecated Use client instead.
+   */
+  prisma?: RuntimeClientLike;
   bindAdapter: (adapter: DatabaseAdapter, models: AdapterBindableModel[]) => DatabaseAdapter;
 }
+interface AdapterQueryInspection {
+  adapter: string;
+  operation: string;
+  target?: string;
+  sql?: string;
+  parameters?: ReadonlyArray<unknown>;
+  detail?: Record<string, unknown>;
+}
+interface ArkormDebugEvent {
+  type: 'query';
+  phase: 'before' | 'after' | 'error';
+  adapter: string;
+  operation: string;
+  target?: string;
+  inspection?: AdapterQueryInspection | null;
+  meta?: Record<string, unknown>;
+  durationMs?: number;
+  error?: unknown;
+}
+type ArkormDebugHandler = (event: ArkormDebugEvent) => void;
 interface ArkormConfig {
   /**
-   * @property prisma Optional Prisma client instance or resolver used for compatibility, CLI flows, and Prisma-backed transactions.
+  * @property client Optional runtime client instance or resolver used for compatibility mode, CLI flows, and client-backed transactions.
+  */
+  client?: ClientResolver;
+  /**
+  * @deprecated Use client instead.
+  * @property prisma Optional Prisma client instance or resolver used for compatibility mode, CLI flows, and Prisma-backed transactions.
    */
   prisma?: ClientResolver;
   /**
@@ -149,6 +202,11 @@ interface ArkormConfig {
    * @property boot Optional synchronous runtime boot hook for central adapter binding.
    */
   boot?: (context: ArkormBootContext) => void;
+  /**
+   * @property debug Optional runtime query debugging. `true` logs through Arkorm's default logger;
+   * a callback receives structured debug events for custom handling.
+   */
+  debug?: boolean | ArkormDebugHandler;
   /**
    * @property pagination Configuration options related to pagination behavior and URL generation.
    */
@@ -294,7 +352,7 @@ interface SoftDeleteConfig {
   enabled: boolean;
   column: string;
 }
-interface PrismaDelegateLike {
+interface ModelQuerySchemaLike {
   findMany: (args?: any) => Promise<unknown[]>;
   findFirst: (args?: any) => Promise<unknown | null>;
   create: (args: any) => Promise<unknown>;
@@ -302,36 +360,88 @@ interface PrismaDelegateLike {
   delete: (args: any) => Promise<unknown>;
   count: (args?: any) => Promise<number>;
 }
+/**
+ * @deprecated Use ModelQuerySchemaLike instead.
+ */
+type PrismaDelegateLike = ModelQuerySchemaLike;
 type FallbackIfUnknownOrNever<TValue, TFallback> = [TValue] extends [never] ? TFallback : unknown extends TValue ? TFallback : TValue;
-type DelegateFindManyArgs<TDelegate extends PrismaDelegateLike> = FallbackIfUnknownOrNever<NonNullable<Parameters<TDelegate['findMany']>[0]>, PrismaFindManyArgsLike>;
-type DelegateWhere<TDelegate extends PrismaDelegateLike> = DelegateFindManyArgs<TDelegate> extends {
+type QuerySchemaFindManyArgs<TSchema extends ModelQuerySchemaLike> = FallbackIfUnknownOrNever<NonNullable<Parameters<TSchema['findMany']>[0]>, PrismaFindManyArgsLike>;
+type QuerySchemaWhere<TSchema extends ModelQuerySchemaLike> = QuerySchemaFindManyArgs<TSchema> extends {
   where?: infer TWhere;
 } ? FallbackIfUnknownOrNever<TWhere, PrismaLikeWhereInput> : PrismaLikeWhereInput;
-type DelegateInclude<TDelegate extends PrismaDelegateLike> = DelegateFindManyArgs<TDelegate> extends {
+type QuerySchemaInclude<TSchema extends ModelQuerySchemaLike> = QuerySchemaFindManyArgs<TSchema> extends {
   include?: infer TInclude;
 } ? FallbackIfUnknownOrNever<TInclude, PrismaLikeInclude> : PrismaLikeInclude;
-type DelegateOrderBy<TDelegate extends PrismaDelegateLike> = DelegateFindManyArgs<TDelegate> extends {
+type QuerySchemaOrderBy<TSchema extends ModelQuerySchemaLike> = QuerySchemaFindManyArgs<TSchema> extends {
   orderBy?: infer TOrderBy;
 } ? FallbackIfUnknownOrNever<TOrderBy, PrismaLikeOrderBy> : PrismaLikeOrderBy;
-type DelegateSelect<TDelegate extends PrismaDelegateLike> = DelegateFindManyArgs<TDelegate> extends {
+type QuerySchemaSelect<TSchema extends ModelQuerySchemaLike> = QuerySchemaFindManyArgs<TSchema> extends {
   select?: infer TSelect;
 } ? FallbackIfUnknownOrNever<TSelect, PrismaLikeSelect> : PrismaLikeSelect;
-type DelegateCreateData<TDelegate extends PrismaDelegateLike> = Parameters<TDelegate['create']>[0] extends {
+type QuerySchemaCreateData<TSchema extends ModelQuerySchemaLike> = Parameters<TSchema['create']>[0] extends {
   data: infer TData;
 } ? TData : Record<string, unknown>;
-type DelegateUpdateArgs<TDelegate extends PrismaDelegateLike> = Parameters<TDelegate['update']>[0];
-type DelegateUpdateData<TDelegate extends PrismaDelegateLike> = DelegateUpdateArgs<TDelegate> extends {
+type QuerySchemaUpdateArgs<TSchema extends ModelQuerySchemaLike> = Parameters<TSchema['update']>[0];
+type QuerySchemaUpdateData<TSchema extends ModelQuerySchemaLike> = QuerySchemaUpdateArgs<TSchema> extends {
   data: infer TData;
 } ? FallbackIfUnknownOrNever<TData, Record<string, unknown>> : Record<string, unknown>;
-type DelegateUniqueWhere<TDelegate extends PrismaDelegateLike> = DelegateUpdateArgs<TDelegate> extends {
+type QuerySchemaUniqueWhere<TSchema extends ModelQuerySchemaLike> = QuerySchemaUpdateArgs<TSchema> extends {
   where: infer TWhere;
 } ? FallbackIfUnknownOrNever<TWhere, Record<string, unknown>> : Record<string, unknown>;
-type DelegateRow<TDelegate extends PrismaDelegateLike> = Exclude<Awaited<ReturnType<TDelegate['findFirst']>>, null>;
-type DelegateRows<TDelegate extends PrismaDelegateLike> = Awaited<ReturnType<TDelegate['findMany']>>;
+type QuerySchemaRow<TSchema extends ModelQuerySchemaLike> = Exclude<Awaited<ReturnType<TSchema['findFirst']>>, null>;
+type QuerySchemaRows<TSchema extends ModelQuerySchemaLike> = Awaited<ReturnType<TSchema['findMany']>>;
+/**
+ * @deprecated Use QuerySchemaFindManyArgs instead.
+ */
+type DelegateFindManyArgs<TSchema extends ModelQuerySchemaLike> = QuerySchemaFindManyArgs<TSchema>;
+/**
+ * @deprecated Use QuerySchemaWhere instead.
+ */
+type DelegateWhere<TSchema extends ModelQuerySchemaLike> = QuerySchemaWhere<TSchema>;
+/**
+ * @deprecated Use QuerySchemaInclude instead.
+ */
+type DelegateInclude<TSchema extends ModelQuerySchemaLike> = QuerySchemaInclude<TSchema>;
+/**
+ * @deprecated Use QuerySchemaOrderBy instead.
+ */
+type DelegateOrderBy<TSchema extends ModelQuerySchemaLike> = QuerySchemaOrderBy<TSchema>;
+/**
+ * @deprecated Use QuerySchemaSelect instead.
+ */
+type DelegateSelect<TSchema extends ModelQuerySchemaLike> = QuerySchemaSelect<TSchema>;
+/**
+ * @deprecated Use QuerySchemaCreateData instead.
+ */
+type DelegateCreateData<TSchema extends ModelQuerySchemaLike> = QuerySchemaCreateData<TSchema>;
+/**
+ * @deprecated Use QuerySchemaUpdateArgs instead.
+ */
+type DelegateUpdateArgs<TSchema extends ModelQuerySchemaLike> = QuerySchemaUpdateArgs<TSchema>;
+/**
+ * @deprecated Use QuerySchemaUpdateData instead.
+ */
+type DelegateUpdateData<TSchema extends ModelQuerySchemaLike> = QuerySchemaUpdateData<TSchema>;
+/**
+ * @deprecated Use QuerySchemaUniqueWhere instead.
+ */
+type DelegateUniqueWhere<TSchema extends ModelQuerySchemaLike> = QuerySchemaUniqueWhere<TSchema>;
+/**
+ * @deprecated Use QuerySchemaRow instead.
+ */
+type DelegateRow<TSchema extends ModelQuerySchemaLike> = QuerySchemaRow<TSchema>;
+/**
+ * @deprecated Use QuerySchemaRows instead.
+ */
+type DelegateRows<TSchema extends ModelQuerySchemaLike> = QuerySchemaRows<TSchema>;
 type Serializable = Record<string, unknown>;
 //#endregion
 //#region src/types/metadata.d.ts
 type ColumnMap = Record<string, string>;
+interface PivotModelStatic {
+  new (attributes?: Record<string, unknown>): any;
+  hydrate?: (attributes: Record<string, unknown>) => any;
+}
 interface ModelMetadata {
   table: string;
   primaryKey: string;
@@ -367,6 +477,12 @@ interface BelongsToManyRelationMetadata extends BaseRelationMetadata {
   relatedPivotKey: string;
   parentKey: string;
   relatedKey: string;
+  pivotAccessor?: string;
+  pivotColumns?: string[];
+  pivotCreatedAtColumn?: string;
+  pivotUpdatedAtColumn?: string;
+  pivotWhere?: QueryCondition;
+  pivotModel?: PivotModelStatic;
 }
 interface HasOneThroughRelationMetadata extends BaseRelationMetadata {
   type: 'hasOneThrough';
@@ -411,12 +527,18 @@ interface MorphToManyRelationMetadata extends BaseRelationMetadata {
 type RelationMetadata = HasOneRelationMetadata | HasManyRelationMetadata | BelongsToRelationMetadata | BelongsToManyRelationMetadata | HasOneThroughRelationMetadata | HasManyThroughRelationMetadata | MorphOneRelationMetadata | MorphManyRelationMetadata | MorphToManyRelationMetadata;
 //#endregion
 //#region src/types/db.d.ts
+interface DatabaseTablePersistedMetadataOptions {
+  cwd?: string;
+  configuredPath?: string;
+  strict?: boolean;
+}
 interface DatabaseTableOptions {
   adapter?: DatabaseAdapter;
   primaryKey?: string;
   columns?: Record<string, string>;
   softDelete?: SoftDeleteConfig;
   primaryKeyGeneration?: PrimaryKeyGeneration;
+  persistedMetadata?: boolean | DatabaseTablePersistedMetadataOptions;
   timestampColumns?: TimestampColumnBehavior[];
 }
 //#endregion
@@ -513,6 +635,30 @@ declare abstract class Relation<TModel> {
    * @returns
    */
   whereIn<TKey extends keyof ModelAttributes<TModel> & string>(key: TKey, values: ModelAttributes<TModel>[TKey][]): this;
+  /**
+   * Add a string contains clause to the relationship query.
+   *
+   * @param key
+   * @param value
+   * @returns
+   */
+  whereLike<TKey extends keyof ModelAttributes<TModel> & string>(key: TKey, value: Extract<ModelAttributes<TModel>[TKey], string>): this;
+  /**
+   * Add a string starts-with clause to the relationship query.
+   *
+   * @param key
+   * @param value
+   * @returns
+   */
+  whereStartsWith<TKey extends keyof ModelAttributes<TModel> & string>(key: TKey, value: Extract<ModelAttributes<TModel>[TKey], string>): this;
+  /**
+   * Add a string ends-with clause to the relationship query.
+   *
+   * @param key
+   * @param value
+   * @returns
+   */
+  whereEndsWith<TKey extends keyof ModelAttributes<TModel> & string>(key: TKey, value: Extract<ModelAttributes<TModel>[TKey], string>): this;
   /**
    * Add an order by clause to the relationship query.
    *
@@ -644,14 +790,208 @@ declare abstract class Relation<TModel> {
 declare class BelongsToManyRelation<TParent, TRelated> extends Relation<TRelated> {
   private readonly parent;
   private readonly related;
-  private readonly throughDelegate;
+  private readonly throughTable;
   private readonly foreignPivotKey;
   private readonly relatedPivotKey;
   private readonly parentKey;
   private readonly relatedKey;
+  private static readonly queryDecorationMarker;
+  private pivotColumns;
+  private pivotAccessor;
+  private pivotCreatedAtColumn;
+  private pivotUpdatedAtColumn;
+  private pivotWhere;
+  private pivotModel;
+  private shouldAttachPivot;
   constructor(parent: TParent & {
     getAttribute: (key: string) => unknown;
-  }, related: RelationshipModelStatic, throughDelegate: string, foreignPivotKey: string, relatedPivotKey: string, parentKey: string, relatedKey: string);
+  }, related: RelationshipModelStatic, throughTable: string, foreignPivotKey: string, relatedPivotKey: string, parentKey: string, relatedKey: string);
+  /**
+   * Specifies additional pivot columns to include on the related models.
+   *
+   * @param columns   The pivot columns to include on the related models.
+   * @returns
+   */
+  withPivot(...columns: Array<string | string[]>): this;
+  /**
+   * Specifies that the pivot table contains timestamp columns and optionally
+   * allows customizing the names of those columns.
+   *
+   * @param createdAtColumn    The name of the "created at" timestamp column.
+   * @param updatedAtColumn    The name of the "updated at" timestamp column.
+   * @returns                  The current instance of the relationship.
+   */
+  withTimestamps(createdAtColumn?: string, updatedAtColumn?: string): this;
+  /**
+   * Specifies a custom accessor name for the pivot attributes on the related models.
+   * By default, pivot attributes are accessible via the `pivot` property on the
+   * related models.
+   *
+   * @param accessor    The custom accessor name for the pivot attributes.
+   * @returns           The current instance of the relationship.
+   */
+  as(accessor: string): this;
+  /**
+   * Specifies a custom pivot model to use for the pivot records. The pivot model can
+   * be used to define custom behavior or methods on the pivot records, as well as to
+   * specify a custom hydration method for the pivot records.
+   *
+   * @param pivotModel    The custom pivot model to use.
+   * @returns             The current instance of the relationship.
+   */
+  using(pivotModel: PivotModelStatic): this;
+  /**
+   * Adds a "pivot column" condition to the relationship query.
+   *
+   * @param column    The pivot column to apply the condition on.
+   * @param value     The value to compare the pivot column against.
+   */
+  wherePivot(column: string, value: unknown): this;
+  /**
+   * Adds a "pivot column" condition to the relationship query.
+   *
+   * @param column    The pivot column to apply the condition on.
+   * @param operator  The operator to use for the comparison.
+   * @param value     The value to compare the pivot column against.
+   */
+  wherePivot(column: string, operator: QueryComparisonOperator, value: unknown): this;
+  /**
+   * Adds a "pivot column in" condition to the relationship query.
+   *
+   * @param column
+   * @param values
+   * @returns
+   */
+  wherePivotNotIn(column: string, values: unknown[]): this;
+  /**
+   * Adds a "pivot column between" condition to the relationship query.
+   *
+   * @param column
+   * @param range
+   * @returns
+   */
+  wherePivotBetween(column: string, range: [unknown, unknown]): this;
+  /**
+   * Adds a "pivot column not between" condition to the relationship query.
+   *
+   * @param column
+   * @param range
+   * @returns
+   */
+  wherePivotNotBetween(column: string, range: [unknown, unknown]): this;
+  /**
+   * Adds a "pivot column is null" condition to the relationship query.
+   *
+   * @param column
+   * @returns
+   */
+  wherePivotNull(column: string): this;
+  /**
+   * Adds a "pivot column is not null" condition to the relationship query.
+   *
+   * @param column
+   * @returns
+   */
+  wherePivotNotNull(column: string): this;
+  private addPivotWhere;
+  private makePivotComparison;
+  private buildPivotWhere;
+  private buildPivotTarget;
+  private buildRelatedPivotCondition;
+  private buildPivotMutationWhere;
+  private normalizeIdentifierValue;
+  private isPlainObject;
+  private isModelLike;
+  private normalizeRelatedItems;
+  private normalizeSyncEntries;
+  private resolveParentPivotValue;
+  private resolveRelatedPivotValue;
+  private buildPivotInsertValues;
+  private attachPivotToSingleResult;
+  private insertPivotRow;
+  private selectPivotRows;
+  private deletePivotRows;
+  private buildPivotUpdateValues;
+  private updatePivotRows;
+  /**
+   * Creates a new instance of the related model with the given attributes and attaches
+   * pivot attributes if pivot attributes should be included.
+   *
+   * @param attributes    The attributes to initialize the related model with.
+   * @returns             A new instance of the related model.
+   */
+  make(attributes?: Record<string, unknown>): TRelated;
+  /**
+   * Creates a new related model record with the given attributes, creates a pivot record
+   * with the given pivot attributes, and attaches pivot attributes if pivot attributes
+   * should be included.
+   *
+   * @param attributes        The attributes to initialize the related model with.
+   * @param pivotAttributes   The attributes to initialize the pivot record with.
+   * @returns                 A new instance of the related model with pivot attributes attached.
+   */
+  create(attributes?: Record<string, unknown>, pivotAttributes?: Record<string, unknown>): Promise<TRelated>;
+  /**
+   * Saves a related model record, creates a pivot record with the given pivot attributes
+   * if the related model was not previously persisted, and attaches pivot attributes if
+   * pivot attributes should be included.
+   *
+   * @param related           The related model instance to save.
+   * @param pivotAttributes   The attributes to initialize the pivot record with.
+   * @returns                 A new instance of the related model with pivot attributes attached.
+   */
+  save(related: TRelated, pivotAttributes?: Record<string, unknown>): Promise<TRelated>;
+  /**
+   * Attaches one or more related model records to the parent model by creating pivot
+   * records with the given pivot attributes if pivot attributes should be included.
+   *
+   * @param related           The related model instance(s) to attach.
+   * @param pivotAttributes   The attributes to initialize the pivot record with.
+   * @returns                 The number of related model records attached.
+   */
+  attach(related: TRelated | unknown | Array<TRelated | unknown>, pivotAttributes?: Record<string, unknown>): Promise<number>;
+  /**
+   * Detaches one or more related model records from the parent model by deleting
+   * matching pivot rows. When no related value is provided, all matching pivot rows
+   * for the parent are removed.
+   *
+   * @param related
+   * @returns
+   */
+  detach(related?: TRelated | unknown | Array<TRelated | unknown>): Promise<number>;
+  /**
+   * Synchronizes the pivot table so only the provided related values remain attached.
+   * Existing matching rows can receive updated pivot attributes during the operation.
+   *
+   * @param related
+   * @param pivotAttributes
+   * @returns
+   */
+  sync(related: TRelated | unknown | Array<TRelated | unknown> | Record<string, Record<string, unknown>>, pivotAttributes?: Record<string, unknown>): Promise<{
+    attached: number;
+    detached: number;
+    updated: number;
+  }>;
+  private shouldAttachPivotAttributes;
+  private getPivotColumnSelection;
+  /**
+   * Creates a pivot record from a row of data.
+   *
+   * @param row   The row of data containing pivot attributes.
+   * @returns     The pivot record.
+   */
+  private createPivotRecord;
+  /**
+   * Attaches pivot attributes to the related models if pivot attributes should be included.
+   *
+   * @param results
+   * @param pivotRows
+   * @returns
+   */
+  private attachPivotToResults;
+  private attachPivotToModel;
+  private decorateQueryBuilder;
+  private loadPivotRowsForParent;
   /**
    * Build the relationship query.
    *
@@ -760,14 +1100,14 @@ declare class HasManyRelation<TParent, TRelated> extends Relation<TRelated> {
 declare class HasManyThroughRelation<TParent, TRelated> extends Relation<TRelated> {
   private readonly parent;
   private readonly related;
-  private readonly throughDelegate;
+  private readonly throughTable;
   private readonly firstKey;
   private readonly secondKey;
   private readonly localKey;
   private readonly secondLocalKey;
   constructor(parent: TParent & {
     getAttribute: (key: string) => unknown;
-  }, related: RelationshipModelStatic, throughDelegate: string, firstKey: string, secondKey: string, localKey: string, secondLocalKey: string);
+  }, related: RelationshipModelStatic, throughTable: string, firstKey: string, secondKey: string, localKey: string, secondLocalKey: string);
   /**
    * Build the relationship query.
    *
@@ -824,14 +1164,14 @@ declare class HasOneRelation<TParent, TRelated> extends SingleResultRelation<TPa
 declare class HasOneThroughRelation<TParent, TRelated> extends SingleResultRelation<TParent & {
   getAttribute: (key: string) => unknown;
 }, TRelated> {
-  private readonly throughDelegate;
+  private readonly throughTable;
   private readonly firstKey;
   private readonly secondKey;
   private readonly localKey;
   private readonly secondLocalKey;
   constructor(parent: TParent & {
     getAttribute: (key: string) => unknown;
-  }, related: RelatedModelClass<TRelated>, throughDelegate: string, firstKey: string, secondKey: string, localKey: string, secondLocalKey: string);
+  }, related: RelatedModelClass<TRelated>, throughTable: string, firstKey: string, secondKey: string, localKey: string, secondLocalKey: string);
   /**
    * Build the relationship query.
    *
@@ -917,14 +1257,14 @@ declare class MorphOneRelation<TParent, TRelated> extends SingleResultRelation<T
 declare class MorphToManyRelation<TParent, TRelated> extends Relation<TRelated> {
   private readonly parent;
   private readonly related;
-  private readonly throughDelegate;
+  private readonly throughTable;
   private readonly morphName;
   private readonly relatedPivotKey;
   private readonly parentKey;
   private readonly relatedKey;
   constructor(parent: TParent & {
     getAttribute: (key: string) => unknown;
-  }, related: RelationshipModelStatic, throughDelegate: string, morphName: string, relatedPivotKey: string, parentKey: string, relatedKey: string);
+  }, related: RelationshipModelStatic, throughTable: string, morphName: string, relatedPivotKey: string, parentKey: string, relatedKey: string);
   /**
    * Build the relationship query.
    *
@@ -1045,13 +1385,20 @@ declare const defineFactory: <TModel, TAttributes extends FactoryAttributes = Pa
  * @author Legacy (3m1n3nc3)
  * @since 0.1.0
  */
-declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string, unknown> | string = Record<string, any>, TAttributes extends Record<string, unknown> = ModelAttributesOf<TSchema>> {
+declare abstract class Model<TSchema extends ModelQuerySchemaLike | Record<string, unknown> | string = Record<string, any>, TAttributes extends Record<string, unknown> = ModelAttributesOf<TSchema>> {
   private static readonly lifecycleStates;
   private static readonly emittedDeprecationWarnings;
   private static eventsSuppressed;
   protected static factoryClass?: new () => ModelFactory<any, any>;
   protected static adapter?: DatabaseAdapter;
+  /**
+   * Compatibility-only runtime state retained for 2.x transition window.
+   * New setups should use adapter-first setup via `setAdapter(...)` or runtime config.
+   */
   protected static client: Record<string, unknown>;
+  /**
+   * @deprecated Use `table` instead. This remains as a compatibility alias during the transition.
+   */
   protected static delegate: string;
   protected static table?: string;
   protected static primaryKey: string;
@@ -1072,7 +1419,8 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
   constructor(attributes?: Record<string, unknown>);
   private static emitDeprecationWarning;
   /**
-   * Set the Prisma client delegates for all models.
+      * Compatibility-only runtime API retained for the 2.x transition window.
+      * This is no longer part of the supported runtime bootstrap path.
    *
    * @deprecated Use Model.setAdapter(createPrismaDatabaseAdapter(...)) or another
    * adapter-first bootstrap path instead.
@@ -1080,6 +1428,9 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
    * @param client
    */
   protected static setClient(client: Record<string, unknown>): void;
+  /**
+   * Primary runtime API: bind an adapter directly to the model class.
+   */
   static setAdapter(adapter?: DatabaseAdapter): void;
   static getTable(): string;
   static getPrimaryKey(): string;
@@ -1166,17 +1517,19 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
    * @param options
    * @returns
    */
-  static transaction<T>(callback: (client: PrismaClientLike) => T | Promise<T>, options?: PrismaTransactionOptions): Promise<Awaited<T>>;
+  static transaction<T>(callback: (context: TransactionContext) => T | Promise<T>, options?: TransactionOptions): Promise<Awaited<T>>;
   /**
-   * Get the Prisma delegate for the model.
+   * Compatibility-only runtime API retained for 2.x migration support.
+   * New runtime code should prefer `getAdapter()` and adapter-backed execution.
+   *
    * If a delegate name is provided, it will attempt to resolve that delegate.
-   * Otherwise, it will attempt to resolve a delegate based on the model's name or
+   * Otherwise, it will attempt to resolve a compatibility schema based on the model's name or
    * the static `delegate` property.
    *
    * @param delegate
    * @returns
    */
-  static getDelegate<TDelegate extends PrismaDelegateLike = PrismaDelegateLike>(delegate?: string): TDelegate;
+  static getDelegate<TDelegate extends ModelQuerySchemaLike = ModelQuerySchemaLike>(delegate?: string): TDelegate;
   static getAdapter(): DatabaseAdapter | undefined;
   /**
    * Get a new query builder instance for the model.
@@ -1184,7 +1537,7 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
    * @param this
    * @returns
    */
-  static query<TThis extends abstract new (attributes?: Record<string, unknown>) => Model<any>, TModel extends InstanceType<TThis> = InstanceType<TThis>, TDelegate extends PrismaDelegateLike = DelegateForModelSchema<TModel extends Model<infer TSchema, any> ? TSchema : Record<string, any>, TModel extends Model<any, infer TAttributes> ? TAttributes : Record<string, any>>>(this: TThis): QueryBuilder<TModel, TDelegate>;
+  static query<TThis extends abstract new (attributes?: Record<string, unknown>) => unknown, TModel extends Model<any, any> = InstanceType<TThis> & Model<any, any>, TDelegate extends ModelQuerySchemaLike = QuerySchemaForModel<TModel extends Model<infer TSchema, any> ? TSchema : Record<string, any>, TModel extends Model<any, infer TAttributes> ? TAttributes : Record<string, any>>>(this: TThis): QueryBuilder<TModel, TDelegate>;
   /**
    * Boot hook for subclasses to register scopes or perform one-time setup.
    */
@@ -1199,14 +1552,14 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
    * @param this
    * @returns
    */
-  static withTrashed<TThis extends abstract new (attributes?: Record<string, unknown>) => Model<any>, TModel extends InstanceType<TThis> = InstanceType<TThis>, TDelegate extends PrismaDelegateLike = DelegateForModelSchema<TModel extends Model<infer TSchema, any> ? TSchema : Record<string, any>, TModel extends Model<any, infer TAttributes> ? TAttributes : Record<string, any>>>(this: TThis): QueryBuilder<TModel, TDelegate>;
+  static withTrashed<TThis extends abstract new (attributes?: Record<string, unknown>) => unknown, TModel extends Model<any, any> = InstanceType<TThis> & Model<any, any>, TDelegate extends ModelQuerySchemaLike = QuerySchemaForModel<TModel extends Model<infer TSchema, any> ? TSchema : Record<string, any>, TModel extends Model<any, infer TAttributes> ? TAttributes : Record<string, any>>>(this: TThis): QueryBuilder<TModel, TDelegate>;
   /**
    * Get a query builder instance that only includes soft-deleted records.
    *
    * @param this
    * @returns
    */
-  static onlyTrashed<TThis extends abstract new (attributes?: Record<string, unknown>) => Model<any>, TModel extends InstanceType<TThis> = InstanceType<TThis>, TDelegate extends PrismaDelegateLike = DelegateForModelSchema<TModel extends Model<infer TSchema, any> ? TSchema : Record<string, any>, TModel extends Model<any, infer TAttributes> ? TAttributes : Record<string, any>>>(this: TThis): QueryBuilder<TModel, TDelegate>;
+  static onlyTrashed<TThis extends abstract new (attributes?: Record<string, unknown>) => unknown, TModel extends Model<any, any> = InstanceType<TThis> & Model<any, any>, TDelegate extends ModelQuerySchemaLike = QuerySchemaForModel<TModel extends Model<infer TSchema, any> ? TSchema : Record<string, any>, TModel extends Model<any, infer TAttributes> ? TAttributes : Record<string, any>>>(this: TThis): QueryBuilder<TModel, TDelegate>;
   /**
    * Get a query builder instance that excludes soft-deleted records.
    * This is the default behavior of the query builder, but this method can be used
@@ -1217,7 +1570,7 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
    * @param args
    * @returns
    */
-  static scope<TThis extends abstract new (attributes?: Record<string, unknown>) => Model<any>, TModel extends InstanceType<TThis> = InstanceType<TThis>, TDelegate extends PrismaDelegateLike = DelegateForModelSchema<TModel extends Model<infer TSchema, any> ? TSchema : Record<string, any>, TModel extends Model<any, infer TAttributes> ? TAttributes : Record<string, any>>>(this: TThis, name: string, ...args: unknown[]): QueryBuilder<TModel, TDelegate>;
+  static scope<TThis extends abstract new (attributes?: Record<string, unknown>) => unknown, TModel extends Model<any, any> = InstanceType<TThis> & Model<any, any>, TDelegate extends ModelQuerySchemaLike = QuerySchemaForModel<TModel extends Model<infer TSchema, any> ? TSchema : Record<string, any>, TModel extends Model<any, infer TAttributes> ? TAttributes : Record<string, any>>>(this: TThis, name: string, ...args: unknown[]): QueryBuilder<TModel, TDelegate>;
   /**
    * Get the soft delete configuration for the model, including whether
    * soft deletes are enabled and the name of the deleted at column.
@@ -1248,7 +1601,7 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
    * @param attributes
    * @returns
    */
-  static hydrateRetrieved<TModel>(this: ModelStatic<TModel, PrismaDelegateLike>, attributes: Record<string, unknown>): Promise<TModel>;
+  static hydrateRetrieved<TModel>(this: ModelStatic<TModel, ModelQuerySchemaLike>, attributes: Record<string, unknown>): Promise<TModel>;
   /**
    * Hydrate multiple model instances and dispatch the retrieved lifecycle event for each.
    *
@@ -1256,7 +1609,7 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
    * @param attributes
    * @returns
    */
-  static hydrateManyRetrieved<TModel>(this: ModelStatic<TModel, PrismaDelegateLike>, attributes: Record<string, unknown>[]): Promise<TModel[]>;
+  static hydrateManyRetrieved<TModel>(this: ModelStatic<TModel, ModelQuerySchemaLike>, attributes: Record<string, unknown>[]): Promise<TModel[]>;
   /**
    * Fill the model's attributes from a plain object, using the
    * setAttribute method to ensure that mutators and casts are applied.
@@ -1272,7 +1625,7 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
    * @param key
    * @returns
    */
-  getAttribute<TKey extends keyof TAttributes & string>(key: TKey): TAttributes[TKey];
+  getAttribute<TSelf extends this, TKey extends string>(this: TSelf, key: TKey): ModelAttributeValue<TSelf, TAttributes, TKey>;
   getAttribute(key: string): unknown;
   /**
    * Set the value of an attribute, applying any set mutators or casts if defined.
@@ -1281,7 +1634,7 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
    * @param value
    * @returns
    */
-  setAttribute<TKey extends keyof TAttributes & string>(key: TKey, value: TAttributes[TKey]): this;
+  setAttribute<TSelf extends this, TKey extends string>(this: TSelf, key: TKey, value: ModelAttributeValue<TSelf, TAttributes, TKey>): this;
   setAttribute(key: string, value: unknown): this;
   /**
    * Save the model to the database.
@@ -1454,38 +1807,38 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
    * Define a belongs to many relationship.
    *
    * @param related
-   * @param throughDelegate
+  * @param throughTable
    * @param foreignPivotKey
    * @param relatedPivotKey
    * @param parentKey
    * @param relatedKey
    * @returns
    */
-  protected belongsToMany<TRelatedClass extends RelatedModelClass>(related: TRelatedClass, throughDelegate: string, foreignPivotKey: string, relatedPivotKey: string, parentKey?: string, relatedKey?: string): BelongsToManyRelation<this, InstanceType<TRelatedClass>>;
+  protected belongsToMany<TRelatedClass extends RelatedModelClass>(related: TRelatedClass, throughTable: string, foreignPivotKey: string, relatedPivotKey: string, parentKey?: string, relatedKey?: string): BelongsToManyRelation<this, InstanceType<TRelatedClass>>;
   /**
    * Define a has one through relationship.
    *
    * @param related
-   * @param throughDelegate
+  * @param throughTable
    * @param firstKey
    * @param secondKey
    * @param localKey
    * @param secondLocalKey
    * @returns
    */
-  protected hasOneThrough<TRelatedClass extends RelatedModelClass>(related: TRelatedClass, throughDelegate: string, firstKey: string, secondKey: string, localKey?: string, secondLocalKey?: string): HasOneThroughRelation<this, InstanceType<TRelatedClass>>;
+  protected hasOneThrough<TRelatedClass extends RelatedModelClass>(related: TRelatedClass, throughTable: string, firstKey: string, secondKey: string, localKey?: string, secondLocalKey?: string): HasOneThroughRelation<this, InstanceType<TRelatedClass>>;
   /**
    * Define a has many through relationship.
    *
    * @param related
-   * @param throughDelegate
+  * @param throughTable
    * @param firstKey
    * @param secondKey
    * @param localKey
    * @param secondLocalKey
    * @returns
    */
-  protected hasManyThrough<TRelatedClass extends RelatedModelClass>(related: TRelatedClass, throughDelegate: string, firstKey: string, secondKey: string, localKey?: string, secondLocalKey?: string): HasManyThroughRelation<this, InstanceType<TRelatedClass>>;
+  protected hasManyThrough<TRelatedClass extends RelatedModelClass>(related: TRelatedClass, throughTable: string, firstKey: string, secondKey: string, localKey?: string, secondLocalKey?: string): HasManyThroughRelation<this, InstanceType<TRelatedClass>>;
   /**
    * Define a polymorphic one to one relationship.
    *
@@ -1508,14 +1861,14 @@ declare abstract class Model<TSchema extends PrismaDelegateLike | Record<string,
    * Define a polymorphic many to many relationship.
    *
    * @param related
-   * @param throughDelegate
+  * @param throughTable
    * @param morphName
    * @param relatedPivotKey
    * @param parentKey
    * @param relatedKey
    * @returns
    */
-  protected morphToMany<TRelatedClass extends RelatedModelClass>(related: TRelatedClass, throughDelegate: string, morphName: string, relatedPivotKey: string, parentKey?: string, relatedKey?: string): MorphToManyRelation<this, InstanceType<TRelatedClass>>;
+  protected morphToMany<TRelatedClass extends RelatedModelClass>(related: TRelatedClass, throughTable: string, morphName: string, relatedPivotKey: string, parentKey?: string, relatedKey?: string): MorphToManyRelation<this, InstanceType<TRelatedClass>>;
   /**
    * Resolve a get mutator method for a given attribute key, if it exists.
    *
@@ -1643,7 +1996,7 @@ type Simplify<TValue> = { [TKey in keyof TValue]: TValue[TKey] } & {};
 type ConventionalAutoManagedKeys = 'id' | 'createdAt' | 'updatedAt' | 'deletedAt';
 type SingularKey<T extends string> = LowercaseString<T> extends `${infer Base}s` ? Base : LowercaseString<T>;
 type PluralKey<T extends string> = `${SingularKey<T>}s`;
-type PrismaClientDelegates = { [TKey in keyof PrismaClient as PrismaClient[TKey] extends PrismaDelegateLike ? TKey : never]: PrismaClient[TKey] };
+type PrismaClientDelegates = { [TKey in keyof PrismaClient as PrismaClient[TKey] extends ModelQuerySchemaLike ? TKey : never]: PrismaClient[TKey] };
 type DelegateFromPrismaClient<TKey extends string> = LowercaseString<TKey> extends keyof PrismaClientDelegates ? PrismaClientDelegates[LowercaseString<TKey>] : SingularKey<TKey> extends keyof PrismaClientDelegates ? PrismaClientDelegates[SingularKey<TKey>] : PluralKey<TKey> extends keyof PrismaClientDelegates ? PrismaClientDelegates[PluralKey<TKey>] : never;
 type AttributeScalarFilter<TValue> = Omit<PrismaLikeScalarFilter, 'equals' | 'not' | 'in' | 'notIn' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains' | 'startsWith' | 'endsWith'> & {
   equals?: TValue;
@@ -1669,7 +2022,7 @@ type RequiredCreateKeys<TAttributes extends Record<string, unknown>> = Exclude<{
 type AtLeastOne<TValue extends Record<string, unknown>> = { [TKey in keyof TValue]-?: Required<Pick<TValue, TKey>> & Partial<Omit<TValue, TKey>> }[keyof TValue];
 type AttributeCreateInput<TAttributes extends Record<string, unknown>> = Simplify<Pick<TAttributes, RequiredCreateKeys<TAttributes>> & Partial<Omit<TAttributes, RequiredCreateKeys<TAttributes>>>>;
 type AttributeUpdateInput<TAttributes extends Record<string, unknown>> = AtLeastOne<Partial<TAttributes>>;
-interface AttributeSchemaDelegate<TAttributes extends Record<string, unknown>> extends PrismaDelegateLike {
+interface AttributeQuerySchema<TAttributes extends Record<string, unknown>> extends ModelQuerySchemaLike {
   findMany: (args?: {
     where?: AttributeWhereInput<TAttributes>;
     include?: PrismaLikeInclude;
@@ -1703,11 +2056,27 @@ interface AttributeSchemaDelegate<TAttributes extends Record<string, unknown>> e
     where?: AttributeWhereInput<TAttributes>;
   }) => Promise<number>;
 }
-type DelegateForModelSchema<TSchema extends PrismaDelegateLike | Record<string, unknown> | string, TAttributes extends Record<string, unknown> = ModelAttributesOf<TSchema>> = TSchema extends PrismaDelegateLike ? TSchema : TSchema extends string ? DelegateFromPrismaClient<TSchema> extends PrismaDelegateLike ? DelegateFromPrismaClient<TSchema> : PrismaDelegateLike : AttributeSchemaDelegate<TAttributes>;
-type ModelAttributesOf<TSchema extends PrismaDelegateLike | Record<string, unknown> | string> = TSchema extends PrismaDelegateLike ? DelegateRow<TSchema> extends Record<string, unknown> ? DelegateRow<TSchema> : Record<string, any> : TSchema extends string ? DelegateFromPrismaClient<TSchema> extends PrismaDelegateLike ? DelegateRow<DelegateFromPrismaClient<TSchema>> extends Record<string, unknown> ? DelegateRow<DelegateFromPrismaClient<TSchema>> : Record<string, any> : Record<string, any> : TSchema extends Record<string, unknown> ? TSchema : Record<string, any>;
+type QuerySchemaForModel<TSchema extends ModelQuerySchemaLike | Record<string, unknown> | string, TAttributes extends Record<string, unknown> = ModelAttributesOf<TSchema>> = TSchema extends ModelQuerySchemaLike ? TSchema : TSchema extends string ? DelegateFromPrismaClient<TSchema> extends ModelQuerySchemaLike ? DelegateFromPrismaClient<TSchema> : ModelQuerySchemaLike : AttributeQuerySchema<TAttributes>;
+/**
+ * @deprecated Use AttributeQuerySchema instead.
+ */
+type AttributeSchemaDelegate<TAttributes extends Record<string, unknown>> = AttributeQuerySchema<TAttributes>;
+/**
+ * @deprecated Use QuerySchemaForModel instead.
+ */
+type DelegateForModelSchema<TSchema extends ModelQuerySchemaLike | Record<string, unknown> | string, TAttributes extends Record<string, unknown> = ModelAttributesOf<TSchema>> = QuerySchemaForModel<TSchema, TAttributes>;
+type ModelAttributesOf<TSchema extends ModelQuerySchemaLike | Record<string, unknown> | string> = TSchema extends ModelQuerySchemaLike ? QuerySchemaRow<TSchema> extends Record<string, unknown> ? QuerySchemaRow<TSchema> : Record<string, any> : TSchema extends string ? DelegateFromPrismaClient<TSchema> extends ModelQuerySchemaLike ? QuerySchemaRow<DelegateFromPrismaClient<TSchema>> extends Record<string, unknown> ? QuerySchemaRow<DelegateFromPrismaClient<TSchema>> : Record<string, any> : Record<string, any> : TSchema extends Record<string, unknown> ? TSchema : Record<string, any>;
 type ModelAttributes<TModel> = TModel extends Model<any, infer TAttributes> ? TAttributes : Record<string, any>;
-type ModelCreateData<TModel, TDelegate extends PrismaDelegateLike> = TModel extends Model<any, infer TAttributes> ? TDelegate extends AttributeSchemaDelegate<TAttributes> ? AttributeCreateInput<TAttributes> : DelegateCreateData<TDelegate> : DelegateCreateData<TDelegate>;
-type ModelUpdateData<TModel, TDelegate extends PrismaDelegateLike> = TModel extends Model<any, infer TAttributes> ? TDelegate extends AttributeSchemaDelegate<TAttributes> ? AttributeUpdateInput<TAttributes> : DelegateUpdateData<TDelegate> : DelegateUpdateData<TDelegate>;
+type BaseModelInstance = Model<any, any>;
+type ModelDeclaredAttributeKey<TModel> = { [TKey in keyof TModel & string]: TKey extends keyof BaseModelInstance ? never : TModel[TKey] extends ((...args: any[]) => any) ? never : TKey }[keyof TModel & string];
+type RelationshipResultProvider<TResult = unknown> = {
+  getResults: (...args: any[]) => Promise<TResult>;
+};
+type ModelRelationshipKey<TModel> = { [TKey in keyof TModel & string]: TKey extends keyof BaseModelInstance ? never : TModel[TKey] extends ((...args: any[]) => infer TReturn) ? Parameters<TModel[TKey]> extends [] ? TReturn extends RelationshipResultProvider<any> ? TKey : never : never : never }[keyof TModel & string];
+type ModelRelationshipResult<TModel, TKey extends ModelRelationshipKey<TModel>> = TModel[TKey] extends ((...args: any[]) => infer TReturn) ? TReturn extends RelationshipResultProvider<infer TResult> ? TResult : never : never;
+type ModelAttributeValue<TModel, TAttributes extends Record<string, unknown>, TKey extends string> = TKey extends ModelRelationshipKey<TModel> ? ModelRelationshipResult<TModel, TKey> : TKey extends ModelDeclaredAttributeKey<TModel> ? TModel[TKey] : TKey extends keyof TAttributes & string ? TAttributes[TKey] : unknown;
+type ModelCreateData<TModel, TDelegate extends ModelQuerySchemaLike> = TModel extends Model<any, infer TAttributes> ? TDelegate extends AttributeQuerySchema<TAttributes> ? AttributeCreateInput<TAttributes> : QuerySchemaCreateData<TDelegate> : QuerySchemaCreateData<TDelegate>;
+type ModelUpdateData<TModel, TDelegate extends ModelQuerySchemaLike> = TModel extends Model<any, infer TAttributes> ? TDelegate extends AttributeQuerySchema<TAttributes> ? AttributeUpdateInput<TAttributes> : QuerySchemaUpdateData<TDelegate> : QuerySchemaUpdateData<TDelegate>;
 type RelatedModelClass<TInstance = unknown> = (abstract new (attributes?: Record<string, unknown>) => TInstance) & RelationshipModelStatic;
 type GlobalScope = (query: QueryBuilder<any, any>) => QueryBuilder<any, any> | void;
 type ModelEventName = 'retrieved' | 'saving' | 'saved' | 'creating' | 'created' | 'updating' | 'updated' | 'deleting' | 'deleted' | 'restoring' | 'restored' | 'forceDeleting' | 'forceDeleted';
@@ -1810,7 +2179,7 @@ declare class Paginator<T> {
  * @author Legacy (3m1n3nc3)
  * @since 0.1.0
  */
-declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = PrismaDelegateLike> {
+declare class QueryBuilder<TModel, TDelegate extends ModelQuerySchemaLike = ModelQuerySchemaLike> {
   private readonly model;
   private readonly adapter?;
   private queryWhere?;
@@ -1840,28 +2209,28 @@ declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = Prisma
    * @param where
    * @returns
    */
-  where(where: DelegateWhere<TDelegate>): this;
+  where(where: QuerySchemaWhere<TDelegate>): this;
   /**
    * Adds an OR where clause to the query.
    *
    * @param where
    * @returns
    */
-  orWhere(where: DelegateWhere<TDelegate>): this;
+  orWhere(where: QuerySchemaWhere<TDelegate>): this;
   /**
    * Adds a NOT where clause to the query.
    *
    * @param where
    * @returns
    */
-  whereNot(where: DelegateWhere<TDelegate>): this;
+  whereNot(where: QuerySchemaWhere<TDelegate>): this;
   /**
    * Adds an OR NOT where clause to the query.
    *
    * @param where
    * @returns
    */
-  orWhereNot(where: DelegateWhere<TDelegate>): this;
+  orWhereNot(where: QuerySchemaWhere<TDelegate>): this;
   /**
    * Adds a null check for a key.
    *
@@ -1933,6 +2302,30 @@ declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = Prisma
    * @returns
    */
   whereNotIn<TKey extends keyof ModelAttributes<TModel> & string>(key: TKey, values: ModelAttributes<TModel>[TKey][]): this;
+  /**
+   * Adds a string contains clause for a single attribute key.
+   *
+   * @param key
+   * @param value
+   * @returns
+   */
+  whereLike<TKey extends keyof ModelAttributes<TModel> & string>(key: TKey, value: Extract<ModelAttributes<TModel>[TKey], string>): this;
+  /**
+   * Adds a string starts-with clause for a single attribute key.
+   *
+   * @param key
+   * @param value
+   * @returns
+   */
+  whereStartsWith<TKey extends keyof ModelAttributes<TModel> & string>(key: TKey, value: Extract<ModelAttributes<TModel>[TKey], string>): this;
+  /**
+   * Adds a string ends-with clause for a single attribute key.
+   *
+   * @param key
+   * @param value
+   * @returns
+   */
+  whereEndsWith<TKey extends keyof ModelAttributes<TModel> & string>(key: TKey, value: Extract<ModelAttributes<TModel>[TKey], string>): this;
   /**
    * Adds a strongly-typed OR NOT IN where clause for a single attribute key.
    *
@@ -1983,7 +2376,7 @@ declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = Prisma
    * @param orderBy
    * @returns
    */
-  orderBy(orderBy: DelegateOrderBy<TDelegate>): this;
+  orderBy(orderBy: QuerySchemaOrderBy<TDelegate>): this;
   /**
    * Puts the query results in random order.
    *
@@ -2018,7 +2411,7 @@ declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = Prisma
    * @param include
    * @returns
    */
-  include(include: DelegateInclude<TDelegate>): this;
+  include(include: QuerySchemaInclude<TDelegate>): this;
   /**
    * Adds eager loading for the specified relations.
    * This will merge with any existing include clause.
@@ -2215,7 +2608,7 @@ declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = Prisma
    * @param select
    * @returns
    */
-  select(select: DelegateSelect<TDelegate>): this;
+  select(select: QuerySchemaSelect<TDelegate>): this;
   /**
    * Adds a skip clause to the query for pagination.
    * This will overwrite any existing skip clause.
@@ -2245,6 +2638,13 @@ declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = Prisma
    * @returns
    */
   limit(value: number): this;
+  /**
+   * Returns a representation of the query that can be used for debugging or logging purposes.
+   *
+   * @param operation
+   * @returns
+   */
+  inspect(operation?: Extract<AdapterQueryOperation, 'select' | 'selectOne' | 'count' | 'exists'>): AdapterQueryInspection | null;
   /**
    * Sets offset/limit for a 1-based page.
    *
@@ -2389,6 +2789,7 @@ declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = Prisma
    * @returns
    */
   updateOrInsert(attributes: Record<string, unknown>, values?: Record<string, unknown> | ((exists: boolean) => Record<string, unknown> | Promise<Record<string, unknown>>)): Promise<boolean>;
+  private shouldFallbackUpdateOrInsertUpsert;
   /**
    * Insert new records or update existing records by one or more unique keys.
    *
@@ -2399,12 +2800,19 @@ declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = Prisma
    */
   upsert(values: Array<Record<string, unknown>>, uniqueBy: string | string[], update?: string[] | null): Promise<number>;
   /**
-   * Deletes records matching the current query constraints and returns
-   * the deleted record(s) as model instance(s).
+   * Deletes the first record matching the current query constraints and returns
+   * it as a hydrated model instance. Returns null when no record matches.
+   *
+   * @returns
+   */
+  delete(): Promise<TModel | null>;
+  /**
+   * Deletes the first record matching the current query constraints and throws
+   * when no record matches.
    *
    * @returns
    */
-  delete(): Promise<TModel>;
+  deleteOrFail(): Promise<TModel>;
   private tryBuildInsertSpec;
   private tryBuildInsertManySpec;
   private tryBuildUpsertSpec;
@@ -2529,12 +2937,23 @@ declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = Prisma
   private normalizeQuerySelect;
   private normalizeQueryOrderBy;
   private cloneRelationLoads;
+  private mergeRelationLoadPlans;
+  private relationLoadPlansToEagerLoadMap;
+  private getRelationLoadSoftDeleteMode;
+  applyRelationLoadPlan(plan: RelationLoadPlan): this;
+  loadIntoModels(models: TModel[]): Promise<void>;
+  /**
+   * Attempts to build relation load plans for the adapter based on the eager loads specified in the query builder.
+   *
+   * @returns an array of RelationLoadPlan if successful, or null if the eager loads contain constraints that cannot be represented in a way compatible with adapter-based loading.
+   */
+  private tryBuildAdapterRelationLoadPlans;
   private eagerLoadModels;
   private normalizeRelationLoadSelect;
   private normalizeRelationLoadOrderBy;
   private normalizeRelationLoads;
   private appendQueryCondition;
-  private toDelegateWhere;
+  private toQuerySchemaWhere;
   private buildSoftDeleteQueryCondition;
   private buildQueryWhereCondition;
   private tryBuildQuerySelectColumns;
@@ -2588,6 +3007,9 @@ declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = Prisma
   private canExecuteRelationFiltersInAdapter;
   private canExecuteRelationAggregatesInAdapter;
   private canExecuteRelationFeaturesInAdapter;
+  private shouldUseCompatibilityRelationFallback;
+  private hasUncompilableSqlRelationFilters;
+  private hasUncompilableSqlRelationAggregates;
   private tryBuildRelationFilterSpecs;
   private tryBuildRelationAggregateSpecs;
   private tryBuildRelationConstraintWhere;
@@ -2604,17 +3026,16 @@ declare class QueryBuilder<TModel, TDelegate extends PrismaDelegateLike = Prisma
 }
 //#endregion
 //#region src/types/ModelStatic.d.ts
-interface ModelStatic<TModel, TDelegate extends PrismaDelegateLike = PrismaDelegateLike> {
-  new (attributes?: DelegateRow<TDelegate> extends Record<string, unknown> ? DelegateRow<TDelegate> : Record<string, unknown>): TModel;
+interface ModelStatic<TModel, TDelegate extends ModelQuerySchemaLike = ModelQuerySchemaLike> {
+  new (attributes?: QuerySchemaRow<TDelegate> extends Record<string, unknown> ? QuerySchemaRow<TDelegate> : Record<string, unknown>): TModel;
   query: () => QueryBuilder<TModel, TDelegate>;
-  hydrate: (attributes: DelegateRow<TDelegate> extends Record<string, unknown> ? DelegateRow<TDelegate> : Record<string, unknown>) => TModel;
-  hydrateMany: (attributes: (DelegateRow<TDelegate> extends Record<string, unknown> ? DelegateRow<TDelegate> : Record<string, unknown>)[]) => TModel[];
-  hydrateRetrieved: (attributes: DelegateRow<TDelegate> extends Record<string, unknown> ? DelegateRow<TDelegate> : Record<string, unknown>) => Promise<TModel>;
-  hydrateManyRetrieved: (attributes: (DelegateRow<TDelegate> extends Record<string, unknown> ? DelegateRow<TDelegate> : Record<string, unknown>)[]) => Promise<TModel[]>;
+  hydrate: (attributes: QuerySchemaRow<TDelegate> extends Record<string, unknown> ? QuerySchemaRow<TDelegate> : Record<string, unknown>) => TModel;
+  hydrateMany: (attributes: (QuerySchemaRow<TDelegate> extends Record<string, unknown> ? QuerySchemaRow<TDelegate> : Record<string, unknown>)[]) => TModel[];
+  hydrateRetrieved: (attributes: QuerySchemaRow<TDelegate> extends Record<string, unknown> ? QuerySchemaRow<TDelegate> : Record<string, unknown>) => Promise<TModel>;
+  hydrateManyRetrieved: (attributes: (QuerySchemaRow<TDelegate> extends Record<string, unknown> ? QuerySchemaRow<TDelegate> : Record<string, unknown>)[]) => Promise<TModel[]>;
   getAdapter: () => DatabaseAdapter | undefined;
   getColumnMap: () => Record<string, string>;
   getColumnName: (attribute: string) => string;
-  getDelegate: (delegate?: string) => TDelegate;
   getModelMetadata: () => ModelMetadata;
   getPrimaryKey: () => string;
   getRelationMetadata: (name: string) => RelationMetadata | null;
@@ -2629,7 +3050,6 @@ interface RelationshipModelStatic {
   getAdapter: () => DatabaseAdapter | undefined;
   getColumnMap: () => Record<string, string>;
   getColumnName: (attribute: string) => string;
-  getDelegate: (delegate?: string) => PrismaDelegateLike;
   getModelMetadata: () => ModelMetadata;
   getPrimaryKey: () => string;
   getRelationMetadata: (name: string) => RelationMetadata | null;
@@ -2710,6 +3130,7 @@ interface RelationFilterSpec {
 interface RelationLoadPlan {
   relation: string;
   constraint?: QueryCondition;
+  softDeleteMode?: SoftDeleteQueryMode;
   orderBy?: QueryOrderBy[];
   limit?: number;
   offset?: number;
@@ -2777,6 +3198,47 @@ interface RelationLoadSpec<TModel = unknown> {
   models: TModel[];
   relations: RelationLoadPlan[];
 }
+type AdapterQueryOperation = 'select' | 'selectOne' | 'count' | 'exists' | 'insert' | 'insertMany' | 'upsert' | 'update' | 'updateFirst' | 'updateMany' | 'delete' | 'deleteFirst' | 'deleteMany';
+type AdapterInspectionRequest<TModel = unknown> = {
+  operation: 'select';
+  spec: SelectSpec<TModel>;
+} | {
+  operation: 'selectOne';
+  spec: SelectSpec<TModel>;
+} | {
+  operation: 'count';
+  spec: AggregateSpec<TModel>;
+} | {
+  operation: 'exists';
+  spec: SelectSpec<TModel>;
+} | {
+  operation: 'insert';
+  spec: InsertSpec<TModel>;
+} | {
+  operation: 'insertMany';
+  spec: InsertManySpec<TModel>;
+} | {
+  operation: 'upsert';
+  spec: UpsertSpec<TModel>;
+} | {
+  operation: 'update';
+  spec: UpdateSpec<TModel>;
+} | {
+  operation: 'updateFirst';
+  spec: UpdateSpec<TModel>;
+} | {
+  operation: 'updateMany';
+  spec: UpdateManySpec<TModel>;
+} | {
+  operation: 'delete';
+  spec: DeleteSpec<TModel>;
+} | {
+  operation: 'deleteFirst';
+  spec: DeleteSpec<TModel>;
+} | {
+  operation: 'deleteMany';
+  spec: DeleteManySpec<TModel>;
+};
 interface AdapterTransactionContext {
   isolationLevel?: string;
   readOnly?: boolean;
@@ -2812,6 +3274,7 @@ interface DatabaseAdapter {
   count: <TModel = unknown>(spec: AggregateSpec<TModel>) => Promise<number>;
   exists?: <TModel = unknown>(spec: SelectSpec<TModel>) => Promise<boolean>;
   loadRelations?: <TModel = unknown>(spec: RelationLoadSpec<TModel>) => Promise<void>;
+  inspectQuery?: <TModel = unknown>(request: AdapterInspectionRequest<TModel>) => AdapterQueryInspection | null;
   introspectModels?: (options?: AdapterModelIntrospectionOptions) => Promise<AdapterModelStructure[]>;
   executeSchemaOperations?: (operations: SchemaOperation[]) => Promise<void>;
   resetDatabase?: () => Promise<void>;
@@ -2843,6 +3306,7 @@ declare class KyselyDatabaseAdapter implements DatabaseAdapter {
   private resolveSchemaColumnName;
   private resolveSchemaIndexName;
   private resolveSchemaForeignKeyName;
+  private resolveSchemaEnumName;
   private resolveSchemaColumnType;
   private resolveSchemaColumnDefault;
   private shouldUseIdentity;
@@ -2869,6 +3333,7 @@ declare class KyselyDatabaseAdapter implements DatabaseAdapter {
   private buildOrderBy;
   private buildConditionValueList;
   private buildComparisonCondition;
+  private buildRawWhereCondition;
   private buildWhereCondition;
   private buildWhereClause;
   private buildPaginationClause;
@@ -2885,7 +3350,17 @@ declare class KyselyDatabaseAdapter implements DatabaseAdapter {
   private buildRelationAggregateSelectList;
   private buildCombinedWhereClause;
   private buildSingleRowTargetCte;
-  private assertNoRelationLoads;
+  private isEagerLoadableModel;
+  private toEagerLoadConstraint;
+  private toEagerLoadMap;
+  private buildSelectStatement;
+  private buildCountStatement;
+  private buildExistsStatement;
+  private compileInspection;
+  private emitDebugQuery;
+  private wrapExecutionError;
+  private executeWithDebug;
+  inspectQuery<TModel = unknown>(request: AdapterInspectionRequest<TModel>): AdapterQueryInspection | null;
   /**
    * Selects records from the database matching the specified criteria and returns
    * them as an array of database rows.
@@ -2981,6 +3456,13 @@ declare class KyselyDatabaseAdapter implements DatabaseAdapter {
    * @returns     A promise that resolves to a boolean indicating whether any records match the criteria.
    */
   exists<TModel = unknown>(spec: SelectSpec<TModel>): Promise<boolean>;
+  /**
+   * Loads relations for the given models based on the specified relation load plans.
+   *
+   * @param spec  The specification defining the models and their relations to be loaded.
+   * @returns
+   */
+  loadRelations<TModel = unknown>(spec: RelationLoadSpec<TModel>): Promise<void>;
   introspectModels(options?: AdapterModelIntrospectionOptions): Promise<AdapterModelStructure[]>;
   executeSchemaOperations(operations: SchemaOperation[]): Promise<void>;
   resetDatabase(): Promise<void>;
@@ -3032,13 +3514,18 @@ declare class PrismaDatabaseAdapter implements DatabaseAdapter {
   private toComparisonWhere;
   private toQueryWhere;
   private buildFindArgs;
+  private emitDebugQuery;
+  private wrapExecutionError;
+  private runWithDebug;
+  inspectQuery<TModel = unknown>(_request: AdapterInspectionRequest<TModel>): AdapterQueryInspection | null;
   private toQueryInclude;
   introspectModels(options?: AdapterModelIntrospectionOptions): Promise<AdapterModelStructure[]>;
   private resolveDelegate;
   /**
-   * @todo Implement relationLoads by performing separate queries and merging results
-   * in-memory, since Prisma does not support nested reads with constraints, ordering, or
-   * pagination on related models as of now.
+   * Prisma can translate relation load plans on direct select/selectOne calls into
+   * Prisma include/select arguments, but the adapter does not advertise the
+   * adapter-owned batch relation load seam. QueryBuilder eager loads therefore stay
+   * on Arkorm's generic relation loader on the Prisma compatibility path.
    *
    * @param spec
    * @returns
@@ -3184,6 +3671,7 @@ declare class CliApp {
    * @returns The entire configuration object or the value of the specified key
    */
   getConfig: GetUserConfig;
+  private isUsingPrismaAdapter;
   /**
    * Utility to ensure directory exists
    *
@@ -3298,13 +3786,14 @@ declare class CliApp {
     factory?: boolean;
     seeder?: boolean;
     migration?: boolean;
+    pivot?: boolean;
     all?: boolean;
   }): {
     model: {
       name: string;
       path: string;
     };
-    prisma: {
+    prisma?: {
       path: string;
       updated: boolean;
     };
@@ -3323,11 +3812,11 @@ declare class CliApp {
   };
   /**
    * Ensure that the Prisma schema has a model entry for the given model
-   * and delegate names.
+   * and table names.
    * If the entry does not exist, it will be created with a default `id` field.
    *
    * @param modelName The name of the model to ensure in the Prisma schema.
-   * @param delegateName The name of the delegate (table) to ensure in the Prisma schema.
+   * @param tableName The table name to ensure in the Prisma schema.
    */
   private ensurePrismaModelEntry;
   /**
@@ -4125,11 +4614,12 @@ declare class DB {
   static setAdapter(adapter?: DatabaseAdapter): void;
   static getAdapter(): DatabaseAdapter | undefined;
   getAdapter(): DatabaseAdapter | undefined;
-  static table<TRow extends Record<string, unknown> = Record<string, unknown>>(table: string, options?: DatabaseTableOptions): QueryBuilder<TRow, PrismaDelegateLike>;
-  table<TRow extends Record<string, unknown> = Record<string, unknown>>(table: string, options?: DatabaseTableOptions): QueryBuilder<TRow, PrismaDelegateLike>;
+  static table<TRow extends Record<string, unknown> = Record<string, unknown>>(table: string, options?: DatabaseTableOptions): QueryBuilder<TRow, ModelQuerySchemaLike>;
+  table<TRow extends Record<string, unknown> = Record<string, unknown>>(table: string, options?: DatabaseTableOptions): QueryBuilder<TRow, ModelQuerySchemaLike>;
   static transaction<TResult>(callback: (db: DB) => TResult | Promise<TResult>, context?: AdapterTransactionContext): Promise<TResult>;
   transaction<TResult>(callback: (db: DB) => TResult | Promise<TResult>, context?: AdapterTransactionContext): Promise<TResult>;
   private static createTableModel;
+  private static resolvePersistedTableMetadata;
 }
 //#endregion
 //#region src/Exceptions/ArkormException.d.ts
@@ -4189,6 +4679,16 @@ declare class QueryConstraintException extends ArkormException {
   constructor(message: string, context?: ArkormErrorContext);
 }
 //#endregion
+//#region src/Exceptions/QueryExecutionException.d.ts
+interface QueryExecutionExceptionContext extends ArkormErrorContext {
+  inspection?: AdapterQueryInspection | null;
+}
+declare class QueryExecutionException extends ArkormException {
+  readonly inspection?: AdapterQueryInspection | null;
+  constructor(message?: string, context?: QueryExecutionExceptionContext);
+  getInspection(): AdapterQueryInspection | null | undefined;
+}
+//#endregion
 //#region src/Exceptions/RelationResolutionException.d.ts
 declare class RelationResolutionException extends ArkormException {
   constructor(message: string, context?: ArkormErrorContext);
@@ -4601,21 +5101,29 @@ declare class PrimaryKeyGenerationPlanner {
  * @returns The same configuration object.
  */
 declare const defineConfig: (config: ArkormConfig) => ArkormConfig;
+/**
+ * Bind a database adapter instance to an array of models that support adapter binding.
+ *
+ * @param adapter
+ * @param models
+ * @returns
+ */
 declare const bindAdapterToModels: (adapter: DatabaseAdapter, models: AdapterBindableModel[]) => DatabaseAdapter;
 /**
  * Get the user-provided ArkORM configuration.
  *
+ * @param key Optional specific configuration key to retrieve. If omitted, the entire configuration object is returned.
  * @returns The user-provided ArkORM configuration object.
  */
 declare const getUserConfig: GetUserConfig;
 /**
- * Configure the ArkORM runtime with the provided Prisma client resolver and
- * delegate mapping resolver.
+ * Configure the ArkORM runtime with the provided runtime client resolver and
+ * adapter-first options.
  *
- * @param prisma
- * @param mapping
+ * @param client
+ * @param options
  */
-declare const configureArkormRuntime: (prisma?: ClientResolver, options?: Omit<ArkormConfig, "prisma">) => void;
+declare const configureArkormRuntime: (client?: ClientResolver, options?: Omit<ArkormConfig, "prisma">) => void;
 /**
  * Reset the ArkORM runtime configuration.
  * This is primarily intended for testing purposes.
@@ -4637,17 +5145,22 @@ declare const loadArkormConfig: () => Promise<void>;
 declare const ensureArkormConfigLoading: () => void;
 declare const getDefaultStubsPath: () => string;
 /**
- * Get the runtime Prisma client.
+ * Get the runtime compatibility client.
  * This function will trigger the loading of the ArkORM configuration if
  * it hasn't already been loaded.
  *
  * @returns
  */
-declare const getRuntimePrismaClient: () => PrismaClientLike | undefined;
+declare const getRuntimeClient: () => RuntimeClientLike | undefined;
+/**
+ * @deprecated Use getRuntimeClient instead.
+ */
+declare const getRuntimePrismaClient: () => RuntimeClientLike | undefined;
 declare const getRuntimeAdapter: () => DatabaseAdapter | undefined;
-declare const getActiveTransactionClient: () => PrismaClientLike | undefined;
-declare const isTransactionCapableClient: (value: unknown) => value is PrismaTransactionCapableClient;
-declare const runArkormTransaction: <TResult>(callback: PrismaTransactionCallback<TResult>, options?: PrismaTransactionOptions) => Promise<TResult>;
+declare const getActiveTransactionClient: () => RuntimeClientLike | undefined;
+declare const getActiveTransactionAdapter: () => DatabaseAdapter | undefined;
+declare const isTransactionCapableClient: (value: unknown) => value is TransactionCapableClient;
+declare const runArkormTransaction: <TResult>(callback: TransactionCallback<TResult>, options?: TransactionOptions, preferredAdapter?: DatabaseAdapter) => Promise<TResult>;
 /**
  * Get the configured pagination URL driver factory from runtime config.
  *
@@ -4660,39 +5173,45 @@ declare const getRuntimePaginationURLDriverFactory: () => PaginationURLDriverFac
  * @returns
  */
 declare const getRuntimePaginationCurrentPageResolver: () => PaginationCurrentPageResolver | undefined;
+declare const getRuntimeDebugHandler: () => ArkormDebugHandler | undefined;
+declare const emitRuntimeDebugEvent: (event: ArkormDebugEvent) => void;
 /**
- * Check if a given value is a Prisma delegate-like object
+ * Check if a given value matches Arkorm's query-schema contract
  * by verifying the presence of common delegate methods.
  *
  * @param value The value to check.
- * @returns True if the value is a Prisma delegate-like object, false otherwise.
+ * @returns True if the value matches the query-schema contract, false otherwise.
  */
-declare const isDelegateLike: (value: unknown) => value is PrismaDelegateLike;
+declare const isQuerySchemaLike: (value: unknown) => value is ModelQuerySchemaLike;
+/**
+ * @deprecated Use isQuerySchemaLike instead.
+ */
+declare const isDelegateLike: (value: unknown) => value is ModelQuerySchemaLike;
 //#endregion
 //#region src/helpers/prisma.d.ts
-type PrismaDelegateMap<TClient extends PrismaClientLike> = { [K in keyof TClient as TClient[K] extends PrismaDelegateLike ? K : never]: TClient[K] extends PrismaDelegateLike ? TClient[K] : never };
+type PrismaDelegateMap<TClient extends RuntimeClientLike> = { [K in keyof TClient as TClient[K] extends ModelQuerySchemaLike ? K : never]: TClient[K] extends ModelQuerySchemaLike ? TClient[K] : never };
 /**
- * Create an adapter to convert a Prisma client instance into a format
- * compatible with ArkORM's expectations.
+ * Compatibility-only helper that exposes Prisma query schemas as a plain object map.
+ * It is retained for migration support and tests, not as a supported runtime bootstrap path.
  *
  * @deprecated Prefer createPrismaDatabaseAdapter(prisma) for runtime usage.
  *
  * @param prisma The Prisma client instance to adapt.
  * @param mapping An optional mapping of Prisma delegate names to ArkORM delegate names.
- * @returns A record of adapted Prisma delegates compatible with ArkORM.
+ * @returns A record of adapted Prisma compatibility query schemas.
  */
-declare function createPrismaAdapter(prisma: PrismaClientLike): Record<string, PrismaDelegateLike>;
+declare function createPrismaAdapter(prisma: RuntimeClientLike): Record<string, ModelQuerySchemaLike>;
 /**
- * Create a delegate mapping record for Model.setClient() from a Prisma client.
+ * Compatibility-only helper for legacy delegate-map bootstrapping during migration.
  *
- * @deprecated Prefer createPrismaDatabaseAdapter(prisma, mapping) and bind the
- * resulting adapter with Model.setAdapter(...).
+ * @deprecated Prefer createPrismaDatabaseAdapter(prisma, mapping). Direct delegate-map
+ * bootstrapping is no longer part of the supported runtime path.
  *
  * @param prisma The Prisma client instance.
  * @param mapping Optional mapping of Arkormˣ delegate names to Prisma delegate names.
- * @returns A delegate map keyed by Arkormˣ delegate names.
+ * @returns A compatibility map keyed by Arkormˣ query-schema names.
  */
-declare function createPrismaDelegateMap(prisma: PrismaClientLike, mapping?: PrismaDelegateNameMapping): Record<string, PrismaDelegateLike>;
+declare function createPrismaDelegateMap(prisma: RuntimeClientLike, mapping?: PrismaDelegateNameMapping): Record<string, ModelQuerySchemaLike>;
 /**
  * Infer the Prisma delegate name for a given model name using a simple convention.
  *
@@ -4701,10 +5220,28 @@ declare function createPrismaDelegateMap(prisma: PrismaClientLike, mapping?: Pri
  */
 declare function inferDelegateName(modelName: string): string;
 //#endregion
+//#region src/helpers/runtime-compatibility.d.ts
+declare const getRuntimeCompatibilityAdapter: (preferredClient?: RuntimeClientLike) => DatabaseAdapter | undefined;
+declare const resolveRuntimeCompatibilityQuerySchema: (candidates: string[], preferredClient?: RuntimeClientLike) => ModelQuerySchemaLike | undefined;
+declare const resolveRuntimeCompatibilityQuerySchemaOrThrow: <TSchema extends ModelQuerySchemaLike = ModelQuerySchemaLike>(key: string, candidates: string[], modelName: string, preferredClient?: RuntimeClientLike) => TSchema;
+//#endregion
 //#region src/helpers/runtime-module-loader.d.ts
 declare class RuntimeModuleLoader {
   static load<T = unknown>(filePath: string): Promise<T>;
-  static loadSync<T = unknown>(filePath: string): T;
+}
+//#endregion
+//#region src/PivotModel.d.ts
+/**
+ * Base pivot class that all pivot models should extend.
+ *
+ * @template TModel The type of the model extending this base class.
+ *
+ * @author Legacy (3m1n3nc3)
+ * @since 2.0.0-next.18
+ */
+declare class PivotModel extends Model {
+  protected readonly attributes: Record<string, unknown>;
+  constructor(attributes?: Record<string, unknown>);
 }
 //#endregion
 //#region src/URLDriver.d.ts
@@ -4725,4 +5262,4 @@ declare class URLDriver {
   url(page: number): string;
 }
 //#endregion
-export { AdapterBindableModel, AdapterCapabilities, AdapterCapability, AdapterModelFieldStructure, AdapterModelIntrospectionOptions, AdapterModelStructure, AdapterTransactionContext, AggregateOperation, AggregateSelection, AggregateSpec, AppliedMigrationEntry, AppliedMigrationRun, AppliedMigrationsState, ArkormBootContext, ArkormCollection, ArkormConfig, ArkormErrorContext, ArkormException, Attribute, AttributeCreateInput, AttributeOptions, AttributeOrderBy, AttributeSchemaDelegate, AttributeSelect, AttributeUpdateInput, AttributeWhereInput, BelongsToManyRelationMetadata, BelongsToRelationMetadata, CastDefinition, CastHandler, CastMap, CastType, CliApp, ClientResolver, ColumnMap, DB, DatabaseAdapter, DatabasePrimitive, DatabaseRow, DatabaseRows, DatabaseTableOptions, DatabaseValue, DelegateCreateData, DelegateFindManyArgs, DelegateForModelSchema, DelegateInclude, DelegateOrderBy, DelegateRow, DelegateRows, DelegateSelect, DelegateUniqueWhere, DelegateUpdateArgs, DelegateUpdateData, DelegateWhere, DeleteManySpec, DeleteSpec, EagerLoadConstraint, EagerLoadMap, EnumBuilder, FactoryAttributes, FactoryDefinition, FactoryModelConstructor, FactoryState, ForeignKeyBuilder, GenerateMigrationOptions, GeneratedMigrationFile, GetUserConfig, GlobalScope, HasManyRelationMetadata, HasManyThroughRelationMetadata, HasOneRelationMetadata, HasOneThroughRelationMetadata, InitCommand, InlineFactory, InsertManySpec, InsertSpec, KyselyDatabaseAdapter, LengthAwarePaginator, MIGRATION_BRAND, MakeFactoryCommand, MakeMigrationCommand, MakeModelCommand, MakeSeederCommand, MigrateCommand, MigrateFreshCommand, MigrateRollbackCommand, Migration, MigrationClass, MigrationHistoryCommand, MigrationInstanceLike, MissingDelegateException, Model, ModelAttributes, ModelAttributesOf, ModelCreateData, ModelEventDispatcher, ModelEventHandler, ModelEventHandlerConstructor, ModelEventListener, ModelEventName, ModelFactory, ModelLifecycleState, ModelMetadata, ModelNotFoundException, ModelStatic, ModelUpdateData, ModelsSyncCommand, MorphManyRelationMetadata, MorphOneRelationMetadata, MorphToManyRelationMetadata, PRISMA_ENUM_MEMBER_REGEX, PRISMA_ENUM_REGEX, PRISMA_MODEL_REGEX, PaginationCurrentPageResolver, PaginationMeta, PaginationOptions, PaginationURLDriver, PaginationURLDriverFactory, Paginator, PersistedColumnMappingsState, PersistedMetadataFeatures, PersistedPrimaryKeyGeneration, PersistedTableMetadata, PersistedTimestampColumn, PrimaryKeyGeneration, PrimaryKeyGenerationPlanner, PrismaClientLike, PrismaDatabaseAdapter, PrismaDelegateLike, PrismaDelegateMap, PrismaDelegateNameMapping, PrismaFindManyArgsLike, PrismaLikeInclude, PrismaLikeOrderBy, PrismaLikeScalarFilter, PrismaLikeSelect, PrismaLikeSortOrder, PrismaLikeWhereInput, PrismaMigrationWorkflowOptions, PrismaSchemaSyncOptions, PrismaTransactionCallback, PrismaTransactionCapableClient, PrismaTransactionOptions, QueryBuilder, QueryComparisonCondition, QueryComparisonOperator, QueryCondition, QueryConstraintException, QueryGroupCondition, QueryLogicalOperator, QueryNotCondition, QueryOrderBy, QueryRawCondition, QuerySelectColumn, QueryTarget, RelatedModelClass, RelationAggregateSpec, RelationColumnLookupSpec, RelationConstraint, RelationDefaultResolver, RelationDefaultValue, RelationFilterSpec, RelationLoadPlan, RelationLoadSpec, RelationMetadata, RelationMetadataProvider, RelationMetadataType, RelationResolutionException, RelationTableLookupSpec, RelationshipModelStatic, RuntimeModuleLoader, SEEDER_BRAND, SchemaBuilder, SchemaColumn, SchemaColumnType, SchemaForeignKey, SchemaForeignKeyAction, SchemaIndex, SchemaOperation, SchemaTableAlterOperation, SchemaTableCreateOperation, SchemaTableDropOperation, ScopeNotDefinedException, SeedCommand, Seeder, SeederCallArgument, SeederConstructor, SeederInput, SelectSpec, Serializable, SimplePaginationMeta, SoftDeleteConfig, SoftDeleteQueryMode, SortDirection, TableBuilder, TimestampColumnBehavior, URLDriver, UniqueConstraintResolutionException, UnsupportedAdapterFeatureException, UpdateManySpec, UpdateSpec, UpsertSpec, applyAlterTableOperation, applyCreateTableOperation, applyDropTableOperation, applyMigrationRollbackToDatabase, applyMigrationRollbackToPrismaSchema, applyMigrationToDatabase, applyMigrationToPrismaSchema, applyOperationsToPersistedColumnMappingsState, applyOperationsToPrismaSchema, bindAdapterToModels, buildEnumBlock, buildFieldLine, buildIndexLine, buildInverseRelationLine, buildMigrationIdentity, buildMigrationRunId, buildMigrationSource, buildModelBlock, buildRelationLine, computeMigrationChecksum, configureArkormRuntime, createEmptyAppliedMigrationsState, createEmptyPersistedColumnMappingsState, createKyselyAdapter, createMigrationTimestamp, createPrismaAdapter, createPrismaCompatibilityAdapter, createPrismaDatabaseAdapter, createPrismaDelegateMap, defineConfig, defineFactory, deleteAppliedMigrationsStateFromStore, deletePersistedColumnMappingsState, deriveCollectionFieldName, deriveInverseRelationAlias, deriveRelationAlias, deriveRelationFieldName, deriveSingularFieldName, ensureArkormConfigLoading, escapeRegex, findAppliedMigration, findEnumBlock, findModelBlock, formatDefaultValue, formatEnumDefaultValue, formatRelationAction, generateMigrationFile, getActiveTransactionClient, getDefaultStubsPath, getLastMigrationRun, getLatestAppliedMigrations, getMigrationPlan, getPersistedColumnMap, getPersistedEnumMap, getPersistedEnumTsType, getPersistedPrimaryKeyGeneration, getPersistedTableMetadata, getPersistedTimestampColumns, getRuntimeAdapter, getRuntimePaginationCurrentPageResolver, getRuntimePaginationURLDriverFactory, getRuntimePrismaClient, getUserConfig, inferDelegateName, isDelegateLike, isMigrationApplied, isTransactionCapableClient, loadArkormConfig, markMigrationApplied, markMigrationRun, pad, readAppliedMigrationsState, readAppliedMigrationsStateFromStore, readPersistedColumnMappingsState, rebuildPersistedColumnMappingsState, removeAppliedMigration, resetArkormRuntimeForTests, resetPersistedColumnMappingsCache, resolveCast, resolveColumnMappingsFilePath, resolveEnumName, resolveMigrationClassName, resolveMigrationStateFilePath, resolvePersistedMetadataFeatures, resolvePrismaType, runArkormTransaction, runMigrationWithPrisma, runPrismaCommand, stripPrismaSchemaModelsAndEnums, supportsDatabaseMigrationExecution, supportsDatabaseMigrationState, supportsDatabaseReset, syncPersistedColumnMappingsFromState, toMigrationFileSlug, toModelName, validatePersistedMetadataFeaturesForMigrations, writeAppliedMigrationsState, writeAppliedMigrationsStateToStore, writePersistedColumnMappingsState };
+export { AdapterBindableModel, AdapterCapabilities, AdapterCapability, AdapterInspectionRequest, AdapterModelFieldStructure, AdapterModelIntrospectionOptions, AdapterModelStructure, AdapterQueryInspection, AdapterQueryOperation, AdapterTransactionContext, AggregateOperation, AggregateSelection, AggregateSpec, AppliedMigrationEntry, AppliedMigrationRun, AppliedMigrationsState, ArkormBootContext, ArkormCollection, ArkormConfig, ArkormDebugEvent, ArkormDebugHandler, ArkormErrorContext, ArkormException, Attribute, AttributeCreateInput, AttributeOptions, AttributeOrderBy, AttributeQuerySchema, AttributeSchemaDelegate, AttributeSelect, AttributeUpdateInput, AttributeWhereInput, BelongsToManyRelationMetadata, BelongsToRelationMetadata, CastDefinition, CastHandler, CastMap, CastType, CliApp, ClientResolver, ColumnMap, DB, DatabaseAdapter, DatabasePrimitive, DatabaseRow, DatabaseRows, DatabaseTableOptions, DatabaseTablePersistedMetadataOptions, DatabaseValue, DelegateCreateData, DelegateFindManyArgs, DelegateForModelSchema, DelegateInclude, DelegateOrderBy, DelegateRow, DelegateRows, DelegateSelect, DelegateUniqueWhere, DelegateUpdateArgs, DelegateUpdateData, DelegateWhere, DeleteManySpec, DeleteSpec, EagerLoadConstraint, EagerLoadMap, EnumBuilder, FactoryAttributes, FactoryDefinition, FactoryModelConstructor, FactoryState, ForeignKeyBuilder, GenerateMigrationOptions, GeneratedMigrationFile, GetUserConfig, GlobalScope, HasManyRelationMetadata, HasManyThroughRelationMetadata, HasOneRelationMetadata, HasOneThroughRelationMetadata, InitCommand, InlineFactory, InsertManySpec, InsertSpec, KyselyDatabaseAdapter, LengthAwarePaginator, MIGRATION_BRAND, MakeFactoryCommand, MakeMigrationCommand, MakeModelCommand, MakeSeederCommand, MigrateCommand, MigrateFreshCommand, MigrateRollbackCommand, Migration, MigrationClass, MigrationHistoryCommand, MigrationInstanceLike, MissingDelegateException, Model, ModelAttributeValue, ModelAttributes, ModelAttributesOf, ModelCreateData, ModelDeclaredAttributeKey, ModelEventDispatcher, ModelEventHandler, ModelEventHandlerConstructor, ModelEventListener, ModelEventName, ModelFactory, ModelLifecycleState, ModelMetadata, ModelNotFoundException, ModelQuerySchemaLike, ModelRelationshipKey, ModelRelationshipResult, ModelStatic, ModelUpdateData, ModelsSyncCommand, MorphManyRelationMetadata, MorphOneRelationMetadata, MorphToManyRelationMetadata, PRISMA_ENUM_MEMBER_REGEX, PRISMA_ENUM_REGEX, PRISMA_MODEL_REGEX, PaginationCurrentPageResolver, PaginationMeta, PaginationOptions, PaginationURLDriver, PaginationURLDriverFactory, Paginator, PersistedColumnMappingsState, PersistedMetadataFeatures, PersistedPrimaryKeyGeneration, PersistedTableMetadata, PersistedTimestampColumn, PivotModel, PivotModelStatic, PrimaryKeyGeneration, PrimaryKeyGenerationPlanner, PrismaClientLike, PrismaDatabaseAdapter, PrismaDelegateLike, PrismaDelegateMap, PrismaDelegateNameMapping, PrismaFindManyArgsLike, PrismaLikeInclude, PrismaLikeOrderBy, PrismaLikeScalarFilter, PrismaLikeSelect, PrismaLikeSortOrder, PrismaLikeWhereInput, PrismaMigrationWorkflowOptions, PrismaSchemaSyncOptions, PrismaTransactionCallback, PrismaTransactionCapableClient, PrismaTransactionContext, PrismaTransactionOptions, QueryBuilder, QueryComparisonCondition, QueryComparisonOperator, QueryCondition, QueryConstraintException, QueryExecutionException, QueryExecutionExceptionContext, QueryGroupCondition, QueryLogicalOperator, QueryNotCondition, QueryOrderBy, QueryRawCondition, QuerySchemaCreateData, QuerySchemaFindManyArgs, QuerySchemaForModel, QuerySchemaInclude, QuerySchemaOrderBy, QuerySchemaRow, QuerySchemaRows, QuerySchemaSelect, QuerySchemaUniqueWhere, QuerySchemaUpdateArgs, QuerySchemaUpdateData, QuerySchemaWhere, QuerySelectColumn, QueryTarget, RelatedModelClass, RelationAggregateSpec, RelationColumnLookupSpec, RelationConstraint, RelationDefaultResolver, RelationDefaultValue, RelationFilterSpec, RelationLoadPlan, RelationLoadSpec, RelationMetadata, RelationMetadataProvider, RelationMetadataType, RelationResolutionException, RelationTableLookupSpec, RelationshipModelStatic, RuntimeClientLike, RuntimeModuleLoader, SEEDER_BRAND, SchemaBuilder, SchemaColumn, SchemaColumnType, SchemaForeignKey, SchemaForeignKeyAction, SchemaIndex, SchemaOperation, SchemaTableAlterOperation, SchemaTableCreateOperation, SchemaTableDropOperation, ScopeNotDefinedException, SeedCommand, Seeder, SeederCallArgument, SeederConstructor, SeederInput, SelectSpec, Serializable, SimplePaginationMeta, SoftDeleteConfig, SoftDeleteQueryMode, SortDirection, TableBuilder, TimestampColumnBehavior, TransactionCallback, TransactionCapableClient, TransactionContext, TransactionOptions, URLDriver, UniqueConstraintResolutionException, UnsupportedAdapterFeatureException, UpdateManySpec, UpdateSpec, UpsertSpec, applyAlterTableOperation, applyCreateTableOperation, applyDropTableOperation, applyMigrationRollbackToDatabase, applyMigrationRollbackToPrismaSchema, applyMigrationToDatabase, applyMigrationToPrismaSchema, applyOperationsToPersistedColumnMappingsState, applyOperationsToPrismaSchema, bindAdapterToModels, buildEnumBlock, buildFieldLine, buildIndexLine, buildInverseRelationLine, buildMigrationIdentity, buildMigrationRunId, buildMigrationSource, buildModelBlock, buildRelationLine, computeMigrationChecksum, configureArkormRuntime, createEmptyAppliedMigrationsState, createEmptyPersistedColumnMappingsState, createKyselyAdapter, createMigrationTimestamp, createPrismaAdapter, createPrismaCompatibilityAdapter, createPrismaDatabaseAdapter, createPrismaDelegateMap, defineConfig, defineFactory, deleteAppliedMigrationsStateFromStore, deletePersistedColumnMappingsState, deriveCollectionFieldName, deriveInverseRelationAlias, deriveRelationAlias, deriveRelationFieldName, deriveSingularFieldName, emitRuntimeDebugEvent, ensureArkormConfigLoading, escapeRegex, findAppliedMigration, findEnumBlock, findModelBlock, formatDefaultValue, formatEnumDefaultValue, formatRelationAction, generateMigrationFile, getActiveTransactionAdapter, getActiveTransactionClient, getDefaultStubsPath, getLastMigrationRun, getLatestAppliedMigrations, getMigrationPlan, getPersistedColumnMap, getPersistedEnumMap, getPersistedEnumTsType, getPersistedPrimaryKeyGeneration, getPersistedTableMetadata, getPersistedTimestampColumns, getRuntimeAdapter, getRuntimeClient, getRuntimeCompatibilityAdapter, getRuntimeDebugHandler, getRuntimePaginationCurrentPageResolver, getRuntimePaginationURLDriverFactory, getRuntimePrismaClient, getUserConfig, inferDelegateName, isDelegateLike, isMigrationApplied, isQuerySchemaLike, isTransactionCapableClient, loadArkormConfig, markMigrationApplied, markMigrationRun, pad, readAppliedMigrationsState, readAppliedMigrationsStateFromStore, readPersistedColumnMappingsState, rebuildPersistedColumnMappingsState, removeAppliedMigration, resetArkormRuntimeForTests, resetPersistedColumnMappingsCache, resolveCast, resolveColumnMappingsFilePath, resolveEnumName, resolveMigrationClassName, resolveMigrationStateFilePath, resolvePersistedMetadataFeatures, resolvePrismaType, resolveRuntimeCompatibilityQuerySchema, resolveRuntimeCompatibilityQuerySchemaOrThrow, runArkormTransaction, runMigrationWithPrisma, runPrismaCommand, stripPrismaSchemaModelsAndEnums, supportsDatabaseMigrationExecution, supportsDatabaseMigrationState, supportsDatabaseReset, syncPersistedColumnMappingsFromState, toMigrationFileSlug, toModelName, validatePersistedMetadataFeaturesForMigrations, writeAppliedMigrationsState, writeAppliedMigrationsStateToStore, writePersistedColumnMappingsState };