@ruleflow-ts/dsl-core 0.1.0

package/dist/generated/src/grammar/RuleFlowLanguageParser.d.ts

@@ -0,0 +1,936 @@
+import { ATN } from "antlr4ts/atn/ATN";
+import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
+import { Parser } from "antlr4ts/Parser";
+import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
+import { RuleContext } from "antlr4ts/RuleContext";
+import { TerminalNode } from "antlr4ts/tree/TerminalNode";
+import { Token } from "antlr4ts/Token";
+import { TokenStream } from "antlr4ts/TokenStream";
+import { Vocabulary } from "antlr4ts/Vocabulary";
+import { RuleFlowLanguageListener } from "./RuleFlowLanguageListener";
+import { RuleFlowLanguageVisitor } from "./RuleFlowLanguageVisitor";
+export declare class RuleFlowLanguageParser extends Parser {
+    static readonly STRING_NOT_SPECIAL_CHARS = 1;
+    static readonly DOT = 2;
+    static readonly COMMA = 3;
+    static readonly ADD = 4;
+    static readonly MINUS = 5;
+    static readonly MULTIPLY = 6;
+    static readonly DIVIDE = 7;
+    static readonly LT = 8;
+    static readonly LT_EQ = 9;
+    static readonly GT = 10;
+    static readonly GT_EQ = 11;
+    static readonly EQ_IC = 12;
+    static readonly EQ = 13;
+    static readonly NOT_EQ = 14;
+    static readonly MINUTE = 15;
+    static readonly HOUR = 16;
+    static readonly DAY = 17;
+    static readonly CURRENT_DATE = 18;
+    static readonly DATE_DIFF = 19;
+    static readonly ABS = 20;
+    static readonly REGEX_STRIP = 21;
+    static readonly MODULO = 22;
+    static readonly K_STARTS_WITH = 23;
+    static readonly K_LIST = 24;
+    static readonly L_BRACE = 25;
+    static readonly R_BRACE = 26;
+    static readonly L_PAREN = 27;
+    static readonly R_PAREN = 28;
+    static readonly K_COLON = 29;
+    static readonly K_ACTION = 30;
+    static readonly K_WORKFLOW = 31;
+    static readonly K_RULESET = 32;
+    static readonly K_RETURN = 33;
+    static readonly K_THEN = 34;
+    static readonly K_DEFAULT = 35;
+    static readonly K_WITH = 36;
+    static readonly K_END = 37;
+    static readonly K_ELSE = 38;
+    static readonly K_AND = 39;
+    static readonly K_OR = 40;
+    static readonly K_CONTAINS = 41;
+    static readonly K_IS = 42;
+    static readonly K_NOT = 43;
+    static readonly K_IS_NOT = 44;
+    static readonly K_IN = 45;
+    static readonly K_ANY = 46;
+    static readonly K_NONE = 47;
+    static readonly K_ALL = 48;
+    static readonly K_COUNT = 49;
+    static readonly K_AVERAGE = 50;
+    static readonly K_DISTINCT = 51;
+    static readonly K_NULL = 52;
+    static readonly DAY_OF_WEEK = 53;
+    static readonly K_EXPR = 54;
+    static readonly K_EVALUATION_MODE = 55;
+    static readonly K_MULTI_MATCH = 56;
+    static readonly K_SINGLE_MATCH = 57;
+    static readonly K_NOW = 58;
+    static readonly K_DATE = 59;
+    static readonly K_DATETIME = 60;
+    static readonly K_DATE_ADD = 61;
+    static readonly K_DATE_SUBTRACT = 62;
+    static readonly STRING_DISTANCE = 63;
+    static readonly PARTIAL_RATIO = 64;
+    static readonly TOKEN_SORT_RATIO = 65;
+    static readonly TOKEN_SET_RATIO = 66;
+    static readonly STRING_SIMILARITY_SCORE = 67;
+    static readonly GEOHASH_ENCODE = 68;
+    static readonly GEOHASH_DECODE = 69;
+    static readonly DISTANCE = 70;
+    static readonly WITHIN_RADIUS = 71;
+    static readonly NUMERIC_LITERAL = 72;
+    static readonly BOOLEAN_LITERAL = 73;
+    static readonly DQUOTA_STRING = 74;
+    static readonly SQUOTA_STRING = 75;
+    static readonly ID = 76;
+    static readonly SINGLE_LINE_COMMENT = 77;
+    static readonly MULTILINE_COMMENT = 78;
+    static readonly SPACES = 79;
+    static readonly UNEXPECTED_CHAR = 80;
+    static readonly RULE_parse = 0;
+    static readonly RULE_error = 1;
+    static readonly RULE_workflow = 2;
+    static readonly RULE_workflow_name = 3;
+    static readonly RULE_string_literal = 4;
+    static readonly RULE_rulesets = 5;
+    static readonly RULE_ruleset_condition = 6;
+    static readonly RULE_rules = 7;
+    static readonly RULE_rule_body = 8;
+    static readonly RULE_name = 9;
+    static readonly RULE_default_clause = 10;
+    static readonly RULE_configuration = 11;
+    static readonly RULE_evaluation_mode = 12;
+    static readonly RULE_return_result = 13;
+    static readonly RULE_state_rule = 14;
+    static readonly RULE_actions = 15;
+    static readonly RULE_action = 16;
+    static readonly RULE_action_params = 17;
+    static readonly RULE_param_pairs = 18;
+    static readonly RULE_param_pair = 19;
+    static readonly RULE_expr = 20;
+    static readonly RULE_geoExpr = 21;
+    static readonly RULE_dateExpr = 22;
+    static readonly RULE_propertyTuple = 23;
+    static readonly RULE_listElems = 24;
+    static readonly RULE_validValue = 25;
+    static readonly RULE_actionParamValue = 26;
+    static readonly RULE_dateParse = 27;
+    static readonly RULE_dateValue = 28;
+    static readonly RULE_timeUnit = 29;
+    static readonly RULE_validProperty = 30;
+    static readonly ruleNames: string[];
+    private static readonly _LITERAL_NAMES;
+    private static readonly _SYMBOLIC_NAMES;
+    static readonly VOCABULARY: Vocabulary;
+    get vocabulary(): Vocabulary;
+    get grammarFileName(): string;
+    get ruleNames(): string[];
+    get serializedATN(): string;
+    protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
+    constructor(input: TokenStream);
+    parse(): ParseContext;
+    error(): ErrorContext;
+    workflow(): WorkflowContext;
+    workflow_name(): Workflow_nameContext;
+    string_literal(): String_literalContext;
+    rulesets(): RulesetsContext;
+    ruleset_condition(): Ruleset_conditionContext;
+    rules(): RulesContext;
+    rule_body(): Rule_bodyContext;
+    name(): NameContext;
+    default_clause(): Default_clauseContext;
+    configuration(): ConfigurationContext;
+    evaluation_mode(): Evaluation_modeContext;
+    return_result(): Return_resultContext;
+    state_rule(): State_ruleContext;
+    actions(): ActionsContext;
+    action(): ActionContext;
+    action_params(): Action_paramsContext;
+    param_pairs(): Param_pairsContext;
+    param_pair(): Param_pairContext;
+    expr(): ExprContext;
+    expr(_p: number): ExprContext;
+    geoExpr(): GeoExprContext;
+    dateExpr(): DateExprContext;
+    propertyTuple(): PropertyTupleContext;
+    listElems(): ListElemsContext;
+    validValue(): ValidValueContext;
+    actionParamValue(): ActionParamValueContext;
+    dateParse(): DateParseContext;
+    dateValue(): DateValueContext;
+    timeUnit(): TimeUnitContext;
+    validProperty(): ValidPropertyContext;
+    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
+    private expr_sempred;
+    static readonly _serializedATN: string;
+    static __ATN: ATN;
+    static get _ATN(): ATN;
+}
+export declare class ParseContext extends ParserRuleContext {
+    EOF(): TerminalNode;
+    workflow(): WorkflowContext | undefined;
+    error(): ErrorContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ErrorContext extends ParserRuleContext {
+    UNEXPECTED_CHAR(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class WorkflowContext extends ParserRuleContext {
+    K_WORKFLOW(): TerminalNode;
+    workflow_name(): Workflow_nameContext;
+    default_clause(): Default_clauseContext;
+    K_END(): TerminalNode;
+    configuration(): ConfigurationContext | undefined;
+    rulesets(): RulesetsContext[];
+    rulesets(i: number): RulesetsContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class Workflow_nameContext extends ParserRuleContext {
+    STRING_NOT_SPECIAL_CHARS(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class String_literalContext extends ParserRuleContext {
+    STRING_NOT_SPECIAL_CHARS(): TerminalNode | undefined;
+    SQUOTA_STRING(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class RulesetsContext extends ParserRuleContext {
+    K_RULESET(): TerminalNode;
+    name(): NameContext;
+    ruleset_condition(): Ruleset_conditionContext | undefined;
+    rules(): RulesContext[];
+    rules(i: number): RulesContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class Ruleset_conditionContext extends ParserRuleContext {
+    expr(): ExprContext;
+    K_THEN(): TerminalNode;
+    L_PAREN(): TerminalNode | undefined;
+    R_PAREN(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class RulesContext extends ParserRuleContext {
+    name(): NameContext;
+    rule_body(): Rule_bodyContext;
+    L_PAREN(): TerminalNode | undefined;
+    R_PAREN(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class Rule_bodyContext extends ParserRuleContext {
+    _then_result: ActionsContext;
+    _result: Return_resultContext;
+    expr(): ExprContext;
+    K_THEN(): TerminalNode | undefined;
+    K_RETURN(): TerminalNode | undefined;
+    actions(): ActionsContext | undefined;
+    return_result(): Return_resultContext | undefined;
+    K_WITH(): TerminalNode | undefined;
+    K_AND(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class NameContext extends ParserRuleContext {
+    string_literal(): String_literalContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class Default_clauseContext extends ParserRuleContext {
+    _default_result: Return_resultContext;
+    K_DEFAULT(): TerminalNode;
+    return_result(): Return_resultContext;
+    actions(): ActionsContext | undefined;
+    K_THEN(): TerminalNode | undefined;
+    K_RETURN(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ConfigurationContext extends ParserRuleContext {
+    evaluation_mode(): Evaluation_modeContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class Evaluation_modeContext extends ParserRuleContext {
+    K_EVALUATION_MODE(): TerminalNode;
+    K_MULTI_MATCH(): TerminalNode | undefined;
+    K_SINGLE_MATCH(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class Return_resultContext extends ParserRuleContext {
+    state_rule(): State_ruleContext | undefined;
+    validProperty(): ValidPropertyContext | undefined;
+    validValue(): ValidValueContext | undefined;
+    K_EXPR(): TerminalNode | undefined;
+    L_PAREN(): TerminalNode | undefined;
+    expr(): ExprContext | undefined;
+    R_PAREN(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class State_ruleContext extends ParserRuleContext {
+    ID(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ActionsContext extends ParserRuleContext {
+    action(): ActionContext[];
+    action(i: number): ActionContext;
+    K_AND(): TerminalNode[];
+    K_AND(i: number): TerminalNode;
+    K_WITH(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ActionContext extends ParserRuleContext {
+    _param_value: String_literalContext;
+    _action_id: Token;
+    K_ACTION(): TerminalNode | undefined;
+    L_PAREN(): TerminalNode | undefined;
+    R_PAREN(): TerminalNode | undefined;
+    string_literal(): String_literalContext | undefined;
+    COMMA(): TerminalNode | undefined;
+    action_params(): Action_paramsContext | undefined;
+    ID(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class Action_paramsContext extends ParserRuleContext {
+    L_BRACE(): TerminalNode;
+    param_pairs(): Param_pairsContext;
+    R_BRACE(): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class Param_pairsContext extends ParserRuleContext {
+    param_pair(): Param_pairContext[];
+    param_pair(i: number): Param_pairContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class Param_pairContext extends ParserRuleContext {
+    _field_name: String_literalContext;
+    _field_value: ActionParamValueContext;
+    K_COLON(): TerminalNode;
+    string_literal(): String_literalContext;
+    actionParamValue(): ActionParamValueContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ExprContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: ExprContext): void;
+}
+export declare class ParenthesisContext extends ExprContext {
+    L_PAREN(): TerminalNode;
+    expr(): ExprContext;
+    R_PAREN(): TerminalNode;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class MathMulContext extends ExprContext {
+    _left: ExprContext;
+    _op: Token;
+    _right: ExprContext;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    MULTIPLY(): TerminalNode | undefined;
+    DIVIDE(): TerminalNode | undefined;
+    MODULO(): TerminalNode | undefined;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class MathAddContext extends ExprContext {
+    _left: ExprContext;
+    _op: Token;
+    _right: ExprContext;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    ADD(): TerminalNode | undefined;
+    MINUS(): TerminalNode | undefined;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ComparatorContext extends ExprContext {
+    _left: ExprContext;
+    _op: Token;
+    _right: ExprContext;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    LT(): TerminalNode | undefined;
+    LT_EQ(): TerminalNode | undefined;
+    GT(): TerminalNode | undefined;
+    GT_EQ(): TerminalNode | undefined;
+    EQ(): TerminalNode | undefined;
+    EQ_IC(): TerminalNode | undefined;
+    NOT_EQ(): TerminalNode | undefined;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ListContext extends ExprContext {
+    _value: ExprContext;
+    _not: Token;
+    _op: Token;
+    _values: ListElemsContext;
+    expr(): ExprContext;
+    listElems(): ListElemsContext;
+    K_CONTAINS(): TerminalNode | undefined;
+    K_IN(): TerminalNode | undefined;
+    K_STARTS_WITH(): TerminalNode | undefined;
+    K_NOT(): TerminalNode | undefined;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class TupleListContext extends ExprContext {
+    _value: PropertyTupleContext;
+    _not: Token;
+    _op: Token;
+    _values: ListElemsContext;
+    propertyTuple(): PropertyTupleContext;
+    listElems(): ListElemsContext;
+    K_CONTAINS(): TerminalNode | undefined;
+    K_IN(): TerminalNode | undefined;
+    K_STARTS_WITH(): TerminalNode | undefined;
+    K_NOT(): TerminalNode | undefined;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class AggregationContext extends ExprContext {
+    _value: ExprContext;
+    _op: Token;
+    _predicate: ExprContext;
+    DOT(): TerminalNode;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    K_COUNT(): TerminalNode | undefined;
+    K_AVERAGE(): TerminalNode | undefined;
+    K_ANY(): TerminalNode | undefined;
+    K_ALL(): TerminalNode | undefined;
+    K_DISTINCT(): TerminalNode | undefined;
+    K_NONE(): TerminalNode | undefined;
+    L_BRACE(): TerminalNode | undefined;
+    R_BRACE(): TerminalNode | undefined;
+    L_PAREN(): TerminalNode | undefined;
+    R_PAREN(): TerminalNode | undefined;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class DateOperationContext extends ExprContext {
+    dateExpr(): DateExprContext;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class RegexlikeContext extends ExprContext {
+    _op: Token;
+    _value: ValidPropertyContext;
+    _regex: Token;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode;
+    R_PAREN(): TerminalNode;
+    REGEX_STRIP(): TerminalNode;
+    validProperty(): ValidPropertyContext;
+    SQUOTA_STRING(): TerminalNode;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class UnaryContext extends ExprContext {
+    _op: Token;
+    _left: ExprContext;
+    L_PAREN(): TerminalNode;
+    R_PAREN(): TerminalNode;
+    ABS(): TerminalNode;
+    expr(): ExprContext;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class BinaryAndContext extends ExprContext {
+    _left: ExprContext;
+    _op: Token;
+    _right: ExprContext;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    K_AND(): TerminalNode;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class BinaryOrContext extends ExprContext {
+    _left: ExprContext;
+    _op: Token;
+    _right: ExprContext;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    K_OR(): TerminalNode;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class DateParseExprContext extends ExprContext {
+    dateParse(): DateParseContext;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ValueContext extends ExprContext {
+    validValue(): ValidValueContext;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class PropertyContext extends ExprContext {
+    validProperty(): ValidPropertyContext;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class StringDistanceContext extends ExprContext {
+    _op: Token;
+    _left: ExprContext;
+    _right: ExprContext;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode;
+    R_PAREN(): TerminalNode;
+    STRING_DISTANCE(): TerminalNode;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class PartialRatioContext extends ExprContext {
+    _op: Token;
+    _left: ExprContext;
+    _right: ExprContext;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode;
+    R_PAREN(): TerminalNode;
+    PARTIAL_RATIO(): TerminalNode;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class TokenSortRatioContext extends ExprContext {
+    _op: Token;
+    _left: ExprContext;
+    _right: ExprContext;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode;
+    R_PAREN(): TerminalNode;
+    TOKEN_SORT_RATIO(): TerminalNode;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class TokenSetRatioContext extends ExprContext {
+    _op: Token;
+    _left: ExprContext;
+    _right: ExprContext;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode;
+    R_PAREN(): TerminalNode;
+    TOKEN_SET_RATIO(): TerminalNode;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class StringSimilarityScoreContext extends ExprContext {
+    _op: Token;
+    _left: ExprContext;
+    _right: ExprContext;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode;
+    R_PAREN(): TerminalNode;
+    STRING_SIMILARITY_SCORE(): TerminalNode;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class GeoOperationContext extends ExprContext {
+    geoExpr(): GeoExprContext;
+    constructor(ctx: ExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class GeoExprContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: GeoExprContext): void;
+}
+export declare class GeohashEncodeContext extends GeoExprContext {
+    _lat: ExprContext;
+    _lon: ExprContext;
+    _precision: ExprContext;
+    GEOHASH_ENCODE(): TerminalNode;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    R_PAREN(): TerminalNode;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    constructor(ctx: GeoExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class GeohashDecodeContext extends GeoExprContext {
+    _geohash: ExprContext;
+    GEOHASH_DECODE(): TerminalNode;
+    L_PAREN(): TerminalNode;
+    R_PAREN(): TerminalNode;
+    expr(): ExprContext;
+    constructor(ctx: GeoExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class DistanceContext extends GeoExprContext {
+    _lat1: ExprContext;
+    _lon1: ExprContext;
+    _lat2: ExprContext;
+    _lon2: ExprContext;
+    DISTANCE(): TerminalNode;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    R_PAREN(): TerminalNode;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    constructor(ctx: GeoExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class DistanceGeohashContext extends GeoExprContext {
+    _geohash1: ExprContext;
+    _geohash2: ExprContext;
+    DISTANCE(): TerminalNode;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode;
+    R_PAREN(): TerminalNode;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    constructor(ctx: GeoExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class WithinRadiusContext extends GeoExprContext {
+    _lat1: ExprContext;
+    _lon1: ExprContext;
+    _lat2: ExprContext;
+    _lon2: ExprContext;
+    _radius: ExprContext;
+    WITHIN_RADIUS(): TerminalNode;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    R_PAREN(): TerminalNode;
+    expr(): ExprContext[];
+    expr(i: number): ExprContext;
+    constructor(ctx: GeoExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class DateExprContext extends ParserRuleContext {
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: DateExprContext): void;
+}
+export declare class DateDiffContext extends DateExprContext {
+    _left: DateValueContext;
+    _right: DateValueContext;
+    DATE_DIFF(): TerminalNode;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    R_PAREN(): TerminalNode;
+    dateValue(): DateValueContext[];
+    dateValue(i: number): DateValueContext;
+    HOUR(): TerminalNode | undefined;
+    DAY(): TerminalNode | undefined;
+    MINUTE(): TerminalNode | undefined;
+    constructor(ctx: DateExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class DayOfWeekContext extends DateExprContext {
+    _op: Token;
+    _left: DateValueContext;
+    L_PAREN(): TerminalNode;
+    R_PAREN(): TerminalNode;
+    DAY_OF_WEEK(): TerminalNode;
+    dateValue(): DateValueContext;
+    constructor(ctx: DateExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class NowContext extends DateExprContext {
+    _op: Token;
+    L_PAREN(): TerminalNode;
+    R_PAREN(): TerminalNode;
+    K_NOW(): TerminalNode;
+    constructor(ctx: DateExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class DateAddContext extends DateExprContext {
+    _op: Token;
+    _date: DateValueContext;
+    _amount: ExprContext;
+    _unit: TimeUnitContext;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    R_PAREN(): TerminalNode;
+    K_DATE_ADD(): TerminalNode;
+    dateValue(): DateValueContext;
+    expr(): ExprContext;
+    timeUnit(): TimeUnitContext;
+    constructor(ctx: DateExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class DateSubtractContext extends DateExprContext {
+    _op: Token;
+    _date: DateValueContext;
+    _amount: ExprContext;
+    _unit: TimeUnitContext;
+    L_PAREN(): TerminalNode;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    R_PAREN(): TerminalNode;
+    K_DATE_SUBTRACT(): TerminalNode;
+    dateValue(): DateValueContext;
+    expr(): ExprContext;
+    timeUnit(): TimeUnitContext;
+    constructor(ctx: DateExprContext);
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class PropertyTupleContext extends ParserRuleContext {
+    L_PAREN(): TerminalNode;
+    validProperty(): ValidPropertyContext[];
+    validProperty(i: number): ValidPropertyContext;
+    R_PAREN(): TerminalNode;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ListElemsContext extends ParserRuleContext {
+    _storedList: Token;
+    _literalList: String_literalContext;
+    _literalTupleList: Token;
+    L_PAREN(): TerminalNode[];
+    L_PAREN(i: number): TerminalNode;
+    string_literal(): String_literalContext[];
+    string_literal(i: number): String_literalContext;
+    R_PAREN(): TerminalNode[];
+    R_PAREN(i: number): TerminalNode;
+    K_LIST(): TerminalNode | undefined;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    validProperty(): ValidPropertyContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ValidValueContext extends ParserRuleContext {
+    _string: String_literalContext;
+    _number: Token;
+    _booleanLiteral: Token;
+    _nullValue: Token;
+    _currentDate: Token;
+    string_literal(): String_literalContext | undefined;
+    NUMERIC_LITERAL(): TerminalNode | undefined;
+    BOOLEAN_LITERAL(): TerminalNode | undefined;
+    K_NULL(): TerminalNode | undefined;
+    CURRENT_DATE(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ActionParamValueContext extends ParserRuleContext {
+    validValue(): ValidValueContext | undefined;
+    validProperty(): ValidPropertyContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class DateParseContext extends ParserRuleContext {
+    K_DATE(): TerminalNode | undefined;
+    L_PAREN(): TerminalNode;
+    dateValue(): DateValueContext;
+    R_PAREN(): TerminalNode;
+    K_DATETIME(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class DateValueContext extends ParserRuleContext {
+    string_literal(): String_literalContext | undefined;
+    validProperty(): ValidPropertyContext | undefined;
+    K_NOW(): TerminalNode | undefined;
+    L_PAREN(): TerminalNode | undefined;
+    R_PAREN(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class TimeUnitContext extends ParserRuleContext {
+    DAY(): TerminalNode | undefined;
+    HOUR(): TerminalNode | undefined;
+    MINUTE(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+export declare class ValidPropertyContext extends ParserRuleContext {
+    _root: Token;
+    _property: Token;
+    _nestedProperty: Token;
+    ID(): TerminalNode[];
+    ID(i: number): TerminalNode;
+    DOT(): TerminalNode[];
+    DOT(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: RuleFlowLanguageListener): void;
+    exitRule(listener: RuleFlowLanguageListener): void;
+    accept<Result>(visitor: RuleFlowLanguageVisitor<Result>): Result;
+}
+//# sourceMappingURL=RuleFlowLanguageParser.d.ts.map