import { Entity } from '../binding';
import type { EntityManager } from '../EntityManager';
import { Class } from '../util';
import { PersistentError } from '../error';
import type { Node } from './Node';
/**
 * An abstract Query which allows retrieving results
 */
export declare abstract class Query<T extends Entity> {
    readonly entityManager: EntityManager;
    readonly resultClass: Class<T>;
    static readonly MAX_URI_SIZE = 2000;
    /**
     * @param entityManager - The owning EntityManager of this query
     * @param resultClass - The result class of this query
     */
    constructor(entityManager: EntityManager, resultClass: Class<T>);
    /**
     * Add an ascending sort for the specified field to this query
     * @param field The field to sort
     * @return The resulting Query
     */
    ascending(field: string): Node<T>;
    /**
     * Add an decending sort for the specified field to this query
     * @param field The field to sort
     * @return The resulting Query
     */
    descending(field: string): Node<T>;
    /**
     * Sets the sort of the query and discard all existing paramaters
     * @param sort The new sort of the query which is an object whose keys are fields and the
     * values are either +1 for ascending order or -1 for descending order
     * @return The resulting Query
     *
     * @see http://docs.mongodb.org/manual/reference/method/cursor.sort/
     */
    sort(sort: {
        [field: string]: 1 | -1;
    }): Node<T>;
    /**
     * Sets the offset of the query, i.e. how many elements should be skipped
     * @param offset The offset of this query
     * @return The resulting Query
     *
     * @see http://docs.mongodb.org/manual/reference/method/cursor.skip/
     */
    offset(offset: number): Node<T>;
    /**
     * Sets the limit of this query, i.e hox many objects should be returnd
     * @param limit The limit of this query
     * @return The resulting Query
     *
     * @see http://docs.mongodb.org/manual/reference/method/cursor.limit/
     */
    limit(limit: number): Node<T>;
    /**
     * Execute the query and return the query results as a List
     *
     * Note: All local unsaved changes on matching objects, will be discarded.
     *
     * @param [options] The query options
     * @param [options.depth=0] The object depth which will be loaded. Depth 0 load only the found
     * objects, <code>true</code> loads the objects by reachability.
     * @param doneCallback Called when the operation succeed.
     * @param failCallback Called when the operation failed.
     * @return A promise that will be resolved with the query result as a list
     */
    abstract resultList(options?: ResultOptions, doneCallback?: ResultListCallback<T>, failCallback?: FailCallback): Promise<T[]>;
    /**
     * Execute the query and return the query results as a List
     *
     * Note: All local unsaved changes on matching objects, will be discarded.
     *
     * @param doneCallback Called when the operation succeed.
     * @param failCallback Called when the operation failed.
     * @return A promise that will be resolved with the query result as a list
     */
    abstract resultList(doneCallback?: ResultListCallback<T>, failCallback?: FailCallback): Promise<T[]>;
    /**
     * Execute the query that returns a single result
     *
     * Note: All local unsaved changes on the matched object, will be discarded.
     *
     * @param [options] The query options
     * @param [options.depth=0] The object depth which will be loaded. Depth 0 load only the found
     * object, <code>true</code> loads the objects by reachability.
     * @param doneCallback Called when the operation succeed.
     * @param failCallback Called when the operation failed.
     * @return A promise that will be resolved with the query result as a single result
     */
    abstract singleResult(options?: ResultOptions, doneCallback?: SingleResultCallback<T>, failCallback?: FailCallback): Promise<T | null>;
    /**
     * Execute the query that returns a single result
     *
     * Note: All local unsaved changes on the matched object, will be discarded.
     *
     * @param doneCallback Called when the operation succeed.
     * @param failCallback Called when the operation failed.
     * @return A promise that will be resolved with the query result as a single result
     */
    abstract singleResult(doneCallback?: SingleResultCallback<T>, failCallback?: FailCallback): Promise<T | null>;
    /**
     * Execute the query that returns the matching objects count.
     * @param doneCallback Called when the operation succeed.
     * @param failCallback Called when there is a server-side error
     * @return The total number of matched objects
     */
    abstract count(doneCallback?: CountCallback, failCallback?: FailCallback): Promise<number>;
    abstract addOrder(field: string, order: 1 | -1): Node<T>;
    abstract addOrder(order: {
        [field: string]: 1 | -1;
    }): Node<T>;
    abstract addOffset(offset: number): Node<T>;
    abstract addLimit(limit: number): Node<T>;
}
export declare function flatArgs(args: any[]): any[];
export type ResultOptions = {
    depth?: number | boolean;
};
/**
 * The resultList callback is called, when the asynchronous query operation completes successfully
 * @param result The query result list, an empty list if no match was found
 * @return A Promise, result or undefined
 */
export type ResultListCallback<T> = (result: T[]) => Promise<any> | any;
/**
 * The singleResult callback is called, when the asynchronous query operation completes successfully
 * @param entity The matching object or null id no matching object was found
 * @return A Promise, result or undefined
 */
export type SingleResultCallback<T> = (entity: T | null) => Promise<any> | any;
/**
 * The count callback is called, when the asynchronous query operation completes successfully
 * @param count the matching object count
 * @return A Promise, result or undefined
 */
export type CountCallback = (count: number) => Promise<any> | any;
/**
 * The fail callback is called, when the asynchronous query operation is rejected by an error
 * @param error The error which reject the operation
 * @return A Promise, result or undefined
 */
export type FailCallback = (error: PersistentError) => Promise<any> | any;
/**
 * This callback is called when the network connection is closed (e.g. because of network timeout or lost Wi-Fi
 * connection)
 */
export type CompleteCallback = () => any;