export declare enum Keyword {
    FUNCTION = "function",
    NEW = "new",
    TYPEOF = "typeof",
    LET = "let",
    CONST = "const",
    LAMBDA = "lambda",
    AWAIT = "await",
    ASYNC = "async",
    IN = "in",
    NOT = "not"
}
export declare enum TokenType {
    UNKNOWN = 0,
    ID = 1,
    INT = 2,
    FLOAT = 3,
    STR = 4,
    BOOL = 5,
    NULL = 6,
    UNDEFINED = 7,
    LAMBDA_ARG = 8,
    PUNCT = 9,
    THROW = 10,
    KEYWORD = 11,
    EOT = 12
}
export declare enum OperatorType {
    BASE = 0,
    CONDITIONAL = 1,
    ASSIGNMENT = 2,
    COALESCING = 3,
    OR = 4,
    AND = 5,
    EQUALITY = 6,
    RELATIONAL = 7,
    SHIFT = 8,
    ADDITION = 9,
    MULTIPLICATION = 10,
    POWER = 11,
    UNARY = 12
}
export declare enum SyntaxType {
    EMPTY = 0,
    PATH = 1,
    PATH_OPTIONS = 2,
    SELECTOR = 3,
    LAMBDA_ARG = 4,
    LITERAL = 5,
    LOGICAL_COALESCE_EXPR = 6,
    LOGICAL_OR_EXPR = 7,
    LOGICAL_AND_EXPR = 8,
    COMPARISON_EXPR = 9,
    IN_EXPR = 10,
    MATH_EXPR = 11,
    UNARY_EXPR = 12,
    SPREAD_EXPR = 13,
    CONDITIONAL_EXPR = 14,
    ARRAY_INDEX_FILTER_EXPR = 15,
    OBJECT_INDEX_FILTER_EXPR = 16,
    RANGE_FILTER_EXPR = 17,
    OBJECT_FILTER_EXPR = 18,
    ARRAY_FILTER_EXPR = 19,
    DEFINITION_EXPR = 20,
    ASSIGNMENT_EXPR = 21,
    OBJECT_PROP_EXPR = 22,
    OBJECT_EXPR = 23,
    ARRAY_EXPR = 24,
    BLOCK_EXPR = 25,
    FUNCTION_EXPR = 26,
    FUNCTION_CALL_ARG = 27,
    FUNCTION_CALL_EXPR = 28,
    STATEMENTS_EXPR = 29
}
export declare enum PathType {
    SIMPLE = 0,
    RICH = 1
}
export interface EngineOptions {
    compileTimeBindings?: Record<string, any>;
    defaultPathType?: PathType;
}
export type Token = {
    type: TokenType;
    value: any;
    range: [number, number];
};
export interface PathOptions {
    item?: string;
    index?: string;
    toArray?: boolean;
}
export interface Expression {
    type: SyntaxType;
    options?: PathOptions;
    [key: string]: any;
}
export interface LambdaArgExpression extends Expression {
    index: number;
}
export interface FunctionExpression extends Expression {
    params?: string[];
    body: StatementsExpression;
    block?: boolean;
    async?: boolean;
}
export interface BlockExpression extends Expression {
    statements: Expression[];
}
export interface ObjectPropExpression extends Expression {
    key?: Expression | string;
    value: Expression;
}
export interface ObjectExpression extends Expression {
    props: ObjectPropExpression[];
}
export interface ArrayExpression extends Expression {
    elements: Expression[];
}
export interface StatementsExpression extends Expression {
    statements: Expression[];
}
export interface UnaryExpression extends Expression {
    arg: Expression;
    op: string;
}
export interface BinaryExpression extends Expression {
    args: [Expression, Expression];
    op: string;
}
export interface ConcatExpression extends Expression {
    args: Expression[];
}
export interface AssignmentExpression extends Expression {
    path: PathExpression;
    value: Expression;
}
export interface DefinitionExpression extends Expression {
    vars: string[];
    fromObject?: boolean;
    value: Expression;
    definition: string;
}
export interface RangeFilterExpression extends Expression {
    fromIdx?: Expression;
    toIdx?: Expression;
}
export interface IndexFilterExpression extends Expression {
    indexes: ArrayExpression;
    exclude?: boolean;
}
export interface ObjectFilterExpression extends Expression {
    filter: Expression;
}
export interface ArrayFilterExpression extends Expression {
    filter: RangeFilterExpression | IndexFilterExpression;
}
export interface LiteralExpression extends Expression {
    value: string | number | boolean | null | undefined;
    tokenType: TokenType;
}
export interface PathExpression extends Expression {
    parts: Expression[];
    root?: Expression | string;
    returnAsArray?: boolean;
    pathType: PathType;
}
export interface SelectorExpression extends Expression {
    selector: string;
    prop?: Token;
}
export interface SpreadExpression extends Expression {
    value: Expression;
}
export interface FunctionCallExpression extends Expression {
    args: Expression[];
    object?: Expression;
    id?: string;
    dot?: boolean;
}
export interface ConditionalExpression extends Expression {
    if: Expression;
    then: Expression;
    else: Expression;
}
//# sourceMappingURL=types.d.ts.map