import { IEntity, IDataClass, ICollection, ICollectionCache } from '../http/catalog.interfaces';
import { IRequest } from '../http/http-client.class';
import { Client } from './client.class';
import { Entity } from './entity.class';
import { Catalog } from './catalog.class';
export declare class Collection<T extends IEntity> {
    private meta;
    private catalog;
    private client;
    private parent;
    private cache;
    private subUrl;
    protected current: ICollection<Entity<T>>;
    request: IRequest;
    length: number;
    queryPlan: any;
    queryPath: any;
    constructor(meta: IDataClass, client: Client, catalog: Catalog, request?: IRequest);
    /**
     * Reset the collection request
     */
    reset(): void;
    /**
     * Check if a target is a collection
     * @param target The object to check if it is an instance of a collection
     */
    static isCollection(target: unknown): boolean;
    /**
     * Checks if a body is a collection
     * @param {any} body The body to check
     */
    static isCollectionLike(body: unknown): boolean;
    /**
     * Executes the query
     *
     * ####Examples:
     *
     * const promise = query.exec();
     *
     * @return {Promise}
     * @api public
     */
    exec<G>(): Promise<G | Collection<T>>;
    /**
     * fill the cache object with the current collection
     * @param collection
     */
    setCache(page: number, collection: Collection<T>): Collection<T>;
    /**
     * get the cache object
     */
    getCache(): ICollectionCache<T>;
    /**
     * Sort the collection using a specific atttribute
     * @param order The attribute to sort with
     */
    orderBy(order: string): Collection<T>;
    /**
     * Expand related attributes
     * @param attributes List of attributes to expand
     */
    expand(...attributes: string[]): Collection<T>;
    /**
     * Select attributes
     * @param attributes List of attributes to select
     */
    select(...attributes: string[]): Collection<T>;
    /**
     * Skip a number of records
     * @param nb Number of records to skip
     */
    skip(nb: number): Collection<T>;
    /**
     * Limit number of records to return
     * @param nb Number of records to return
     */
    limit(nb: number): Collection<T>;
    /**
     * creates and returns a JavaScript array where each element is an object
     * containing a set of properties and values corresponding to the attribute
     * names and values for a datastore class or an entity collection.
     * @param attrs a string containing the attribute names or paths that belong to the datastore class
     */
    toArray(attrs?: string): Collection<T>;
    /**
     * Get the entity set key from the entity set URL
     */
    getKey(): string;
    /**
     * Count number of records in the current collection
     */
    count(): Promise<number>;
    /**
     * Get the first item of the collection
     */
    first(): Promise<Entity<T>>;
    /**
     * Loop over all items of the current collection
     * @param cb The callback
     * @param pageSize Number of elements per page
     */
    forEach(cb: (item: Entity<T>, index: number, Collection: any) => void, pageSize?: number): Promise<Collection<T>>;
    /**
     * Implementation of the async iterator over the collection
     */
    [Symbol.asyncIterator](): AsyncIterator<Entity<T>>;
    /**
     * Query by a query string
     * @param {string} queryString The query string
     * @param  {...any} args List of arguments
     */
    query(queryString?: string, ...args: any[]): Collection<T>;
    /**
     * Release a collection
     */
    release(): Promise<boolean>;
    /**
     * Find by a query string
     * @param {string} queryString The query string
     * @param  {...any} args List of arguments
     */
    find(queryString: string, ...args: any[]): Promise<Entity<T>>;
    /**
     * Remove all items of the current collection
     */
    remove(): Promise<any>;
    /**
     * Get the dataclass of the current collection
     */
    getDataClass(): typeof Entity;
    /**
     * Sum the values of an attribute of the current collection
     * @param attribute Attribute that will be used to calculate the sum
     */
    sum(attribute: string): Promise<number>;
    /**
     * Calculate the max value of an attribute of the current collection
     * @param attribute Attribute that will be used to calculate the max
     */
    max(attribute: string): Promise<number>;
    /**
     * Calculate the min value of an attribute of the current collection
     * @param attribute Attribute that will be used to calculate the min
     */
    min(attribute: string): Promise<number>;
    /**
     * Method creates an array and returns in it all the distinct values
     * @param attribute
     */
    distinctValues(attribute: string): Collection<T>;
    /**
     * filter by a string
     * @param {string} queryString The query string
     */
    filter(queryString: string): Collection<T>;
    /**
     * Returns the query plan as it was passed
     */
    getQueryPath(): Collection<T>;
    /**
     * Returns the query as it was executed
     */
    getQueryPlan(): Collection<T>;
    /**
     * Method returns the arithmetic average of all the non-null values of attribute
     * @param attribute
     */
    average(attribute: string): Collection<T>;
    /**
     * The statistical calculations on the attribute or list of attributes passed as the parameter
     * @param attribute
     * @param distinct
     */
    compute(attribute: string, distinct?: string): Collection<T>;
    /**
     * Method compares the entity collection to which it is applied and the collection2 and returns a new entity collection
     * @param collectionOrEntity
     */
    and(secondOperator: Collection<T> | Entity<T>): Promise<Collection<T>>;
    /**
     * Method creates a new entity collection that contains all the entities from the entity collection
     * to which it is applied and all the entities from the collection2 entity collection
     * @param collectionOrEntity
     */
    or(secondOperator: Collection<T> | Entity<T>): Promise<Collection<T>>;
    /**
     * Method excludes from the entity collection to which it is applied the entities that are in the
     * collection2 and returns the resulting entity collection
     * @param collectionOrEntity
     */
    minus(secondOperator: Collection<T> | Entity<T>): Promise<Collection<T>>;
    /**
     * Method creates a new entity collection that contains all the entities from the entity collection
     * to which it is applied and all the entities from the collection2 entity collection
     * @param collectionOrEntity
     */
    add(secondOperator: Collection<T> | Entity<T>): Promise<Collection<T>>;
    /**
     * create entity collection and gets it's "__ENTITYSET" ID
     * @param entity
     */
    private create;
    /**
     * The all( ) method returns an object of type EntityCollection containing all
     * the entities in the datastore class to which it was applied.
     * @param collection
     */
    all(): Collection<T>;
    /**
     * Use toString method to get a string representation of the data in the entities.
     */
    toString(): Array<string>;
    get(index: number): Promise<Entity<T>>;
    /**
     * creates and returns a array of json entities where each element is an object
     * containing a set of properties and values corresponding to the attribute
     * names and values for a datastore class or an entity collection.
     * @param attrs a string containing the attribute names or paths that belong to the datastore class
     */
    toJSON(): Promise<Array<any>>;
}
//# sourceMappingURL=collection.class.d.ts.map