import { Id } from '../shared';
import { Model } from './model';
import { Universe } from "./universe";
import { Interface } from "./interface";
export declare type StringFormatType = 'string' | 'hex' | 'base64';
export declare type JSONByteFormatType = 'hex' | 'base64';
export declare type NumberFormatType = 'integer' | 'float';
export declare type BooleanFormatType = 'boolean';
export declare type JSONFormatType = StringFormatType | JSONByteFormatType | NumberFormatType | BooleanFormatType;
export declare type FormatType = StringFormatType | JSONByteFormatType | NumberFormatType | BooleanFormatType | 'raw';
export declare type NodeType = 'endpoint' | 'reference' | 'context' | 'relation' | 'specials' | 'value' | 'instance' | 'filter' | 'sort' | 'slice' | 'aggregate' | 'list' | 'map';
export declare type EnvironmentType = 'primitive' | 'list' | 'keyed_list';
export declare type SourceType = 'node' | 'key';
export declare type AggregateType = 'count' | 'minimum' | 'maximum' | 'sum' | 'average';
export declare type FieldType = 'id' | 'name' | 'created' | 'user' | 'size' | 'data';
export declare type EndpointType = 'get' | 'put';
export interface NodeDef {
    [_: string]: any;
    type: NodeType;
    endpoint?: EndpointNodeDef;
    reference?: ReferenceNodeDef;
    context?: ContextNodeDef;
    relation?: RelationNodeDef;
    specials?: SpecialsNodeDef;
    value?: ValueNodeDef;
    instance?: InstanceNodeDef;
    filter?: FilterNodeDef;
    sort?: SortNodeDef;
    slice?: SliceNodeDef;
    aggregate?: AggregateNodeDef;
    list?: ListNodeDef;
    map?: MapNodeDef;
}
export interface EnvironmentDef {
    type: EnvironmentType;
    model?: string;
}
export interface ContextDef {
    environment: EnvironmentDef;
    value: string | string[] | Id | Id[] | undefined;
}
export interface Context {
    environment: Environment;
    value: string | string[] | Id | Id[] | undefined;
}
export interface ValueSourceDef {
    type: SourceType;
    format: FormatType;
    node?: NodeDef;
}
export interface ValueSource {
    type: SourceType;
    format: FormatType;
    node?: Node;
}
export interface Parameter {
    name: string;
    description: string;
    interface: Interface;
}
export interface EndpointNodeDef {
    [_: string]: any;
    id?: Id;
    type: EndpointType;
    name: string;
    node: NodeDef;
    context: ContextDef;
    interface?: Interface;
    parameters?: Parameter[];
}
export interface ReferenceNodeDef {
    name: string;
}
export interface ContextNodeDef {
    context: ContextDef;
    node: NodeDef;
}
export interface RelationNodeDef {
    type: EnvironmentType;
    relation: string;
    reverse: boolean;
    node: NodeDef;
}
export interface SpecialsNodeDef {
    type: EnvironmentType;
    direct: boolean;
    indirect: boolean;
    node: NodeDef;
}
export interface ValueNodeDef {
    field: FieldType;
    format: FormatType;
}
export interface InstanceSwitchDef {
    type: string;
    value: any;
}
export interface InstanceNodeDef {
    format: FormatType;
    switches: InstanceSwitchDef[];
}
export interface ListNodeDef {
    entry: NodeDef;
    keyFormat?: FormatType;
    keyName?: string;
    valueName?: string;
}
export interface FilterNodeDef {
    filter: {
        source: ValueSourceDef;
        operator: OperatorType;
        value: any;
    };
    node: NodeDef;
}
export interface SortNodeDef {
    order: {
        source: ValueSourceDef;
        descending: boolean;
    };
    node: NodeDef;
}
export interface SliceNodeDef {
    offset?: number;
    limit?: number;
    node: NodeDef;
}
export interface AggregateNodeDef {
    source: ValueSourceDef;
    function: AggregateType;
}
export interface MapNodeEntryDef {
    name: string;
    node: NodeDef;
}
export interface MapNodeDef {
    entries: MapNodeEntryDef[];
}
export interface Environment {
    type: EnvironmentType;
    model?: Model;
}
export declare abstract class Node {
    parent?: Node;
    context?: Context;
    abstract getType(): NodeType;
    abstract getDefinition(): NodeDef | undefined;
    abstract resolveDefinition(universe: Universe): NodeDef | undefined;
}
export declare class EndpointNode extends Node {
    type?: EndpointType;
    id?: Id;
    name?: string;
    node?: Node;
    parameters?: Parameter[];
    interface?: Interface;
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
/**
 * A node representing a reference to another node.
 */
export declare class ReferenceNode extends Node {
    node?: EndpointNode;
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
export declare type OperatorType = 'eq' | 'ne' | 'gt' | 'ge' | 'lt' | 'le';
export interface FilterEntryDef {
    source: ValueSource;
    operator: OperatorType;
    value: any;
}
export interface OrderEntryDef {
    source: ValueSource;
    descending: boolean;
}
/**
 * A node manipulating the context for its child node.
 */
export declare class ContextNode extends Node {
    node?: Node;
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
export declare class RelationNode extends Node {
    type?: EnvironmentType;
    relation?: string;
    reverse?: boolean;
    node?: Node;
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
export declare class SpecialsNode extends Node {
    type?: EnvironmentType;
    direct?: boolean | undefined;
    indirect?: boolean | undefined;
    node?: Node;
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
/**
 * A node representing a value derived from the current environment.
 */
export declare class ValueNode extends Node {
    field?: FieldType;
    format?: FormatType;
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
export declare class InstanceNode extends Node {
    format?: FormatType;
    switches?: InstanceSwitchDef[];
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
export declare class ListNode extends Node {
    entry?: Node;
    keyFormat?: FormatType;
    keyName?: string;
    valueName?: string;
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
export declare class FilterNode extends Node {
    filter?: FilterEntryDef;
    node?: Node;
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
export declare class SortNode extends Node {
    order?: OrderEntryDef;
    node?: Node;
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
export declare class SliceNode extends Node {
    offset?: number;
    limit?: number;
    node?: Node;
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
export declare class AggregateNode extends Node {
    source?: ValueSource;
    function?: AggregateType;
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
export interface MapNodeEntry {
    name: string;
    node: Node;
}
export declare class MapNode extends Node {
    entries?: MapNodeEntry[];
    getType(): NodeType;
    getDefinition(): NodeDef | undefined;
    resolveDefinition(universe: Universe): NodeDef | undefined;
}
export declare function loadNode(nodeDef: NodeDef, universe: Universe): Node;
export declare function loadEndpointNode(endpointNodeDef: EndpointNodeDef, universe: Universe): EndpointNode;
//# sourceMappingURL=node.d.ts.map