import type BaseRepository from "./baseRepository.ts";
import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
import type { RepositoryQuery } from "./repositoryQuery.ts";
import type { QueryOptions, QueryWhere } from "./types.ts";
type RelatedRecord = {
    id: unknown;
    get<K extends string>(key: K): unknown;
};
interface RelatedModelClass<TRelated extends object, RelatedKey extends keyof TRelated & string> {
    name: string;
    repository(): BaseRepository<TRelated, RelatedKey>;
    create(attributes: Record<string, unknown>, forced?: Record<string, unknown>): Promise<RelatedRecord>;
    newFromRecord(record: TRelated, exists?: boolean): RelatedRecord;
}
interface RelationHost<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
    readonly id: TEntity[PrimaryKey];
    get<K extends keyof TEntity>(key: K): TEntity[K];
    getRepository(): BaseRepository<TEntity, PrimaryKey>;
}
type RelationKind = "hasMany" | "hasOne" | "belongsTo" | "belongsToMany" | "hasManyThrough" | "morphMany" | "morphOne" | "morphTo";
type ExistsClause = {
    sql: string;
    params: unknown[];
};
declare class HasManyRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TChild extends object, ChildKey extends keyof TChild & string> {
    private readonly parent;
    private readonly related;
    readonly relation: HasManyRelation<TParent, TChild, ParentKey, keyof TChild & string>;
    readonly kind: RelationKind;
    private extraWhere;
    private extraOptions;
    constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TChild, ChildKey>, relation: HasManyRelation<TParent, TChild, ParentKey, keyof TChild & string>);
    where(where: QueryWhere<TChild>): this;
    orderBy(orderBy: QueryOptions<TChild>["orderBy"]): this;
    limit(limit: number): this;
    applyEagerLoad(query: RepositoryQuery<TParent, ParentKey>, alias: string): void;
    hydrateEager(row: Record<string, unknown>, alias: string): unknown;
    toExistsClause(parentTable: string): ExistsClause;
    private scopedQuery;
    get(): Promise<RelatedRecord[]>;
    first(): Promise<RelatedRecord | null>;
    count(): Promise<number>;
    pluck(column: string): Promise<unknown[]>;
    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
    value(column: string): Promise<unknown>;
    then(onfulfilled?: ((value: RelatedRecord[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
    create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
    save(related: RelatedRecord | (Record<string, unknown> & {
        save?: () => Promise<unknown>;
        mergeAttributes?: (patch: Record<string, unknown>) => unknown;
    })): Promise<RelatedRecord>;
    createMany(records: ReadonlyArray<Record<string, unknown>>): Promise<RelatedRecord[]>;
}
declare class HasOneRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TChild extends object, ChildKey extends keyof TChild & string> {
    readonly relation: HasOneRelation<TParent, TChild, ParentKey, keyof TChild & string>;
    readonly kind: RelationKind;
    private readonly inner;
    constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TChild, ChildKey>, relation: HasOneRelation<TParent, TChild, ParentKey, keyof TChild & string>);
    where(where: QueryWhere<TChild>): this;
    orderBy(orderBy: QueryOptions<TChild>["orderBy"]): this;
    applyEagerLoad(query: RepositoryQuery<TParent, ParentKey>, alias: string): void;
    hydrateEager(row: Record<string, unknown>, alias: string): unknown;
    toExistsClause(parentTable: string): ExistsClause;
    get(): Promise<RelatedRecord | null>;
    first(): Promise<RelatedRecord | null>;
    count(): Promise<number>;
    pluck(column: string): Promise<unknown[]>;
    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
    value(column: string): Promise<unknown>;
    then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
    create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
    save(related: RelatedRecord | Record<string, unknown>): Promise<RelatedRecord>;
}
declare class BelongsToRelationQuery<TChild extends object, ChildKey extends keyof TChild & string, TParent extends object, ParentKey extends keyof TParent & string> {
    private readonly parent;
    private readonly related;
    readonly relation: BelongsToRelation<TChild, TParent, keyof TChild & string, ParentKey>;
    readonly kind: RelationKind;
    private extraWhere;
    private extraOptions;
    constructor(parent: RelationHost<TChild, ChildKey>, related: RelatedModelClass<TParent, ParentKey>, relation: BelongsToRelation<TChild, TParent, keyof TChild & string, ParentKey>);
    where(where: QueryWhere<TParent>): this;
    orderBy(orderBy: QueryOptions<TParent>["orderBy"]): this;
    applyEagerLoad(query: RepositoryQuery<TChild, ChildKey>, alias: string): void;
    hydrateEager(row: Record<string, unknown>, alias: string): unknown;
    toExistsClause(parentTable: string): ExistsClause;
    get(): Promise<RelatedRecord | null>;
    first(): Promise<RelatedRecord | null>;
    pluck(column: string): Promise<unknown[]>;
    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
    value(column: string): Promise<unknown>;
    private relatedQuery;
    then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
    associate(owner: {
        id?: unknown;
    } | RelatedRecord): Promise<void>;
    dissociate(): Promise<void>;
}
declare class BelongsToManyRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TRelated extends object, RelatedKey extends keyof TRelated & string, Pivot extends object> {
    private readonly parent;
    private readonly related;
    readonly relation: BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, keyof Pivot & string, keyof Pivot & string>;
    readonly kind: RelationKind;
    private extraWhere;
    private extraOptions;
    private pivotValues;
    constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TRelated, RelatedKey>, relation: BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, keyof Pivot & string, keyof Pivot & string>);
    where(where: QueryWhere<TRelated>): this;
    orderBy(orderBy: QueryOptions<TRelated>["orderBy"]): this;
    applyEagerLoad(query: RepositoryQuery<TParent, ParentKey>, alias: string): void;
    withPivotValues(values: Record<string, unknown>): this;
    hydrateEager(row: Record<string, unknown>, alias: string): unknown;
    toExistsClause(parentTable: string): ExistsClause;
    private connection;
    get(): Promise<RelatedRecord[]>;
    first(): Promise<RelatedRecord | null>;
    count(): Promise<number>;
    pluck(column: string): Promise<unknown[]>;
    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
    value(column: string): Promise<unknown>;
    private relatedQuery;
    then(onfulfilled?: ((value: RelatedRecord[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
    attach(ids: unknown | readonly unknown[]): Promise<void>;
    toggle(ids: unknown | readonly unknown[]): Promise<void>;
    detach(ids?: unknown | readonly unknown[]): Promise<void>;
    sync(ids: readonly unknown[]): Promise<void>;
    create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
}
declare class MorphManyRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TChild extends object, ChildKey extends keyof TChild & string> {
    private readonly parent;
    private readonly related;
    readonly relation: MorphManyRelation<TParent, TChild, ParentKey, keyof TChild & string, keyof TChild & string>;
    readonly kind: RelationKind;
    private extraWhere;
    private extraOptions;
    constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TChild, ChildKey>, relation: MorphManyRelation<TParent, TChild, ParentKey, keyof TChild & string, keyof TChild & string>);
    where(where: QueryWhere<TChild>): this;
    applyEagerLoad(query: RepositoryQuery<TParent, ParentKey>, alias: string): void;
    hydrateEager(row: Record<string, unknown>, alias: string): unknown;
    toExistsClause(parentTable: string): ExistsClause;
    private scopedQuery;
    get(): Promise<RelatedRecord[]>;
    first(): Promise<RelatedRecord | null>;
    count(): Promise<number>;
    pluck(column: string): Promise<unknown[]>;
    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
    value(column: string): Promise<unknown>;
    then(onfulfilled?: ((value: RelatedRecord[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
    create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
}
declare class MorphOneRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TChild extends object, ChildKey extends keyof TChild & string> {
    readonly relation: MorphOneRelation<TParent, TChild, ParentKey, keyof TChild & string, keyof TChild & string>;
    readonly kind: RelationKind;
    private readonly inner;
    constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TChild, ChildKey>, relation: MorphOneRelation<TParent, TChild, ParentKey, keyof TChild & string, keyof TChild & string>);
    where(where: QueryWhere<TChild>): this;
    applyEagerLoad(query: RepositoryQuery<TParent, ParentKey>, alias: string): void;
    hydrateEager(row: Record<string, unknown>, alias: string): unknown;
    toExistsClause(parentTable: string): ExistsClause;
    get(): Promise<RelatedRecord | null>;
    first(): Promise<RelatedRecord | null>;
    count(): Promise<number>;
    pluck(column: string): Promise<unknown[]>;
    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
    value(column: string): Promise<unknown>;
    then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
    create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
}
declare class MorphToRelationQuery<TChild extends object, ChildKey extends keyof TChild & string> {
    private readonly parent;
    private readonly relatedByType;
    readonly relation: MorphToRelation<TChild, keyof TChild & string, keyof TChild & string>;
    readonly kind: RelationKind;
    private extraWhere;
    constructor(parent: RelationHost<TChild, ChildKey>, relatedByType: Record<string, RelatedModelClass<Record<string, unknown>, "id">>, relation: MorphToRelation<TChild, keyof TChild & string, keyof TChild & string>);
    where(where: QueryWhere<Record<string, unknown>>): this;
    applyEagerLoad(query: RepositoryQuery<TChild, ChildKey>, alias: string): void;
    hydrateEager(row: Record<string, unknown>, alias: string): unknown;
    toExistsClause(parentTable: string): ExistsClause;
    get(): Promise<RelatedRecord | null>;
    pluck(column: string): Promise<unknown[]>;
    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
    value(column: string): Promise<unknown>;
    private relatedForCurrentType;
    private relatedQuery;
    then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
}
declare class HasManyThroughRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TFar extends object, FarKey extends keyof TFar & string> {
    private readonly parent;
    private readonly related;
    readonly relation: HasManyThroughRelation<TParent, TFar, ParentKey, string, string, keyof TFar & string>;
    readonly kind: RelationKind;
    private extraWhere;
    private extraOptions;
    constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TFar, FarKey>, relation: HasManyThroughRelation<TParent, TFar, ParentKey, string, string, keyof TFar & string>);
    where(where: QueryWhere<TFar>): this;
    orderBy(orderBy: QueryOptions<TFar>["orderBy"]): this;
    limit(limit: number): this;
    applyEagerLoad(query: RepositoryQuery<TParent, ParentKey>, alias: string): void;
    hydrateEager(row: Record<string, unknown>, alias: string): unknown;
    toExistsClause(parentTable: string): ExistsClause;
    get(): Promise<RelatedRecord[]>;
    first(): Promise<RelatedRecord | null>;
    count(): Promise<number>;
    pluck(column: string): Promise<unknown[]>;
    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
    value(column: string): Promise<unknown>;
    private farRows;
    then(onfulfilled?: ((value: RelatedRecord[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
}
type AnyRelationQuery = {
    kind: RelationKind;
    applyEagerLoad(query: unknown, alias: string): void;
    hydrateEager(row: Record<string, unknown>, alias: string): unknown;
    get(): Promise<unknown>;
    toExistsClause(parentTable: string): ExistsClause;
    where?(where: Record<string, unknown>): unknown;
    then?: (onfulfilled?: ((value: unknown) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null) => Promise<unknown>;
};
export type { AnyRelationQuery, RelatedModelClass, RelatedRecord, RelationHost };
export { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuery, HasManyThroughRelationQuery, HasOneRelationQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery, };