import { BindingEngine, Disposable } from "aurelia-binding";
import { EventAggregator } from "aurelia-event-aggregator";
import { CancelablePromise } from "aurelia-utils";
import { TaskQueue } from "aurelia-task-queue";
import { EntityService } from "./entity-service";
import { Sorting } from "./sorting";
import { FilterQuery } from "./filter-query";
import { FilterBinding } from "./filter-binding";
export declare class EntityCollector<E extends Object> extends EventAggregator implements Disposable {
    static ENTITIES_LOADED: string;
    static SCROLL_RETRIEVE_INCREMENT: number;
    private bindingEngine;
    private taskQueue;
    private entityService;
    private currentFilter;
    private defaultFilter;
    private activationPromise;
    private loadCancelables;
    private countCancelables;
    private disposables;
    sorting: Sorting;
    limit: number;
    skip: number;
    countTotal: number;
    countFilter: number;
    entities: E[];
    bindings: Object;
    properties: string[];
    loading: boolean;
    constructor(bindingEngine: BindingEngine, taskQueue: TaskQueue, entityService: EntityService<E>, sorting?: Sorting, defaultFilter?: FilterQuery, properties?: string[]);
    setDefaultFilter(filter: FilterQuery): void;
    setSorting(sorting: Sorting): void;
    setProperties(properties: string[]): void;
    on<V>(property: string, callback: (filter: FilterQuery, value: V) => void, autoRetrieve?: boolean): EntityCollector<E>;
    onCollection<V>(property: string, callback: (filter: FilterQuery, value: V[]) => void, autoRetrieve?: boolean): EntityCollector<E>;
    count(filter?: FilterQuery): CancelablePromise<number>;
    applyFilter(callback: (FilterQuery, any) => void, value: any): void;
    activate(filter: FilterBinding, filterMapper?: Function): void;
    save(name: string): FilterBinding;
    reset(): void;
    dispose(): void;
    retrieve(limit?: number, skip?: number): Promise<E[]>;
    retrieveMore(increment?: number): Promise<number>;
    hasMore(): boolean;
    protected replaceEntities(entities: E[]): E[];
    protected concatEntities(entities: E[]): E[];
    protected load(limit: number, skip: number): Promise<E[]>;
}