import { Entity } from './Entity';
import { EntityConstructor, EntityMetadata, EntityObject, ID, Query } from './index';
import { List } from './List';
import { BaseRelationship } from './ORM/BaseRelationship';
import { EntityQuery } from './EntityQuery';
export interface EntityField<T extends Entity> {
    value<K extends keyof T>(entity: T, key: string): T[K] | T[K][] | string | number | undefined;
    set<K extends keyof T>(entity: T, key: T[K]): void;
}
export declare class ColumnField<T extends Entity> implements EntityField<T> {
    entity: EntityConstructor<T>;
    property: string;
    type: () => Function;
    column: string;
    constructor(entity: EntityConstructor<T>, property: string, type: () => Function, column: string);
    value<K extends keyof T>(entity: T, key: string): T[K] | T[K][] | string | number | undefined;
    set(target: T, value: T[keyof T]): void;
}
export declare class JSONField<T extends Entity> extends ColumnField<T> {
    value<K extends keyof T>(entity: T, key: string): T[K] | T[K][] | string | number | undefined;
    set(target: T, value: T[keyof T]): void;
}
export declare abstract class InverseField<T extends Entity> implements EntityField<T> {
    entity: EntityConstructor<T>;
    property: string;
    type: () => Function;
    protected constructor(entity: EntityConstructor<T>, property: string, type: () => Function);
    value<K extends keyof T>(entity: T, key: string): T[K] | T[K][] | string | number | undefined;
    abstract set(target: T, value: T[keyof T]): void;
}
export declare class PrimaryField<T extends Entity> extends ColumnField<T> {
}
export declare abstract class RelationshipField<T extends Entity, R extends Entity> extends ColumnField<T> {
    type: () => EntityConstructor<R>;
    inverseBy: string;
    abstract relationClass: typeof BaseRelationship;
    protected constructor(entity: EntityConstructor<T>, property: string, type: () => EntityConstructor<R>, inverseBy: string, column: string);
    get related(): EntityConstructor<R>;
    abstract match(entities: T[], relatedEntities: R[]): T[];
    abstract matchCounts(entities: T[], counts: T[]): T[];
    abstract getRelatedValue(relatedEntities: R[], eagerLoad: EntityQuery<T>['eagerLoad'], customQuery?: (query: Query) => void): Promise<R[]>;
    abstract getRelatedCount(relatedEntities: R[], customQuery?: (query: Query) => void): Promise<T[]>;
    abstract update(target: T): void;
}
export declare abstract class InverseRelationship<T extends Entity, R extends Entity> extends InverseField<T> {
    type: () => EntityConstructor<R>;
    inverseBy: string;
    abstract relationClass: typeof BaseRelationship;
    protected constructor(entity: EntityConstructor<T>, property: string, type: () => EntityConstructor<R>, inverseBy: string);
    get related(): EntityConstructor<R>;
    abstract match(entities: T[], relatedEntities: R[]): T[];
    abstract matchCounts(entities: T[], counts: T[]): T[];
    abstract getRelatedValue(relatedEntities: R[], eagerLoad: EntityQuery<T>['eagerLoad'], customQuery?: (query: Query) => void): Promise<R[]>;
    abstract getRelatedCount(relatedEntities: R[], customQuery?: (query: Query) => void): Promise<T[]>;
}
export declare class HasOneField<T extends Entity, R extends Entity> extends InverseRelationship<T, R> {
    relationClass: typeof HasOne;
    constructor(entity: EntityConstructor<T>, property: string, type: () => EntityConstructor<R>, inverseBy: string);
    set(target: T, value: T[keyof T]): void;
    getRelatedValue(relatedEntities: R[], eagerLoad: EntityQuery<T>['eagerLoad'], customQuery?: (query: Query) => void): Promise<R[]>;
    getRelatedCount(relatedEntities: R[], customQuery?: (query: Query) => void): Promise<T[]>;
    match(entities: T[], relatedEntities: R[]): T[];
    matchCounts(entities: T[], counts: T[]): T[];
}
export declare class HasManyField<T extends Entity, R extends Entity> extends InverseRelationship<T, R> {
    inverseBy: string;
    relationClass: typeof HasMany;
    constructor(entity: EntityConstructor<T>, property: string, type: () => EntityConstructor<R>, inverseBy: string);
    set(target: T, value: T[keyof T]): void;
    getRelatedValue(relatedEntities: R[], eagerLoad: EntityQuery<T>['eagerLoad'], customQuery?: (query: Query) => void): Promise<R[]>;
    getRelatedCount(relatedEntities: R[], customQuery?: (query: Query) => void): Promise<T[]>;
    match(entities: T[], relatedEntities: R[]): T[];
    matchCounts(entities: T[], counts: T[]): T[];
    save(items: Partial<EntityObject<R> | R>[], parent: T): Promise<R[]>;
    getQuery(parent: T): EntityQuery<R>;
}
export declare class BelongsToField<T extends Entity, R extends Entity> extends RelationshipField<T, R> {
    relationClass: typeof BelongsTo;
    constructor(entity: EntityConstructor<T>, property: string, type: () => EntityConstructor<R>, inverseBy: string, column?: string);
    set(target: T, value: T[keyof T]): void;
    update(target: T): void;
    value<K extends keyof T>(entity: T, key: string): undefined;
    getRelatedValue(parents: R[], eagerLoad: EntityQuery<T>['eagerLoad'], customQuery?: (query: Query) => void): Promise<R[]>;
    getRelatedCount(relatedEntities: R[], customQuery?: (query: Query) => void): Promise<never[]>;
    match(entities: T[], relatedEntities: R[]): T[];
    matchCounts(entities: T[], counts: T[]): T[];
    getQuery(parent: T): EntityQuery<T>;
    save(items: Partial<EntityObject<R> | R>[], parent: T): Promise<R[]>;
}
export declare class BelongsToManyField<T extends Entity, R extends Entity> extends InverseRelationship<T, R> {
    table?: string | undefined;
    parentColumn?: string | undefined;
    relatedColumn?: string | undefined;
    relationClass: typeof BelongsToMany;
    constructor(entity: EntityConstructor<T>, property: string, type: () => EntityConstructor<R>, inverseBy: string, table?: string | undefined, parentColumn?: string | undefined, relatedColumn?: string | undefined);
    set(target: T, value: T[keyof T]): void;
    getRelatedValue(parents: R[], eagerLoad: EntityQuery<T>['eagerLoad'], customQuery?: (query: Query) => void): Promise<R[]>;
    getParentForeignKey(): string;
    getRelatedForeignKey(): string;
    getRelatedCount(relatedEntities: R[], customQuery?: (query: Query) => void): Promise<T[]>;
    match(entities: T[], relatedEntities: R[]): T[];
    matchCounts(entities: T[], counts: T[]): T[];
    getPivotTable(): string;
    value<K extends keyof T>(entity: T, key: string): T[K];
    add(items: (R | ID)[], parent: T): Promise<R[]>;
    getQuery(parent: T): EntityQuery<R>;
}
export interface EntityFieldOptions {
    table?: string;
    column?: string;
}
export interface BelongsToManyFieldOptions extends EntityFieldOptions {
    foreignColumn?: string;
}
export declare class BelongsTo<T extends Entity, P extends Entity = Entity> extends BaseRelationship<T, P> {
    private instance?;
    constructor(relationship: RelationshipField<P, T>, parent: P);
    update(): void;
    static relationship<T extends Entity, R extends Entity>(metadata: EntityMetadata<T, R>, entityClass: EntityConstructor<T>, property: keyof T, type: () => EntityConstructor<R>, inverseBy: keyof R, options?: EntityFieldOptions): EntityMetadata<T, R>;
    get(): T | undefined;
    set(instance: T | number): void;
    setById(id: number): void;
    save(data?: EntityObject<T> | {} | undefined): Promise<T | undefined>;
    toJSON(): { [K in keyof T]: T[K]; } | undefined;
}
export declare class HasOne<T extends Entity, P extends Entity = Entity> extends BaseRelationship<T, P> {
    relationship: RelationshipField<P, T>;
    private instance?;
    static relationship<T extends Entity, R extends Entity>(metadata: EntityMetadata<T, R>, entityClass: EntityConstructor<T>, property: keyof T, type: () => EntityConstructor<R>, inverseBy: keyof R, options?: EntityFieldOptions): EntityMetadata<T, R>;
    get(): T | undefined;
    set(instance: T | number | undefined): void;
    setById(id: number): void;
    save(instance?: T | undefined): Promise<T | undefined>;
    toJSON(): { [K in keyof T]: T[K]; } | undefined;
}
export declare class HasMany<T extends Entity, P extends Entity = Entity> extends List<T, P> {
    relationship: HasManyField<P, T>;
    constructor(relationship: HasManyField<P, T>, parent: P);
    static relationship<T extends Entity, R extends Entity>(metadata: EntityMetadata<T, R>, entityClass: EntityConstructor<T>, property: keyof T, type: () => EntityConstructor<R>, inverseBy: keyof R, options?: EntityFieldOptions): EntityMetadata<T, R>;
    save(item: Partial<EntityObject<T> | T>): Promise<T>;
    saveMany(...items: Partial<EntityObject<T> | T>[]): Promise<T[]>;
    clear(): Promise<void>;
}
export declare class BelongsToMany<T extends Entity, P extends Entity = Entity> extends List<T, P> {
    relationship: BelongsToManyField<P, T>;
    constructor(relationship: BelongsToManyField<P, T>, parent: P);
    static relationship<T extends Entity, R extends Entity>(metadata: EntityMetadata<T, R>, entityClass: EntityConstructor<T>, property: keyof T, type: () => EntityConstructor<R>, inverseBy: keyof R, options?: BelongsToManyFieldOptions): EntityMetadata<T, R>;
    has(item: T | ID): Promise<boolean>;
    add(...items: (T | ID)[]): Promise<T[]>;
    remove(...items: (T | ID)[]): Promise<void>;
    toggle(...items: (T | ID)[]): Promise<void>;
    clear(): Promise<void>;
    sync(...items: (T | ID)[]): Promise<void>;
    syncWithoutDetaching(...items: (T | ID)[]): Promise<void>;
}
//# sourceMappingURL=Fields.d.ts.map