import { Entity } from '../entity';
import { Manager } from '../manager';
export interface QueryDataSchema {
    where?: {
        [key: string]: any;
    };
    subQueries?: {
        [key: string]: {
            query: QueryData;
            key: string;
        };
    };
    ids?: string[];
    contains?: {
        [key: string]: any[];
    };
    limit?: number;
    skip?: number;
    className?: string;
    less?: {
        [key: string]: any;
    };
    lessOrEqual?: {
        [key: string]: any;
    };
    greater?: {
        [key: string]: any;
    };
    greaterOrEqual?: {
        [key: string]: any;
    };
    pluck?: string[];
}
export declare type QueryData<TSchema extends {
    [key: string]: any;
} = QueryDataSchema> = {
    key: keyof TSchema;
    value: any;
}[];
export declare class Query<T extends Entity> {
    private _builder;
    private _className;
    static clone<TQuery extends Query<any>>(query: TQuery): TQuery;
    static fromJSON<T extends Entity = Entity>(queryData: QueryData<QueryDataSchema>): Query<T>;
    static getHash(queryData: QueryData<QueryDataSchema>): string;
    constructor(ctor: string | (new () => T));
    get json(): QueryData<QueryDataSchema>;
    get hash(): string;
    get className(): string;
    append<TKey extends keyof QueryDataSchema>(key: TKey, value: QueryDataSchema[TKey]): this;
    replace<TKey extends keyof QueryDataSchema>(key: TKey, value: QueryDataSchema[TKey]): this;
    clear<TKey extends keyof QueryDataSchema>(key: TKey): this;
    equalTo(key: string, value: any): this;
    contains(key: string, value: any[]): this;
    limit(limit: number): this;
    skip(skip: number): this;
    matchesQuery(key: string, query: Query<any>): this;
    matchesKeyInQuery(key: string, keyInQuery: string, subQuery: Query<any>): this;
    matchesEdgeQuery(edgeName: string, query: Query<any>): this;
    matchesEdgeDstQuery(edgeName: string, query: Query<any>): this;
    ids(ids: string[]): this;
    less(key: string, value: any): this;
    lessOrEqual(key: string, value: any): this;
    greater(key: string, value: any): this;
    greaterOrEqual(key: string, value: any): this;
    pluck(...keys: string[]): this;
    count(manager: Manager): Promise<number>;
    get(id: string, manager: Manager, deep?: number): Promise<T>;
    find(manager: Manager, deep?: number): Promise<T[]>;
    first(manager: Manager, deep?: number): Promise<T>;
    delete(manager: Manager): Promise<void>;
    subscribe(manager: Manager, cb: (oldValues: T, newValues: T, newValueIndex?: number) => any, deep?: number): () => any;
}