import Model, { ModelType } from "./Model.js";
import ModelQuery, { ModelFieldData, ModelQueryResult } from "./ModelQuery.js";
export default abstract class ModelRelation<S extends Model, O extends Model, R extends O | O[] | null> {
    protected readonly _model: S;
    protected readonly foreignModelType: ModelType<O>;
    protected readonly dbProperties: RelationDatabaseProperties;
    protected readonly queryModifiers: QueryModifier<O>[];
    protected readonly filters: ModelFilter<O>[];
    protected cachedModels?: O[];
    protected constructor(model: S, foreignModelType: ModelType<O>, dbProperties: RelationDatabaseProperties);
    abstract clone(): ModelRelation<S, O, R>;
    constraint(queryModifier: QueryModifier<O>): this;
    filter(modelFilter: ModelFilter<O>): this;
    protected makeQuery(): ModelQuery<O>;
    getModelId(): ModelFieldData;
    protected applyRegularConstraints(query: ModelQuery<O>): void;
    get(): Promise<R>;
    getOrFail(): R;
    protected abstract collectionToOutput(models: O[]): R;
    eagerLoad(relations: ModelRelation<S, O, R>[], subRelations?: string[]): Promise<ModelQueryResult<O>>;
    populate(models: ModelQueryResult<O>): Promise<void>;
    count(): Promise<number>;
    has(model: O): Promise<boolean>;
}
export declare class OneModelRelation<S extends Model, O extends Model> extends ModelRelation<S, O, O | null> {
    constructor(model: S, foreignModelType: ModelType<O>, dbProperties: RelationDatabaseProperties);
    clone(): OneModelRelation<S, O>;
    protected collectionToOutput(models: O[]): O | null;
    set(model: O): Promise<void>;
    clear(): Promise<void>;
}
export declare class ManyModelRelation<S extends Model, O extends Model> extends ModelRelation<S, O, O[]> {
    protected readonly paginatedCache: {
        [perPage: number]: {
            [pageNumber: number]: ModelQueryResult<O> | undefined;
        } | undefined;
    };
    constructor(model: S, foreignModelType: ModelType<O>, dbProperties: RelationDatabaseProperties);
    clone(): ManyModelRelation<S, O>;
    cloneReduceToOne(): OneModelRelation<S, O>;
    protected collectionToOutput(models: O[]): O[];
    paginate(page: number, perPage: number): Promise<ModelQueryResult<O>>;
}
export declare class ManyThroughModelRelation<S extends Model, O extends Model> extends ManyModelRelation<S, O> {
    protected readonly dbProperties: PivotRelationDatabaseProperties;
    constructor(model: S, foreignModelType: ModelType<O>, dbProperties: PivotRelationDatabaseProperties);
    clone(): ManyThroughModelRelation<S, O>;
    cloneReduceToOne(): OneModelRelation<S, O>;
    protected applyRegularConstraints(query: ModelQuery<O>): void;
    eagerLoad(relations: ModelRelation<S, O, O[]>[], subRelations?: string[]): Promise<ModelQueryResult<O>>;
    populate(models: ModelQueryResult<O>): Promise<void>;
}
export declare class RecursiveModelRelation<M extends Model> extends ManyModelRelation<M, M> {
    private readonly reverse;
    constructor(model: M, foreignModelType: ModelType<M>, dbProperties: RelationDatabaseProperties, reverse?: boolean);
    clone(): RecursiveModelRelation<M>;
    populate(models: ModelQueryResult<M>): Promise<void>;
}
export declare type QueryModifier<M extends Model> = (query: ModelQuery<M>) => ModelQuery<M>;
export declare type ModelFilter<O extends Model> = (model: O) => boolean | Promise<boolean>;
export declare type RelationDatabaseProperties = {
    localKey: string;
    foreignKey: string;
};
export declare type PivotRelationDatabaseProperties = RelationDatabaseProperties & {
    pivotTable: string;
    localPivotKey: string;
    foreignPivotKey: string;
};