import type BaseRepository from "./baseRepository.ts";
import type { AnyRelationQuery, RelatedModelClass } from "./relationQuery.ts";
import { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuery, HasManyThroughRelationQuery, HasOneRelationQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery } from "./relationQuery.ts";
import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation } from "./relationships.ts";
import type { RepositoryQuery } from "./repositoryQuery.ts";
import type { QueryOptions, QueryWhere } from "./types.ts";
type CastType = "date" | "datetime" | "json" | "bool" | "boolean" | "integer" | "int" | "hashed";
type LoadedAttributes = Record<string, unknown>;
type ModelCasts = Partial<Record<string, CastType>>;
type GlobalScopeFn<TEntity extends object, PrimaryKey extends keyof TEntity & string> = (query: RepositoryQuery<TEntity, PrimaryKey>) => RepositoryQuery<TEntity, PrimaryKey>;
type ModelClassType<TEntity extends object, PrimaryKey extends keyof TEntity & string> = typeof Model & (new (attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean) => Model<TEntity, PrimaryKey>);
interface ModelConstructor<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>> extends ModelClassType<TEntity, PrimaryKey> {
    new (attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean): TModel;
}
type AnyModel = Model<Record<string, unknown>, "id">;
type RelatedRef<TRelated extends object, RelatedKey extends keyof TRelated & string> = RelatedModelClass<TRelated, RelatedKey> | string | (() => RelatedModelClass<TRelated, RelatedKey>);
type RelationNameInput = string | readonly string[];
type ModelObserver = {
    retrieved?: (model: AnyModel) => unknown;
    creating?: (model: AnyModel) => unknown;
    created?: (model: AnyModel) => unknown;
    updating?: (model: AnyModel) => unknown;
    updated?: (model: AnyModel) => unknown;
    saving?: (model: AnyModel) => unknown;
    saved?: (model: AnyModel) => unknown;
    deleting?: (model: AnyModel) => unknown;
    deleted?: (model: AnyModel) => unknown;
};
/** Alias for `hasMany("Name")` when `Name` is not `constructor.name` or `$morphClass`. */
declare function registerModelClass(name: string, model: object): void;
declare function hydrateValue(value: unknown, cast: CastType): unknown;
declare function dehydrateValue(value: unknown, cast: CastType): unknown;
declare function filterMassAssignable(fillable: readonly string[] | undefined, guarded: readonly string[] | true | undefined, input: LoadedAttributes): LoadedAttributes;
declare function applyCasts(values: LoadedAttributes, casts: ModelCasts, direction: "hydrate" | "dehydrate"): LoadedAttributes;
declare class ModelQuery {
    private readonly modelClass;
    readonly query: RepositoryQuery<Record<string, unknown>, "id">;
    private readonly eager;
    constructor(modelClass: object, query: RepositoryQuery<Record<string, unknown>, "id">);
    with(...relations: RelationNameInput[]): this;
    where(input: QueryWhere<object> | ((builder: import("./whereBuilder.ts").WhereBuilder<object>) => void)): this;
    orWhere(input: QueryWhere<object> | ((builder: import("./whereBuilder.ts").WhereBuilder<object>) => void)): this;
    orderBy(orderBy: QueryOptions<object>["orderBy"]): this;
    limit(limit: number): this;
    offset(offset: number): this;
    whereNull(column: string): this;
    whereNotNull(column: string): this;
    whereIn(column: string, values: readonly unknown[]): this;
    whereNotIn(column: string, values: readonly unknown[]): this;
    groupBy(groupBy: QueryOptions<object>["groupBy"]): this;
    having(having: QueryWhere<object>): this;
    join(left: `${string}.${string}`, right: `${string}.${string}`): this;
    leftJoin(left: `${string}.${string}`, right: `${string}.${string}`): this;
    paginate(options: {
        page: number;
        perPage: number;
    }): Promise<{
        data: Array<Model<Record<string, unknown>, "id">>;
        meta: Awaited<ReturnType<RepositoryQuery<Record<string, unknown>, "id">["paginate"]>>["meta"];
    }>;
    whereExists(sql: string, params?: readonly unknown[]): this;
    whereNotExists(sql: string, params?: readonly unknown[]): this;
    whereHas(name: string, constrain?: (query: AnyRelationQuery) => void): this;
    has(name: string): this;
    doesntHave(name: string): this;
    whereDoesntHave(name: string, constrain?: (query: AnyRelationQuery) => void): this;
    withHasMany(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withHasMany"]>): this;
    withBelongsTo(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withBelongsTo"]>): this;
    withBelongsToMany(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withBelongsToMany"]>): this;
    withMorphMany(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withMorphMany"]>): this;
    withMorphOne(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withMorphOne"]>): this;
    withMorphTo(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withMorphTo"]>): this;
    withHasManyThrough(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withHasManyThrough"]>): this;
    withTrashed(): this;
    onlyTrashed(): this;
    get(): Promise<Array<Model<Record<string, unknown>, "id">>>;
    private hydrateRows;
    first(): Promise<Model<Record<string, unknown>, "id"> | null>;
    count(): Promise<number>;
    pluck(column: string): Promise<unknown[]>;
    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
    value(column: string): Promise<unknown>;
    find(id: unknown): Promise<Model<Record<string, unknown>, "id"> | null>;
    findOrFail(id: unknown, errorFactory?: (id: unknown) => Error): Promise<Model<Record<string, unknown>, "id">>;
    then(onfulfilled?: ((value: Array<Model<Record<string, unknown>, "id">>) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
    withCount(name: string, alias?: string): this;
    private constrainExists;
}
declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
    protected attributes: TEntity;
    protected readonly repository: BaseRepository<TEntity, PrimaryKey>;
    static $fillable?: readonly string[];
    static $guarded?: readonly string[] | true;
    static $casts: ModelCasts;
    static $timestamps: boolean;
    static $hidden?: readonly string[];
    static $visible?: readonly string[];
    static $appends?: readonly string[];
    static $morphClass?: string;
    private _exists;
    private readonly loadedRelations;
    private hiddenOverrides;
    private visibleOverrides;
    private appended;
    constructor(attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean);
    getRepository(): BaseRepository<TEntity, PrimaryKey>;
    get $exists(): boolean;
    get<K extends keyof TEntity>(key: K): TEntity[K];
    get id(): TEntity[PrimaryKey];
    toObject(): TEntity;
    toArray(): Record<string, unknown>;
    toJSON(): Record<string, unknown>;
    makeHidden(...keys: string[]): this;
    makeVisible(...keys: string[]): this;
    append(...keys: string[]): this;
    protected primaryKey(): PrimaryKey;
    protected static primaryKeyField(this: object): string;
    protected static hydrateAttributes<TEntity extends object>(this: object, attributes: TEntity): TEntity;
    protected static dehydrateAttributes(this: object, attributes: LoadedAttributes): LoadedAttributes;
    protected static fromRecord<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object, record: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean): Model<TEntity, PrimaryKey>;
    static boot(): void;
    static observe(this: object, observer: ModelObserver): void;
    static addGlobalScope<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object, _name: string, scope: GlobalScopeFn<TEntity, PrimaryKey>): void;
    static repository<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object): BaseRepository<TEntity, PrimaryKey>;
    static query(this: object): ModelQuery;
    static newFromRecord(this: object, record: object, exists?: boolean): Model<Record<string, unknown>, "id">;
    static create(this: object, attributes: Record<string, unknown>, forced?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
    static with(this: object, ...relations: RelationNameInput[]): ModelQuery;
    static withTrashed(this: object): ModelQuery;
    static onlyTrashed(this: object): ModelQuery;
    static chunk(this: object, count: number, callback: (models: Array<Model<Record<string, unknown>, "id">>) => Promise<boolean | void>): Promise<void>;
    static cursorPaginate(this: object, options: {
        perPage: number;
        cursor?: unknown;
    }): Promise<{
        data: Array<Model<Record<string, unknown>, "id">>;
        meta: {
            per_page: number;
            next_cursor: unknown;
            prev_cursor: unknown;
            has_more: boolean;
        };
    }>;
    static whereHas(this: object, name: string, constrain?: (query: AnyRelationQuery) => void): ModelQuery;
    static has(this: object, name: string): ModelQuery;
    static doesntHave(this: object, name: string): ModelQuery;
    static whereDoesntHave(this: object, name: string, constrain?: (query: AnyRelationQuery) => void): ModelQuery;
    static find(this: object, id: unknown): Promise<Model<Record<string, unknown>, "id"> | null>;
    static findOrFail(this: object, id: unknown, errorFactory?: (id: unknown) => Error): Promise<Model<Record<string, unknown>, "id">>;
    static all(this: object, options?: Omit<QueryOptions<object>, "where">): Promise<Array<Model<Record<string, unknown>, "id">>>;
    static where(this: object, where: QueryWhere<object>): ModelQuery;
    static count(this: object): Promise<number>;
    static pluck(this: object, column: string): Promise<unknown[]>;
    static pluck(this: object, column: string, keyBy: string): Promise<Map<unknown, unknown>>;
    static value(this: object, column: string): Promise<unknown>;
    static firstWhere(this: object, where: QueryWhere<object>, options?: Omit<QueryOptions<object>, "where">): Promise<Model<Record<string, unknown>, "id"> | null>;
    static firstOrNew(this: object, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
    static firstOrCreate(this: object, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
    static updateOrCreate(this: object, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
    save(): Promise<this>;
    update(changes: Partial<TEntity>): Promise<this>;
    delete(): Promise<boolean>;
    forceDelete(): Promise<boolean>;
    restore(): Promise<this | null>;
    loadHasMany<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasManyRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): Promise<this & Record<Alias, TChild[]>>;
    loadHasOne<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasOneRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): Promise<this & Record<Alias, TChild | undefined>>;
    loadBelongsTo<TParent extends object, ForeignKey extends keyof TEntity & string, OwnerKey extends keyof TParent & string, Alias extends string>(as: Alias, relation: BelongsToRelation<TEntity, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<this & Record<Alias, TParent | undefined>>;
    loadBelongsToMany<TRelated extends object, Pivot extends object, ParentKey extends keyof TEntity & string, RelatedKey extends keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string, Alias extends string>(as: Alias, relation: BelongsToManyRelation<TEntity, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>, relatedRepository: BaseRepository<TRelated, RelatedKey>, options?: Omit<QueryOptions<TRelated>, "where">): Promise<this & Record<Alias, TRelated[]>>;
    hasMany<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, foreignKey?: keyof TRelated & string, localKey?: PrimaryKey): HasManyRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
    hasOne<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, foreignKey?: keyof TRelated & string, localKey?: PrimaryKey): HasOneRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
    belongsTo<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, foreignKey?: keyof TEntity & string, ownerKey?: RelatedKey): BelongsToRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
    hasManyThrough<TRelated extends object, TThrough extends object, RelatedKey extends keyof TRelated & string, ThroughKey extends keyof TThrough & string>(related: RelatedRef<TRelated, RelatedKey>, through: RelatedRef<TThrough, ThroughKey>, firstKey?: string, secondKey?: keyof TRelated & string, localKey?: PrimaryKey, secondLocalKey?: ThroughKey): HasManyThroughRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
    belongsToMany<TRelated extends object, RelatedKey extends keyof TRelated & string, Pivot extends object = Record<string, unknown>>(related: RelatedRef<TRelated, RelatedKey>, pivotTable?: string, foreignPivotKey?: keyof Pivot & string, relatedPivotKey?: keyof Pivot & string): BelongsToManyRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey, Pivot>;
    morphMany<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, morphName: string, typeKey?: keyof TRelated & string, idKey?: keyof TRelated & string, morphType?: string): MorphManyRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
    morphOne<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, morphName: string, typeKey?: keyof TRelated & string, idKey?: keyof TRelated & string, morphType?: string): MorphOneRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
    morphTo(relatedByType: Record<string, RelatedRef<Record<string, unknown>, "id">>, morphName?: string, typeKey?: keyof TEntity & string, idKey?: keyof TEntity & string): MorphToRelationQuery<TEntity, PrimaryKey>;
    load(...names: RelationNameInput[]): Promise<this>;
    loaded<T = unknown>(name: string): T | undefined;
    setLoaded(name: string, value: unknown): this;
    mergeAttributes(patch: Partial<TEntity>): this;
}
/** Binds a Model class to its table/connection and names it for `hasMany("User")`. */
declare function registerModelRepository<TModelClass>(model: TModelClass, repository: object): TModelClass;
export { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuery, HasManyThroughRelationQuery, HasOneRelationQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery, } from "./relationQuery.ts";
export type { CastType, GlobalScopeFn, ModelClassType, ModelConstructor };
export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, ModelQuery, registerModelClass, registerModelRepository, };