/**
 * Active Record `Model` base class for `@atlex/orm`.
 *
 * Responsibility:
 * - Attribute storage, dirty tracking, mass assignment rules
 * - Persistence (`save`, `delete`, `restore`) delegating to `QueryBuilder`
 * - Relationships (hasOne/hasMany/belongsTo/belongsToMany/through variants)
 * - Eager loading (`with`, `withCount`) with batched queries (no N+1)
 * - Scopes (global + local scope macros)
 * - Hooks/observers lifecycle events
 *
 * Usage example:
 * ```ts
 * class User extends SoftDeletes(Model) {
 *   static table = 'users'
 *   static hidden = ['password']
 *   static fillable = ['name', 'email', 'password']
 *
 *   getFullNameAttribute() { return `${this.first_name} ${this.last_name}` }
 *
 *   posts()   { return this.hasMany(Post, 'user_id') }
 *   profile() { return this.hasOne(Profile, 'user_id') }
 *   roles()   { return this.belongsToMany(Role, 'role_user').withPivot('assigned_at') }
 *
 *   scopeActive(qb: QueryBuilder) { return qb.where('active', '=', true) }
 * }
 *
 * const user = await User.findOrFail(1)
 * const posts = await user.posts().where('published', '=', true).latest().get()
 * const users = await User.with('posts', 'profile').active().get()
 * ```
 */
import type { CursorPaginator } from './pagination/CursorPaginator.js';
import type { LengthAwarePaginator } from './pagination/LengthAwarePaginator.js';
import type { CursorPaginationOptions, PaginationOptions } from './pagination/PaginationMeta.js';
import type { Paginator } from './pagination/Paginator.js';
import { type QueryBuilder } from './QueryBuilder.js';
import { ManyToManyRelationBuilder } from './relations/ManyToManyRelationBuilder.js';
import { RelationBuilder } from './relations/RelationBuilder.js';
import type { Scope } from './scopes/Scope.js';
import type { ModelConstructor } from './types.js';
type Attributes = Record<string, unknown>;
type ModelClass<T extends Model> = ModelConstructor<T> & typeof Model;
export declare abstract class Model {
    #private;
    static table: string;
    static primaryKey: string;
    static timestamps: boolean;
    static incrementing: boolean;
    static hidden: string[];
    static fillable: string[];
    static guarded: string[];
    static appends: string[];
    [key: string]: unknown;
    /**
     * Create a new model instance.
     *
     * The constructor wraps the instance in a Proxy so `model.email` maps to attributes.
     */
    constructor();
    /**
     * Create a fresh query builder scoped to this model (applies global scopes, hydration, local scopes).
     */
    static query<T extends Model>(this: ModelClass<T>): QueryBuilder<T>;
    /**
     * Escape hatch: build complex queries starting from the model table.
     */
    static where<T extends Model>(this: ModelClass<T>, column: string, operator: string, value: unknown): QueryBuilder<T>;
    static where<T extends Model>(this: ModelClass<T>, column: string, value: unknown): QueryBuilder<T>;
    static where<T extends Model>(this: ModelClass<T>, callback: (qb: QueryBuilder<T>) => void): QueryBuilder<T>;
    static whereIn<T extends Model>(this: ModelClass<T>, column: string, values: unknown[]): QueryBuilder<T>;
    static orderBy<T extends Model>(this: ModelClass<T>, column: string, direction?: 'asc' | 'desc'): QueryBuilder<T>;
    static limit<T extends Model>(this: ModelClass<T>, n: number): QueryBuilder<T>;
    /**
     * Fetch all records.
     */
    static all<T extends Model>(this: ModelClass<T>): Promise<T[]>;
    /**
     * Length-aware pagination for this model's table.
     */
    static paginate<T extends Model>(this: ModelClass<T>, perPage?: number, options?: PaginationOptions): Promise<LengthAwarePaginator<T>>;
    /**
     * Simple pagination (no total count) for this model's table.
     */
    static simplePaginate<T extends Model>(this: ModelClass<T>, perPage?: number, options?: PaginationOptions): Promise<Paginator<T>>;
    /**
     * Cursor pagination; uses {@link Model.primaryKey} when no `orderBy` is set on the query.
     */
    static cursorPaginate<T extends Model>(this: ModelClass<T>, perPage?: number, options?: CursorPaginationOptions): Promise<CursorPaginator<T>>;
    /**
     * Find by primary key.
     */
    static find<T extends Model>(this: ModelClass<T>, id: number | string): Promise<T | null>;
    /**
     * Find by primary key or throw.
     */
    static findOrFail<T extends Model>(this: ModelClass<T>, id: number | string): Promise<T>;
    /**
     * Find many by primary key; preserves input order.
     */
    static findMany<T extends Model>(this: ModelClass<T>, ids: (number | string)[]): Promise<T[]>;
    /**
     * Return the first row ordered by primary key asc.
     */
    static first<T extends Model>(this: ModelClass<T>): Promise<T | null>;
    /**
     * Return the first row or throw.
     */
    static firstOrFail<T extends Model>(this: ModelClass<T>): Promise<T>;
    /**
     * Create and persist a model with mass assignment rules and hooks.
     */
    static create<T extends Model>(this: ModelClass<T>, data: Partial<T>): Promise<T>;
    /**
     * First or create atomically (returns [model, wasCreated]).
     */
    static firstOrCreate<T extends Model>(this: ModelClass<T>, search: Partial<T>, data?: Partial<T>): Promise<[T, boolean]>;
    /**
     * First or new (does not persist).
     */
    static firstOrNew<T extends Model>(this: ModelClass<T>, search: Partial<T>, data?: Partial<T>): Promise<T>;
    /**
     * Update or create atomically.
     */
    static updateOrCreate<T extends Model>(this: ModelClass<T>, search: Partial<T>, data: Partial<T>): Promise<T>;
    /**
     * Bulk insert (no hydration, no hooks, no mass-assignment).
     */
    static insert(rows: Record<string, unknown>[]): Promise<void>;
    /**
     * Truncate table (blocked in production unless ALLOW_UNSAFE_OPERATIONS=true).
     */
    static truncate(): Promise<void>;
    static count(column?: string): Promise<number>;
    static max(column: string): Promise<number>;
    static min(column: string): Promise<number>;
    static avg(column: string): Promise<number>;
    static sum(column: string): Promise<number>;
    static exists<T extends Model>(this: ModelClass<T>, id: number | string): Promise<boolean>;
    static with<T extends Model>(this: ModelClass<T>, ...relations: string[]): QueryBuilder<T>;
    static withCount<T extends Model>(this: ModelClass<T>, ...relations: string[]): QueryBuilder<T>;
    static addGlobalScope(name: string, scope: Scope): void;
    static withoutGlobalScope<T extends Model>(this: ModelClass<T>, name: string): QueryBuilder<T>;
    static withoutGlobalScopes<T extends Model>(this: ModelClass<T>): QueryBuilder<T>;
    /**
     * Boot hook for registering global scopes. Called once per model class.
     */
    static booted(): void;
    /**
     * Register an observer instance.
     */
    static observe(observer: object): void;
    /**
     * Persist this model (insert or update).
     */
    save(): Promise<void>;
    /**
     * @internal Save using an existing transaction-scoped builder.
     */
    _saveWithBuilder(builder: QueryBuilder): Promise<void>;
    /**
     * Delete this model.
     */
    delete(): Promise<void>;
    /**
     * Force delete (soft delete mixin overrides this).
     */
    forceDelete(): Promise<void>;
    /**
     * Restore (soft delete mixin overrides this).
     */
    restore(): Promise<void>;
    exists(): boolean;
    /**
     * Mass-assign attributes respecting fillable/guarded rules.
     */
    fill(data: Partial<this>): this;
    /**
     * Force fill bypasses mass-assignment. Never use with raw user input.
     */
    forceFill(data: Partial<this>): this;
    /**
     * Get an attribute value, applying accessors when available.
     */
    getAttribute(key: string): unknown;
    /**
     * Set an attribute value, applying mutators when available.
     */
    setAttribute(key: string, value: unknown): void;
    getAttributes(): Attributes;
    getDirty(): Attributes;
    isDirty(key?: string): boolean;
    isClean(key?: string): boolean;
    wasChanged(key?: string): boolean;
    /**
     * Re-fetch this record as a new instance.
     */
    fresh(): Promise<this>;
    /**
     * Refresh this instance in-place.
     */
    refresh(): Promise<void>;
    toObject(): Attributes;
    toJSON(): Record<string, unknown>;
    toString(): string;
    is(other: Model): boolean;
    isNot(other: Model): boolean;
    clone(): this;
    protected hasOne<T extends Model>(RelatedModel: ModelConstructor<T>, foreignKey?: string, localKey?: string): RelationBuilder<T>;
    protected hasMany<T extends Model>(RelatedModel: ModelConstructor<T>, foreignKey?: string, localKey?: string): RelationBuilder<T>;
    protected belongsTo<T extends Model>(RelatedModel: ModelConstructor<T>, foreignKey?: string, ownerKey?: string): RelationBuilder<T>;
    protected belongsToMany<T extends Model>(RelatedModel: ModelConstructor<T>, pivotTable?: string, foreignKey?: string, relatedKey?: string): ManyToManyRelationBuilder<T>;
    protected hasManyThrough<T extends Model>(FinalModel: ModelConstructor<T>, ThroughModel: ModelConstructor<Model>, firstKey: string, secondKey: string): RelationBuilder<T>;
    protected hasOneThrough<T extends Model>(FinalModel: ModelConstructor<T>, ThroughModel: ModelConstructor<Model>, firstKey: string, secondKey: string): RelationBuilder<T>;
    setRelation(name: string, value: unknown): void;
    getRelation<T = unknown>(name: string): T;
    private syncOriginal;
    /** @internal */
    static applyGlobalScopes<T>(this: typeof Model, qb: QueryBuilder<T>, disabled?: Set<string>): QueryBuilder<T>;
    /** @internal */
    static queryWithoutScopes<T extends Model>(this: typeof Model, disabled: Set<string>): QueryBuilder<T>;
    /** @internal */
    static hydrateQuery<T extends Model>(this: typeof Model, qb: QueryBuilder): QueryBuilder<T>;
    /** @internal */
    static hydrate<T extends Model>(this: typeof Model, attrs: Attributes): T;
    /** @internal */
    static applyLocalScopeProxy<T extends Model>(this: typeof Model, qb: QueryBuilder<T>): QueryBuilder<T>;
    private static callHook;
    /** @internal for SoftDeletes */
    static callRestoringHook(model: Model): Promise<void>;
    /** @internal for SoftDeletes */
    static callRestoredHook(model: Model): Promise<void>;
    private static eagerLoad;
    private static eagerLoadRelation;
    private static eagerLoadCount;
}
export {};
//# sourceMappingURL=Model.d.ts.map