import { Field, RelationSide, RootEntityType } from '../model';
import { FieldSegment, RelationSegment } from '../model/implementation/collect-path';
import { QueryNode } from './base';
import { EntitiesIdentifierKind } from './mutations';
export declare class EntityFromIdQueryNode extends QueryNode {
    readonly rootEntityType: RootEntityType;
    readonly idNode: QueryNode;
    constructor(rootEntityType: RootEntityType, idNode: QueryNode);
    describe(): string;
}
/**
 * A node that evaluates in the list of entities of a given type. use ListQueryNode to further process them
 */
export declare class EntitiesQueryNode extends QueryNode {
    readonly rootEntityType: RootEntityType;
    constructor(rootEntityType: RootEntityType);
    describe(): string;
}
/**
 * A node that evaluates to the value of a field of an object, or NULL if it does not exist or objectNode does not
 * evaluate to an object
 *
 * Note: this is unrelated to storing the value in a property of a result object, see ObjectQueryNode
 */
export declare class FieldQueryNode extends QueryNode {
    readonly objectNode: QueryNode;
    readonly field: Field;
    constructor(objectNode: QueryNode, field: Field);
    describe(): string;
}
/**
 * A node that evaluates to the value of a field of an object, or NULL if it does not exist or objectNode does not
 * evaluate to an object
 *
 * Note: this is unrelated to storing the value in a property of a result object, see ObjectQueryNode
 */
export declare class FieldPathQueryNode extends QueryNode {
    readonly objectNode: QueryNode;
    readonly path: ReadonlyArray<Field>;
    constructor(objectNode: QueryNode, path: ReadonlyArray<Field>);
    describe(): string;
}
/**
 * A node that evaluates to the value of a property of an object, or NULL if it does not exist or objectNode does not
 * evaluate to an object
 *
 * This is equivalent to a FieldQueryNode except there does not need to be a model field. Authorization checks will not
 * be applied.
 */
export declare class PropertyAccessQueryNode extends QueryNode {
    readonly objectNode: QueryNode;
    readonly propertyName: string;
    constructor(objectNode: QueryNode, propertyName: string);
    describe(): string;
}
/**
 * A node that evaluates to the value of a property of an object, or NULL if it does not exist or objectNode does not
 * evaluate to an object
 */
export declare class DynamicPropertyAccessQueryNode extends QueryNode {
    readonly objectNode: QueryNode;
    readonly propertyNode: QueryNode;
    constructor(objectNode: QueryNode, propertyNode: QueryNode);
    describe(): string;
}
/**
 * A node that evaluates to the id of a root entity
 */
export declare class RootEntityIDQueryNode extends QueryNode {
    readonly objectNode: QueryNode;
    constructor(objectNode: QueryNode);
    describe(): string;
}
/**
 * A node that evaluates to the revision identifier of a root entity
 */
export declare class RevisionQueryNode extends QueryNode {
    readonly objectNode: QueryNode;
    constructor(objectNode: QueryNode);
    describe(): string;
}
/**
 * Evaluates to all root entities that are connected to a specific root entitity through a specific edge
 */
export declare class FollowEdgeQueryNode extends QueryNode {
    readonly relationSide: RelationSide;
    readonly sourceEntityNode: QueryNode;
    constructor(relationSide: RelationSide, sourceEntityNode: QueryNode);
    describe(): string;
}
interface TraversalQueryNodeParams {
    readonly entitiesIdentifierKind?: EntitiesIdentifierKind;
    readonly sourceEntityNode: QueryNode;
    readonly sourceIsList?: boolean;
    readonly alwaysProduceList?: boolean;
    readonly relationSegments: ReadonlyArray<RelationSegment>;
    readonly fieldSegments: ReadonlyArray<FieldSegment>;
    readonly captureRootEntities: boolean;
}
/**
 * Traverses a path of relations and other fields
 */
export declare class TraversalQueryNode extends QueryNode {
    readonly entitiesIdentifierKind: EntitiesIdentifierKind;
    readonly sourceEntityNode: QueryNode;
    readonly relationSegments: ReadonlyArray<RelationSegment>;
    readonly fieldSegments: ReadonlyArray<FieldSegment>;
    readonly captureRootEntity: boolean;
    /**
     * Specifies if sourceEntityNode resolves to a list of entities instead of a single entity
     */
    readonly sourceIsList: boolean;
    /**
     * Specifies if the result should be a list one value if the path results in a single object instead of a list
     */
    readonly alwaysProduceList: boolean;
    constructor(params: TraversalQueryNodeParams);
    describe(): string;
    private describeSegment;
}
export {};