import { AggregationOperator } from '../model/config';
export { OrderDirection } from '../model/implementation/order';
import { OrderDirection } from '../model/implementation/order';
import { QueryNode } from './base';
import { VariableQueryNode } from './variables';
/**
 * A node that evaluates to a list with query nodes as list entries
 */
export declare class ListQueryNode extends QueryNode {
    readonly itemNodes: ReadonlyArray<QueryNode>;
    constructor(itemNodes: ReadonlyArray<QueryNode>);
    static readonly EMPTY: ListQueryNode;
    describe(): string;
}
/**
 * A node to filter, order, limit and map a list
 *
 * itemVariable can be used inside filterNode and innerNode to access the current item
 */
export declare class TransformListQueryNode extends QueryNode {
    constructor(params: {
        listNode: QueryNode;
        innerNode?: QueryNode;
        filterNode?: QueryNode;
        orderBy?: OrderSpecification;
        skip?: number;
        maxCount?: number;
        itemVariable?: VariableQueryNode;
    });
    readonly listNode: QueryNode;
    readonly innerNode: QueryNode;
    readonly filterNode: QueryNode;
    readonly orderBy: OrderSpecification;
    readonly skip: number;
    readonly maxCount: number | undefined;
    readonly itemVariable: VariableQueryNode;
    describe(): string;
}
export declare class OrderClause extends QueryNode {
    readonly valueNode: QueryNode;
    readonly direction: OrderDirection;
    constructor(valueNode: QueryNode, direction: OrderDirection);
    private describeDirection;
    describe(): string;
}
export declare class OrderSpecification extends QueryNode {
    readonly clauses: ReadonlyArray<OrderClause>;
    constructor(clauses: ReadonlyArray<OrderClause>);
    static readonly UNORDERED: OrderSpecification;
    isUnordered(): boolean;
    describe(): string;
}
/**
 * A node that concatenates multiple lists and evaluates to the new list
 *
 * This can be used to append items to an array by using a ListQueryNode as second item
 */
export declare class ConcatListsQueryNode extends QueryNode {
    readonly listNodes: ReadonlyArray<QueryNode>;
    constructor(listNodes: ReadonlyArray<QueryNode>);
    describe(): string;
}
/**
 * A node that evaluates to the number of items in a list
 *
 * If the listNode evaluates to null, this node evaluates to zero
 */
export declare class CountQueryNode extends QueryNode {
    readonly listNode: QueryNode;
    constructor(listNode: QueryNode);
    describe(): string;
}
/**
 * A node that evaluates to the first item of a list, or NULL if the list is empty
 */
export declare class FirstOfListQueryNode extends QueryNode {
    readonly listNode: QueryNode;
    constructor(listNode: QueryNode);
    describe(): string;
}
/**
 * A node that evaluates to a specific item of a list, or NULL if the list is empty
 */
export declare class ListItemQueryNode extends QueryNode {
    readonly listNode: QueryNode;
    readonly index: number;
    constructor(listNode: QueryNode, index: number);
    describe(): string;
}
interface AggregationQueryNodeParams {
    sort?: boolean;
}
export declare class AggregationQueryNode extends QueryNode {
    readonly listNode: QueryNode;
    readonly operator: AggregationOperator;
    readonly sort: boolean;
    constructor(listNode: QueryNode, operator: AggregationOperator, options?: AggregationQueryNodeParams);
    describe(): string;
}