import { GenericType, DeleteMode, ValueType, IObjectType, ObjectLike } from "../Common/Type";
import { DbContext } from "../Data/DBContext";
import { DeferredQuery } from "../Query/DeferredQuery";
import { IQueryExpression } from "./QueryExpression/IQueryExpression";
import { IQueryVisitor } from "../Query/IQueryVisitor";
import { IQueryParameterMap } from "../Query/IQueryParameter";
import { IQueryOption } from "../Query/IQueryOption";
export declare abstract class Queryable<T = any> {
    type: GenericType<T>;
    readonly dbContext: DbContext;
    queryOption: IQueryOption;
    /**
     * equal to number of times queryable.parameter() was called.
     * represent the stack index of parameter used by current queryable
     */
    protected parameterStackIndex: number;
    /**
     * all parameter used by current queryable and it's parent.
     */
    flatParameterStacks: {
        [key: string]: any;
    };
    /**
     * parameter that is actually used by current queryable
     */
    parameters: {
        [key: string]: any;
    };
    protected parent: Queryable;
    constructor(type: GenericType<T>, parent?: Queryable);
    abstract buildQuery(queryVisitor: IQueryVisitor): IQueryExpression<T>;
    abstract hashCode(): number;
    buildParameter(queryExp: IQueryExpression, params: {
        [key: string]: any;
    }): IQueryParameterMap;
    toString(): string;
    toArray(): Promise<T[]>;
    toMap<K, V>(keySelector: (item: T) => K, valueSelector?: (item: T) => V): Promise<Map<K, V>>;
    count(): Promise<number>;
    contains(item: T): Promise<boolean>;
    sum(selector?: (item: T) => number): Promise<number>;
    max(selector?: (item: T) => number): Promise<number>;
    min(selector?: (item: T) => number): Promise<number>;
    avg(selector?: (item: T) => number): Promise<number>;
    all(predicate: (item: T) => boolean): Promise<boolean>;
    any(predicate?: (item: T) => boolean): Promise<boolean>;
    find(id: ValueType | ObjectLike<T>): Promise<T>;
    first(predicate?: (item: T) => boolean): Promise<T>;
    update(setter: {
        [key in keyof T]?: T[key] | ((item: T) => ValueType);
    }): Promise<number>;
    delete(mode: DeleteMode): Promise<number>;
    delete(predicate?: (item: T) => boolean, mode?: DeleteMode): Promise<number>;
    insertInto<TT>(type: IObjectType<TT>): Promise<number>;
    deferredToArray(): DeferredQuery<T[]>;
    deferredToMap<K, V>(keySelector: (item: T) => K, valueSelector?: (item: T) => V): DeferredQuery<Map<K, V>>;
    deferredCount(): DeferredQuery<number>;
    deferredSum(selector?: (item: T) => number): DeferredQuery<number>;
    deferredMax(selector?: (item: T) => number): DeferredQuery<number>;
    deferredMin(selector?: (item: T) => number): DeferredQuery<number>;
    deferredAvg(selector?: (item: T) => number): DeferredQuery<number>;
    deferredAll(predicate: (item: T) => boolean): DeferredQuery<boolean>;
    deferredAny(predicate?: (item: T) => boolean): DeferredQuery<boolean>;
    deferredFind(id: ValueType | ObjectLike<T>): DeferredQuery<T>;
    deferredFirst(predicate?: (item: T) => boolean): DeferredQuery<T>;
    deferredContains(item: T): DeferredQuery<boolean>;
    deferredUpdate(setter: {
        [key in keyof T]?: T[key] | ((item: T) => ValueType);
    }): DeferredQuery<number>;
    deferredDelete(mode: DeleteMode): DeferredQuery<number>;
    deferredDelete(predicate?: (item: T) => boolean, mode?: DeleteMode): DeferredQuery<number>;
    deferredInsertInto<TT>(type: IObjectType<TT>): DeferredQuery<number>;
    private cacheKey;
}
import "./Queryable.partial";
import "../Extensions/QueryableExtension";
import "../Extensions/DateExtension";
import "../Extensions/StringExtension";
import "../Extensions/ArrayItemTypeExtension";