@bunyad/orm 0.2.0-beta.0 → 0.2.0-beta.2

package/dist/model.d.ts

@@ -1,11 +1,13 @@
 import type { Connection, DatabaseManager, DateInput } from "@bunyad/database";
 import { LengthAwarePaginator, CursorPaginator } from "@bunyad/database";
-import { Collection } from "@bunyad/common";
+import { Collection, LazyCollection } from "@bunyad/common";
 import { OrmCollection } from "./orm-collection.js";
 import { type CastDefinition } from "./casts.js";
 import { type ModelEventListener, type ModelEventName, type ModelObserver } from "./model-events.js";
 import { type GlobalScopeCallback } from "./scopes.js";
-import { BelongsTo, BelongsToMany, HasMany, HasManyThrough, HasOne, HasOneThrough, MorphMany, MorphOne, MorphTo, MorphToMany, type MorphToManyOptions } from "./relations.js";
+import { BelongsTo, BelongsToMany, HasMany, HasManyThrough, HasOne, HasOneThrough, MorphMany, MorphOne, MorphTo, MorphToMany, MorphedByMany, type MorphToManyOptions } from "./relations.js";
+import type { AggregateRelations } from "./model-query.js";
+import type { ColumnHint, RelationHint, WithMap } from "./typed-names.js";
 import { ModelQuery } from "./model-query.js";
 export type { CastType, CastDefinition, EnumCast } from "./casts.js";
 export { Attribute, AsCollection, AsFluent, AsEnumCollection, } from "./casts.js";
@@ -24,6 +26,14 @@ export type RelationFactory = {
     bivarianceHack(model: Model): unknown;
 }["bivarianceHack"];
 export type RelationsMap = Record<string, RelationFactory> | (() => Record<string, RelationFactory>);
+/**
+ * What a relation definition needs from the related class. Deliberately small:
+ * `hasMany(Product)` is checked for every model graph (Brand ↔ Product ↔ …), and comparing
+ * the full `typeof Model` static side there recurses until the compiler overflows its stack.
+ */
+export type RelatedModel = (abstract new (...args: any[]) => Model) & {
+    table: string;
+};
 export type ModelClass = typeof Model & {
     table: string;
     primaryKey: string;
@@ -53,6 +63,8 @@ export type ModelQueryOptions = {
 };
 /** Resolve a connection name or handle to a live Connection. */
 export declare function resolveConnection(connection?: string | Connection | null): Connection;
+/** Whether `key` may be mass assigned (mirrors {@link filterFillable}'s rules). */
+export declare function canMassAssign(model: ModelClass, key: string): boolean;
 export declare function filterFillable(model: ModelClass, attributes: Record<string, unknown>): Record<string, unknown>;
 /** True when hydrating this row must run cast getters (partial selects often do not). */
 export declare function attributesNeedModelCasts(ctor: ModelClass, attributes: Record<string, unknown>): boolean;
@@ -118,6 +130,8 @@ export declare class Model {
     static newFromBuilder<T extends typeof Model>(this: T, attributes: Record<string, unknown>): InstanceType<T>;
     /** Snapshot current attributes as the original set. */
     syncOriginal(): this;
+    /** `$model->only($keys)` — a subset of the attributes (array or varargs; missing keys are skipped). */
+    only(...keys: Array<string | string[]>): Record<string, unknown>;
     /** Current attribute bag (non-function own properties). */
     getAttributes(): Record<string, unknown>;
     /**
@@ -136,6 +150,9 @@ export declare class Model {
     getOriginal(key: string): unknown;
     /** `getChanges` — attributes changed by the last save. */
     getChanges(): Record<string, unknown>;
+    /** `getPrevious` — original values of the attributes changed by the last save. */
+    getPrevious(): Record<string, unknown>;
+    getPrevious(key: string): unknown;
     /** `wasChanged`. */
     wasChanged(...attributes: string[]): boolean;
     /** `wasRecentlyCreated`. */
@@ -172,6 +189,14 @@ export declare class Model {
     static isIgnoringTouch(this: typeof Model): boolean;
     /** `Model::preventLazyLoading`. */
     static preventLazyLoading(prevent?: boolean): void;
+    /** `Model::unguard()` — disable mass-assignment protection (seeders, imports). */
+    static unguard(state?: boolean): void;
+    /** `Model::reguard()`. */
+    static reguard(): void;
+    /** `Model::isUnguarded()`. */
+    static isUnguarded(): boolean;
+    /** `Model::unguarded(callback)` — run with protection off, then restore it. */
+    static unguarded<R>(callback: () => R): R;
     /** `Model::preventSilentlyDiscardingAttributes`. */
     static preventSilentlyDiscardingAttributes(prevent?: boolean): void;
     /** `Model::preventAccessingMissingAttributes`. */
@@ -274,20 +299,107 @@ export declare class Model {
     static findSync<T extends typeof Model>(this: T, id: string | number): InstanceType<T> | null;
     /** `Model::where`. */
     static where<T extends typeof Model>(this: T, callback: (query: ModelQuery<InstanceType<T>>) => void): ModelQuery<InstanceType<T>>;
-    static where<T extends typeof Model>(this: T, column: string, value: unknown): ModelQuery<InstanceType<T>>;
-    static where<T extends typeof Model>(this: T, column: string, op: string, value: unknown): ModelQuery<InstanceType<T>>;
-    /** Karobar-style multi-column LIKE search. */
+    static where<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>, value: unknown): ModelQuery<InstanceType<T>>;
+    static where<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>, op: string, value: unknown): ModelQuery<InstanceType<T>>;
+    /** Multi-column LIKE search. */
     static search<T extends typeof Model>(this: T, columns: string[], term: string): ModelQuery<InstanceType<T>>;
+    static whereBetween<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereBetween"]>): ModelQuery<InstanceType<T>>;
+    static whereNotBetween<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereNotBetween"]>): ModelQuery<InstanceType<T>>;
+    static whereNotIn<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereNotIn"]>): ModelQuery<InstanceType<T>>;
+    static whereRaw<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereRaw"]>): ModelQuery<InstanceType<T>>;
+    static whereColumn<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereColumn"]>): ModelQuery<InstanceType<T>>;
+    static whereLike<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereLike"]>): ModelQuery<InstanceType<T>>;
+    static whereNotLike<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereNotLike"]>): ModelQuery<InstanceType<T>>;
+    static whereDay<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereDay"]>): ModelQuery<InstanceType<T>>;
+    static whereMonth<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereMonth"]>): ModelQuery<InstanceType<T>>;
+    static whereYear<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereYear"]>): ModelQuery<InstanceType<T>>;
+    static orWhereIn<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereIn"]>): ModelQuery<InstanceType<T>>;
+    static orWhereNotIn<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereNotIn"]>): ModelQuery<InstanceType<T>>;
+    static orWhereNull<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereNull"]>): ModelQuery<InstanceType<T>>;
+    static orWhereNotNull<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereNotNull"]>): ModelQuery<InstanceType<T>>;
+    static orWhereBetween<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereBetween"]>): ModelQuery<InstanceType<T>>;
+    static orWhereNotBetween<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereNotBetween"]>): ModelQuery<InstanceType<T>>;
+    static orWhereColumn<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereColumn"]>): ModelQuery<InstanceType<T>>;
+    static orWhereRaw<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereRaw"]>): ModelQuery<InstanceType<T>>;
+    static orWhereLike<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereLike"]>): ModelQuery<InstanceType<T>>;
+    static orWhereNotLike<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereNotLike"]>): ModelQuery<InstanceType<T>>;
+    static groupBy<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["groupBy"]>): ModelQuery<InstanceType<T>>;
+    static having<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["having"]>): ModelQuery<InstanceType<T>>;
+    static havingRaw<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["havingRaw"]>): ModelQuery<InstanceType<T>>;
+    static selectRaw<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["selectRaw"]>): ModelQuery<InstanceType<T>>;
+    static addSelect<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["addSelect"]>): ModelQuery<InstanceType<T>>;
+    static distinct<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["distinct"]>): ModelQuery<InstanceType<T>>;
+    static inRandomOrder<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["inRandomOrder"]>): ModelQuery<InstanceType<T>>;
+    static reorder<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["reorder"]>): ModelQuery<InstanceType<T>>;
+    static offset<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["offset"]>): ModelQuery<InstanceType<T>>;
+    static skip<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["skip"]>): ModelQuery<InstanceType<T>>;
+    static lockForUpdate<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["lockForUpdate"]>): ModelQuery<InstanceType<T>>;
+    static sharedLock<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["sharedLock"]>): ModelQuery<InstanceType<T>>;
+    static has<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["has"]>): ModelQuery<InstanceType<T>>;
+    static doesntHave<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["doesntHave"]>): ModelQuery<InstanceType<T>>;
+    static orHas<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orHas"]>): ModelQuery<InstanceType<T>>;
+    static orDoesntHave<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orDoesntHave"]>): ModelQuery<InstanceType<T>>;
+    static orWhereDoesntHave<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereDoesntHave"]>): ModelQuery<InstanceType<T>>;
+    static whereHasMorph<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereHasMorph"]>): ModelQuery<InstanceType<T>>;
+    static orWhereHasMorph<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereHasMorph"]>): ModelQuery<InstanceType<T>>;
+    static whereDoesntHaveMorph<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereDoesntHaveMorph"]>): ModelQuery<InstanceType<T>>;
+    static orWhereDoesntHaveMorph<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereDoesntHaveMorph"]>): ModelQuery<InstanceType<T>>;
+    static hasMorph<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["hasMorph"]>): ModelQuery<InstanceType<T>>;
+    static doesntHaveMorph<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["doesntHaveMorph"]>): ModelQuery<InstanceType<T>>;
+    static whereMorphedTo<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereMorphedTo"]>): ModelQuery<InstanceType<T>>;
+    static whereNotMorphedTo<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereNotMorphedTo"]>): ModelQuery<InstanceType<T>>;
+    static orWhereMorphedTo<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereMorphedTo"]>): ModelQuery<InstanceType<T>>;
+    static orWhereNotMorphedTo<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereNotMorphedTo"]>): ModelQuery<InstanceType<T>>;
+    static whereMorphRelation<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereMorphRelation"]>): ModelQuery<InstanceType<T>>;
+    static orWhereMorphRelation<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereMorphRelation"]>): ModelQuery<InstanceType<T>>;
+    static whereKeyNot<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["whereKeyNot"]>): ModelQuery<InstanceType<T>>;
+    static orWhereBelongsTo<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereBelongsTo"]>): ModelQuery<InstanceType<T>>;
+    static orWhereAny<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereAny"]>): ModelQuery<InstanceType<T>>;
+    static orWhereAll<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereAll"]>): ModelQuery<InstanceType<T>>;
+    static orWhereNone<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["orWhereNone"]>): ModelQuery<InstanceType<T>>;
+    static withAggregate<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["withAggregate"]>): ModelQuery<InstanceType<T>>;
+    static withAttributes<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["withAttributes"]>): ModelQuery<InstanceType<T>>;
+    static withCasts<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["withCasts"]>): ModelQuery<InstanceType<T>>;
+    static rightJoin<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["rightJoin"]>): ModelQuery<InstanceType<T>>;
+    static when<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["when"]>): ModelQuery<InstanceType<T>>;
+    static unless<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["unless"]>): ModelQuery<InstanceType<T>>;
+    static tap<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["tap"]>): ModelQuery<InstanceType<T>>;
+    static forPage<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["forPage"]>): ModelQuery<InstanceType<T>>;
+    static firstWhere<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["firstWhere"]>): ReturnType<ModelQuery<InstanceType<T>>["firstWhere"]>;
+    static findMany<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["findMany"]>): ReturnType<ModelQuery<InstanceType<T>>["findMany"]>;
+    static findOr<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["findOr"]>): ReturnType<ModelQuery<InstanceType<T>>["findOr"]>;
+    static findOrNew<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["findOrNew"]>): ReturnType<ModelQuery<InstanceType<T>>["findOrNew"]>;
+    static firstOr<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["firstOr"]>): ReturnType<ModelQuery<InstanceType<T>>["firstOr"]>;
+    static chunk<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["chunk"]>): ReturnType<ModelQuery<InstanceType<T>>["chunk"]>;
+    static chunkById<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["chunkById"]>): ReturnType<ModelQuery<InstanceType<T>>["chunkById"]>;
+    static chunkByIdDesc<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["chunkByIdDesc"]>): ReturnType<ModelQuery<InstanceType<T>>["chunkByIdDesc"]>;
+    static dd<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["dd"]>): ReturnType<ModelQuery<InstanceType<T>>["dd"]>;
+    static dump<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["dump"]>): ReturnType<ModelQuery<InstanceType<T>>["dump"]>;
+    static toBase<T extends typeof Model>(this: T, ...args: Parameters<ModelQuery<InstanceType<T>>["toBase"]>): ReturnType<ModelQuery<InstanceType<T>>["toBase"]>;
+    static count<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["count"]>;
+    static sum<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["sum"]>;
+    static avg<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["avg"]>;
+    static min<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["min"]>;
+    static max<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["max"]>;
+    static exists<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["exists"]>;
+    static doesntExist<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["doesntExist"]>;
+    static sole<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["sole"]>;
+    static soleValue<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["soleValue"]>;
+    static valueOrFail<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["valueOrFail"]>;
+    static toSql<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["toSql"]>;
+    static toRawSql<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["toRawSql"]>;
+    static getBindings<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["getBindings"]>;
+    static firstOrFail<T extends typeof Model>(this: T, ...args: any[]): ReturnType<ModelQuery<InstanceType<T>>["firstOrFail"]>;
     /** Start a new query and forward common builder methods (`__callStatic`). */
-    static orWhere<T extends typeof Model>(this: T, column: string, value: unknown): ModelQuery<InstanceType<T>>;
-    static orWhere<T extends typeof Model>(this: T, column: string, op: string, value: unknown): ModelQuery<InstanceType<T>>;
-    static whereIn<T extends typeof Model>(this: T, column: string, values: unknown[]): ModelQuery<InstanceType<T>>;
-    static whereNull<T extends typeof Model>(this: T, column: string): ModelQuery<InstanceType<T>>;
-    static whereNotNull<T extends typeof Model>(this: T, column: string): ModelQuery<InstanceType<T>>;
-    static orderBy<T extends typeof Model>(this: T, column: string, direction?: "asc" | "desc"): ModelQuery<InstanceType<T>>;
-    static orderByDesc<T extends typeof Model>(this: T, column: string): ModelQuery<InstanceType<T>>;
+    static orWhere<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>, value: unknown): ModelQuery<InstanceType<T>>;
+    static orWhere<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>, op: string, value: unknown): ModelQuery<InstanceType<T>>;
+    static whereIn<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>, values: unknown[]): ModelQuery<InstanceType<T>>;
+    static whereNull<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>): ModelQuery<InstanceType<T>>;
+    static whereNotNull<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>): ModelQuery<InstanceType<T>>;
+    static orderBy<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>, direction?: "asc" | "desc"): ModelQuery<InstanceType<T>>;
+    static orderByDesc<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>): ModelQuery<InstanceType<T>>;
     static orderByRaw<T extends typeof Model>(this: T, sql: string): ModelQuery<InstanceType<T>>;
-    /** Karobar alias for `orderByRaw`. */
+    /** Alias for `orderByRaw`. */
     static orderBySql<T extends typeof Model>(this: T, sql: string): ModelQuery<InstanceType<T>>;
     static latest<T extends typeof Model>(this: T, column?: string): ModelQuery<InstanceType<T>>;
     static oldest<T extends typeof Model>(this: T, column?: string): ModelQuery<InstanceType<T>>;
@@ -297,10 +409,14 @@ export declare class Model {
     /** `Model::whereDate`. */
     static whereDate<T extends typeof Model>(this: T, column: string, value: DateInput): ModelQuery<InstanceType<T>>;
     static whereDate<T extends typeof Model>(this: T, column: string, op: string, value: DateInput): ModelQuery<InstanceType<T>>;
-    /** `Model::whereNot(closure)`. */
+    /** `Model::whereNot(closure | column, [op], value)`. */
     static whereNot<T extends typeof Model>(this: T, callback: (query: ModelQuery<InstanceType<T>>) => void): ModelQuery<InstanceType<T>>;
-    /** `Model::orWhereNot(closure)`. */
+    static whereNot<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>, value: unknown): ModelQuery<InstanceType<T>>;
+    static whereNot<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>, op: string, value: unknown): ModelQuery<InstanceType<T>>;
+    /** `Model::orWhereNot(closure | column, [op], value)`. */
     static orWhereNot<T extends typeof Model>(this: T, callback: (query: ModelQuery<InstanceType<T>>) => void): ModelQuery<InstanceType<T>>;
+    static orWhereNot<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>, value: unknown): ModelQuery<InstanceType<T>>;
+    static orWhereNot<T extends typeof Model>(this: T, column: ColumnHint<InstanceType<T>>, op: string, value: unknown): ModelQuery<InstanceType<T>>;
     /** `withTrashed()`. */
     static withTrashed<T extends typeof Model>(this: T): ModelQuery<InstanceType<T>>;
     /** `onlyTrashed()`. */
@@ -310,26 +426,26 @@ export declare class Model {
     /** `get()` returns plain row objects. Models are not built. */
     static rows<T extends typeof Model>(this: T): ModelQuery<InstanceType<T>, "row">;
     /** Eager-load relations (`with('posts')`, `with({ posts: (q) => q.where(…) })`). */
-    static with<T extends typeof Model>(this: T, ...relations: Array<string | string[] | Record<string, unknown>>): ModelQuery<InstanceType<T>>;
+    static with<T extends typeof Model>(this: T, ...relations: Array<RelationHint<InstanceType<T>> | RelationHint<InstanceType<T>>[] | WithMap<InstanceType<T>>>): ModelQuery<InstanceType<T>>;
     /** `Model::whereHas`. */
-    static whereHas<T extends typeof Model>(this: T, relation: string, callback?: (query: ModelQuery) => void): ModelQuery<InstanceType<T>>;
+    static whereHas<T extends typeof Model>(this: T, relation: RelationHint<InstanceType<T>>, callback?: (query: ModelQuery) => void): ModelQuery<InstanceType<T>>;
     /** `Model::whereDoesntHave`. */
-    static whereDoesntHave<T extends typeof Model>(this: T, relation: string, callback?: (query: ModelQuery) => void): ModelQuery<InstanceType<T>>;
+    static whereDoesntHave<T extends typeof Model>(this: T, relation: RelationHint<InstanceType<T>>, callback?: (query: ModelQuery) => void): ModelQuery<InstanceType<T>>;
     /** `Model::orWhereHas`. */
-    static orWhereHas<T extends typeof Model>(this: T, relation: string, callback?: (query: ModelQuery) => void): ModelQuery<InstanceType<T>>;
+    static orWhereHas<T extends typeof Model>(this: T, relation: RelationHint<InstanceType<T>>, callback?: (query: ModelQuery) => void): ModelQuery<InstanceType<T>>;
     /** `Model::whereRelation`. */
     static whereRelation<T extends typeof Model>(this: T, relation: string, column: string, opOrValue: unknown, value?: unknown): ModelQuery<InstanceType<T>>;
     /** `Model::orWhereRelation`. */
     static orWhereRelation<T extends typeof Model>(this: T, relation: string, column: string, opOrValue: unknown, value?: unknown): ModelQuery<InstanceType<T>>;
     /** `withCount` — `'posts'`, `'posts as post_total'`, a string list, or `{ products: { as: 'productsCount' } }`. */
-    static withCount<T extends typeof Model>(this: T, ...relations: Array<string | string[] | Record<string, unknown>>): ModelQuery<InstanceType<T>>;
+    static withCount<T extends typeof Model>(this: T, ...relations: AggregateRelations[]): ModelQuery<InstanceType<T>>;
     /** `Model::withSum`. */
-    static withSum<T extends typeof Model>(this: T, relation: string, column: string): ModelQuery<InstanceType<T>>;
-    static withAvg<T extends typeof Model>(this: T, relation: string, column: string): ModelQuery<InstanceType<T>>;
-    static withMin<T extends typeof Model>(this: T, relation: string, column: string): ModelQuery<InstanceType<T>>;
-    static withMax<T extends typeof Model>(this: T, relation: string, column: string): ModelQuery<InstanceType<T>>;
-    static withExists<T extends typeof Model>(this: T, ...relations: string[]): ModelQuery<InstanceType<T>>;
-    static withWhereHas<T extends typeof Model>(this: T, relation: string, callback?: (query: ModelQuery) => void): ModelQuery<InstanceType<T>>;
+    static withSum<T extends typeof Model>(this: T, relation: AggregateRelations, column: string): ModelQuery<InstanceType<T>>;
+    static withAvg<T extends typeof Model>(this: T, relation: AggregateRelations, column: string): ModelQuery<InstanceType<T>>;
+    static withMin<T extends typeof Model>(this: T, relation: AggregateRelations, column: string): ModelQuery<InstanceType<T>>;
+    static withMax<T extends typeof Model>(this: T, relation: AggregateRelations, column: string): ModelQuery<InstanceType<T>>;
+    static withExists<T extends typeof Model>(this: T, ...relations: AggregateRelations[]): ModelQuery<InstanceType<T>>;
+    static withWhereHas<T extends typeof Model>(this: T, relation: RelationHint<InstanceType<T>>, callback?: (query: ModelQuery) => void): ModelQuery<InstanceType<T>>;
     static whereBelongsTo<T extends typeof Model>(this: T, related: Model, relationName?: string): ModelQuery<InstanceType<T>>;
     static whereAny<T extends typeof Model>(this: T, columns: string[], opOrValue: unknown, value?: unknown): ModelQuery<InstanceType<T>>;
     static whereAll<T extends typeof Model>(this: T, columns: string[], opOrValue: unknown, value?: unknown): ModelQuery<InstanceType<T>>;
@@ -353,10 +469,20 @@ export declare class Model {
         path?: string;
         cursorName?: string;
     }): Promise<CursorPaginator<InstanceType<T>>>;
+    /** `Model::cursor()`: stream models from a single query. */
+    static cursor<T extends typeof Model>(this: T, chunkSize?: number): LazyCollection<InstanceType<T>>;
+    /** `Model::lazy()`: chunked iteration, one query per chunk. */
+    static lazy<T extends typeof Model>(this: T, chunkSize?: number): LazyCollection<InstanceType<T>>;
+    /** `Model::lazyById()`: chunked iteration by primary key (safe while updating). */
+    static lazyById<T extends typeof Model>(this: T, chunkSize?: number, column?: string): LazyCollection<InstanceType<T>>;
+    /** `Model::lazyByIdDesc()`. */
+    static lazyByIdDesc<T extends typeof Model>(this: T, chunkSize?: number, column?: string): LazyCollection<InstanceType<T>>;
     /** `Model::create` (respects `$fillable` / `$guarded`). */
     static create<T extends typeof Model>(this: T, attributes: Record<string, unknown>): InstanceType<T> | Promise<InstanceType<T>>;
     /** `Model::forceCreate` — insert every given attribute, ignoring `$fillable`. */
-    static forceCreate<T extends typeof Model>(this: T, useAttrs: Record<string, unknown>): InstanceType<T> | Promise<InstanceType<T>>;
+    static forceCreate<T extends typeof Model>(this: T, useAttrs: Record<string, unknown>, beforeSave?: (model: InstanceType<T>) => void | Promise<void>): InstanceType<T> | Promise<InstanceType<T>>;
+    /** Persist a model built by {@link forceCreate} and re-hydrate get-casts. */
+    private static forceCreateSaved;
     /** `firstOrNew`. */
     static firstOrNew<T extends typeof Model>(this: T, attributes: Record<string, unknown>, values?: Record<string, unknown>): Promise<InstanceType<T>>;
     /** `firstOrCreate`. */
@@ -375,6 +501,12 @@ export declare class Model {
     static upsert<T extends typeof Model>(this: T, values: Record<string, unknown> | Record<string, unknown>[], uniqueBy: string | string[], update?: string[] | null): Promise<number>;
     /** `$model->fill($attributes)`. */
     fill(attributes: Record<string, unknown>): this;
+    /** `$model->forceFill($attributes)` — assign without checking `fillable` / `guarded`. */
+    forceFill(attributes: Record<string, unknown>): this;
+    /** `$model->isFillable($key)`. */
+    isFillable(key: string): boolean;
+    /** `$model->isGuarded($key)`. */
+    isGuarded(key: string): boolean;
     /** `$model->update($attributes)`. */
     update(attributes: Record<string, unknown>): Promise<this>;
     save(): this | Promise<this>;
@@ -439,6 +571,7 @@ export declare class Model {
     loadMax(relation: string, column: string): Promise<this>;
     /** `$model->loadExists(...$relations)`. */
     loadExists(...relations: string[]): Promise<this>;
+    /** `toArray()` with `bigint` values as decimal strings, since JSON has no `bigint`. */
     toJSON(): Record<string, unknown>;
     /** Alias of {@link toJSON}. */
     toJson(): Record<string, unknown>;
@@ -454,9 +587,9 @@ export declare class Model {
      */
     static forceDestroy<T extends typeof Model>(this: T, ids: Array<string | number> | string | number): Promise<number>;
     /** `$this->hasMany(Related::class)`. */
-    hasMany<R extends ModelClass>(related: R, foreignKey?: string, localKey?: string): HasMany<InstanceType<R>>;
+    hasMany<R extends RelatedModel>(related: R, foreignKey?: string, localKey?: string): HasMany<InstanceType<R>>;
     /** `$this->hasOne(Related::class)`. */
-    hasOne<R extends ModelClass>(related: R, foreignKey?: string, localKey?: string): HasOne<InstanceType<R>>;
+    hasOne<R extends RelatedModel>(related: R, foreignKey?: string, localKey?: string): HasOne<InstanceType<R>>;
     /**
      * `$this->hasManyThrough(Related::class, Through::class)`.
      * Parent → Through (firstKey) → Related (secondKey).
@@ -467,24 +600,29 @@ export declare class Model {
      */
     hasOneThrough<R extends ModelClass, TThrough extends ModelClass>(related: R, through: TThrough, firstKey?: string, secondKey?: string, localKey?: string, secondLocalKey?: string): HasOneThrough<InstanceType<R>>;
     /** `$this->belongsTo(Related::class)`. */
-    belongsTo<R extends ModelClass>(related: R, foreignKey?: string, ownerKey?: string): BelongsTo<InstanceType<R>>;
+    belongsTo<R extends RelatedModel>(related: R, foreignKey?: string, ownerKey?: string): BelongsTo<InstanceType<R>>;
     /** `$this->belongsToMany(Related::class, pivot)`. */
-    belongsToMany<R extends ModelClass>(related: R, table?: string, foreignPivotKey?: string, relatedPivotKey?: string): BelongsToMany<InstanceType<R>>;
+    belongsToMany<R extends RelatedModel>(related: R, table?: string, foreignPivotKey?: string, relatedPivotKey?: string): BelongsToMany<InstanceType<R>>;
     /**
      * Polymorphic many-to-many (`model_has_roles`-style pivots).
      * Third argument may be the pivot table name or an options bag (tenant/legacy morph types).
      */
-    morphToMany<R extends ModelClass>(related: R, name: string, tableOrOptions?: string | MorphToManyOptions, foreignPivotKey?: string, relatedPivotKey?: string): MorphToMany<InstanceType<R>>;
+    morphToMany<R extends RelatedModel>(related: R, name: string, tableOrOptions?: string | MorphToManyOptions, foreignPivotKey?: string, relatedPivotKey?: string): MorphToMany<InstanceType<R>>;
+    /**
+     * `$this->morphedByMany(Related::class, name)` — inverse of `morphToMany`.
+     * Defaults: pivot `{name}s`, `{name}_id`, `{name}_type`, parent key `{parent}_id`.
+     */
+    morphedByMany<R extends RelatedModel>(related: R, name: string, table?: string, foreignPivotKey?: string, relatedPivotKey?: string): MorphedByMany<InstanceType<R>>;
     /** `$this->morphMany(Related::class, name)`. */
-    morphMany<R extends ModelClass>(related: R, name: string, type?: string, id?: string, localKey?: string): MorphMany<InstanceType<R>>;
+    morphMany<R extends RelatedModel>(related: R, name: string, type?: string, id?: string, localKey?: string): MorphMany<InstanceType<R>>;
     /** `$this->morphOne(Related::class, name)`. */
-    morphOne<R extends ModelClass>(related: R, name: string, type?: string, id?: string, localKey?: string): MorphOne<InstanceType<R>>;
+    morphOne<R extends RelatedModel>(related: R, name: string, type?: string, id?: string, localKey?: string): MorphOne<InstanceType<R>>;
     /** `$this->morphTo($name)`. */
     morphTo(name: string, type?: string, id?: string, ownerKey?: string): MorphTo;
 }
 /** True when `value` is a Model subclass constructor (O(1) prototype check). */
 export declare function isModelCtor(value: unknown): value is ModelClass;
-export { BelongsTo, BelongsToMany, HasMany, HasManyThrough, HasOne, HasOneThrough, MorphMany, MorphOne, MorphTo, MorphToMany, clearMorphMap, morphMap, type MorphToManyOptions, } from "./relations.js";
+export { BelongsTo, BelongsToMany, HasMany, HasManyThrough, HasOne, HasOneThrough, MorphMany, MorphOne, MorphTo, MorphToMany, MorphedByMany, clearMorphMap, morphMap, enforceMorphMap, requireMorphMap, getMorphedModel, type MorphToManyOptions, } from "./relations.js";
 export { eagerLoadAggregates, eagerLoadModels, type EagerAggregateSpec, } from "./eager.js";
 export { ModelQuery } from "./model-query.js";
 export { LazyLoadingViolationException, MassAssignmentException, MissingAttributeException, resetModelStrictnessForTests, } from "./model-strictness.js";