udm-rules-vue 0.0.1

package/dist/grammar/rule/RuleParser.d.ts

@@ -0,0 +1,537 @@
+import { RuleParserListener } from './RuleParserListener.js';
+import { RuleParserVisitor } from './RuleParserVisitor.js';
+import * as antlr from "antlr4ng";
+export declare class RuleParser extends antlr.Parser {
+    static readonly PlaceHolder = 1;
+    static readonly ObjectName = 2;
+    static readonly EnumDescriptor = 3;
+    static readonly FieldDescriptor = 4;
+    static readonly MethodDescriptor = 5;
+    static readonly If = 6;
+    static readonly Then = 7;
+    static readonly Else = 8;
+    static readonly Print = 9;
+    static readonly ForEach = 10;
+    static readonly BeCalledAs = 11;
+    static readonly As = 12;
+    static readonly PredefineDeclare = 13;
+    static readonly PredefineSpecify = 14;
+    static readonly PredefineFrom = 15;
+    static readonly FromList = 16;
+    static readonly PredefineConditionDeclare = 17;
+    static readonly CurrentItemDeclare = 18;
+    static readonly VariableName = 19;
+    static readonly DateTime = 20;
+    static readonly Date = 21;
+    static readonly Time = 22;
+    static readonly ChineseFullCornerSpace = 23;
+    static readonly Char = 24;
+    static readonly String = 25;
+    static readonly Number = 26;
+    static readonly Colon = 27;
+    static readonly ChineseFullCornorColon = 28;
+    static readonly Semicolon = 29;
+    static readonly AllConditionsTrueDeclare = 30;
+    static readonly AllConditionsNotTrueDeclare = 31;
+    static readonly AnyConditionsTrueDeclare = 32;
+    static readonly Add = 33;
+    static readonly Sub = 34;
+    static readonly Mul = 35;
+    static readonly Div = 36;
+    static readonly Mod = 37;
+    static readonly Dash = 38;
+    static readonly EQ = 39;
+    static readonly True = 40;
+    static readonly False = 41;
+    static readonly PredefineOneType = 42;
+    static readonly PredefineManyType = 43;
+    static readonly CONTENT = 44;
+    static readonly LINE_COMMENT = 45;
+    static readonly WS = 46;
+    static readonly Other = 47;
+    static readonly RULE_ruleStatement = 0;
+    static readonly RULE_documentation = 1;
+    static readonly RULE_value = 2;
+    static readonly RULE_elseStatement = 3;
+    static readonly RULE_thenStatement = 4;
+    static readonly RULE_ifStatement = 5;
+    static readonly RULE_actions = 6;
+    static readonly RULE_singleAction = 7;
+    static readonly RULE_action = 8;
+    static readonly RULE_precondition = 9;
+    static readonly RULE_predefineStatement = 10;
+    static readonly RULE_predefineItem = 11;
+    static readonly RULE_predefineVariableName = 12;
+    static readonly RULE_predefineAs = 13;
+    static readonly RULE_predefineValue = 14;
+    static readonly RULE_predefineConditionValue = 15;
+    static readonly RULE_predefineObjectValue = 16;
+    static readonly RULE_predefineSourceCondition = 17;
+    static readonly RULE_predefineObjectName = 18;
+    static readonly RULE_predefineSource = 19;
+    static readonly RULE_predefineSourceType = 20;
+    static readonly RULE_predefineType = 21;
+    static readonly RULE_singleConditionExpression = 22;
+    static readonly RULE_batchConditionsExpression = 23;
+    static readonly RULE_listCondition = 24;
+    static readonly RULE_expression = 25;
+    static readonly RULE_primary = 26;
+    static readonly RULE_additiveOp = 27;
+    static readonly RULE_multiplicativeOp = 28;
+    static readonly RULE_currentLoopItem = 29;
+    static readonly RULE_object = 30;
+    static readonly RULE_variable = 31;
+    static readonly RULE_enum = 32;
+    static readonly RULE_literal = 33;
+    static readonly RULE_others = 34;
+    static readonly literalNames: (string | null)[];
+    static readonly symbolicNames: (string | null)[];
+    static readonly ruleNames: string[];
+    get grammarFileName(): string;
+    get literalNames(): (string | null)[];
+    get symbolicNames(): (string | null)[];
+    get ruleNames(): string[];
+    get serializedATN(): number[];
+    protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException;
+    constructor(input: antlr.TokenStream);
+    ruleStatement(): RuleStatementContext;
+    documentation(): DocumentationContext;
+    value(): ValueContext;
+    elseStatement(): ElseStatementContext;
+    thenStatement(): ThenStatementContext;
+    ifStatement(): IfStatementContext;
+    actions(): ActionsContext;
+    singleAction(): SingleActionContext;
+    action(): ActionContext;
+    precondition(): PreconditionContext;
+    predefineStatement(): PredefineStatementContext;
+    predefineItem(): PredefineItemContext;
+    predefineVariableName(): PredefineVariableNameContext;
+    predefineAs(): PredefineAsContext;
+    predefineValue(): PredefineValueContext;
+    predefineConditionValue(): PredefineConditionValueContext;
+    predefineObjectValue(): PredefineObjectValueContext;
+    predefineSourceCondition(): PredefineSourceConditionContext;
+    predefineObjectName(): PredefineObjectNameContext;
+    predefineSource(): PredefineSourceContext;
+    predefineSourceType(): PredefineSourceTypeContext;
+    predefineType(): PredefineTypeContext;
+    singleConditionExpression(): SingleConditionExpressionContext;
+    batchConditionsExpression(): BatchConditionsExpressionContext;
+    listCondition(): ListConditionContext;
+    expression(): ExpressionContext;
+    expression(_p: number): ExpressionContext;
+    primary(): PrimaryContext;
+    additiveOp(): AdditiveOpContext;
+    multiplicativeOp(): MultiplicativeOpContext;
+    currentLoopItem(): CurrentLoopItemContext;
+    object(): ObjectContext;
+    variable(): VariableContext;
+    enum_(): EnumContext;
+    literal(): LiteralContext;
+    others(): OthersContext;
+    sempred(localContext: antlr.ParserRuleContext | null, ruleIndex: number, predIndex: number): boolean;
+    private expression_sempred;
+    static readonly _serializedATN: number[];
+    private static __ATN;
+    static get _ATN(): antlr.ATN;
+    private static readonly vocabulary;
+    get vocabulary(): antlr.Vocabulary;
+    private static readonly decisionsToDFA;
+}
+export declare class RuleStatementContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    thenStatement(): ThenStatementContext;
+    EOF(): antlr.TerminalNode;
+    documentation(): DocumentationContext | null;
+    predefineStatement(): PredefineStatementContext | null;
+    ifStatement(): IfStatementContext | null;
+    elseStatement(): ElseStatementContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class DocumentationContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    CONTENT(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class ValueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    String(): antlr.TerminalNode | null;
+    Number(): antlr.TerminalNode | null;
+    Date(): antlr.TerminalNode | null;
+    DateTime(): antlr.TerminalNode | null;
+    True(): antlr.TerminalNode | null;
+    False(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class ElseStatementContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Else(): antlr.TerminalNode;
+    actions(): ActionsContext;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class ThenStatementContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Then(): antlr.TerminalNode;
+    actions(): ActionsContext;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class IfStatementContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    If(): antlr.TerminalNode;
+    expression(): ExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class ActionsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    action(): ActionContext[];
+    action(i: number): ActionContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class SingleActionContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    expression(): ExpressionContext;
+    EOF(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class ActionContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    expression(): ExpressionContext;
+    Semicolon(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PreconditionContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    predefineStatement(): PredefineStatementContext | null;
+    ifStatement(): IfStatementContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineStatementContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    PredefineDeclare(): antlr.TerminalNode;
+    predefineItem(): PredefineItemContext[];
+    predefineItem(i: number): PredefineItemContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineItemContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    PredefineSpecify(): antlr.TerminalNode;
+    predefineVariableName(): PredefineVariableNameContext;
+    predefineAs(): PredefineAsContext;
+    predefineValue(): PredefineValueContext;
+    Semicolon(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineVariableNameContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    VariableName(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineAsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    As(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineValueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    predefineConditionValue(): PredefineConditionValueContext | null;
+    predefineObjectValue(): PredefineObjectValueContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineConditionValueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    expression(): ExpressionContext;
+    predefineSourceCondition(): PredefineSourceConditionContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineObjectValueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    predefineType(): PredefineTypeContext;
+    predefineObjectName(): PredefineObjectNameContext;
+    predefineSourceType(): PredefineSourceTypeContext | null;
+    predefineSource(): PredefineSourceContext | null;
+    predefineSourceCondition(): PredefineSourceConditionContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineSourceConditionContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    PredefineConditionDeclare(): antlr.TerminalNode;
+    expression(): ExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineObjectNameContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    ObjectName(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineSourceContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    expression(): ExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineSourceTypeContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    FromList(): antlr.TerminalNode | null;
+    PredefineFrom(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PredefineTypeContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    PredefineOneType(): antlr.TerminalNode | null;
+    PredefineManyType(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class SingleConditionExpressionContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    expression(): ExpressionContext;
+    EOF(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class BatchConditionsExpressionContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    AllConditionsTrueDeclare(): antlr.TerminalNode | null;
+    listCondition(): ListConditionContext[];
+    listCondition(i: number): ListConditionContext | null;
+    AllConditionsNotTrueDeclare(): antlr.TerminalNode | null;
+    AnyConditionsTrueDeclare(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class ListConditionContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Dash(): antlr.TerminalNode;
+    expression(): ExpressionContext;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class ExpressionContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    get ruleIndex(): number;
+    copyFrom(ctx: ExpressionContext): void;
+}
+export declare class Method1Context extends ExpressionContext {
+    constructor(ctx: ExpressionContext);
+    MethodDescriptor(): antlr.TerminalNode;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class Method2Context extends ExpressionContext {
+    constructor(ctx: ExpressionContext);
+    expression(): ExpressionContext[];
+    expression(i: number): ExpressionContext | null;
+    MethodDescriptor(): antlr.TerminalNode[];
+    MethodDescriptor(i: number): antlr.TerminalNode | null;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class Method3Context extends ExpressionContext {
+    constructor(ctx: ExpressionContext);
+    MethodDescriptor(): antlr.TerminalNode[];
+    MethodDescriptor(i: number): antlr.TerminalNode | null;
+    expression(): ExpressionContext[];
+    expression(i: number): ExpressionContext | null;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class BatchConditionsContext extends ExpressionContext {
+    constructor(ctx: ExpressionContext);
+    batchConditionsExpression(): BatchConditionsExpressionContext;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class MultiplicativeContext extends ExpressionContext {
+    constructor(ctx: ExpressionContext);
+    expression(): ExpressionContext[];
+    expression(i: number): ExpressionContext | null;
+    multiplicativeOp(): MultiplicativeOpContext[];
+    multiplicativeOp(i: number): MultiplicativeOpContext | null;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class BasicContext extends ExpressionContext {
+    constructor(ctx: ExpressionContext);
+    primary(): PrimaryContext;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class AdditiveContext extends ExpressionContext {
+    constructor(ctx: ExpressionContext);
+    expression(): ExpressionContext[];
+    expression(i: number): ExpressionContext | null;
+    additiveOp(): AdditiveOpContext[];
+    additiveOp(i: number): AdditiveOpContext | null;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class PrimaryContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    variable(): VariableContext | null;
+    object(): ObjectContext | null;
+    enum(): EnumContext | null;
+    literal(): LiteralContext | null;
+    currentLoopItem(): CurrentLoopItemContext | null;
+    PlaceHolder(): antlr.TerminalNode | null;
+    others(): OthersContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class AdditiveOpContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Add(): antlr.TerminalNode | null;
+    Sub(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class MultiplicativeOpContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Mul(): antlr.TerminalNode | null;
+    Div(): antlr.TerminalNode | null;
+    Mod(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class CurrentLoopItemContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    CurrentItemDeclare(): antlr.TerminalNode;
+    object(): ObjectContext;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class ObjectContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    ObjectName(): antlr.TerminalNode;
+    FieldDescriptor(): antlr.TerminalNode[];
+    FieldDescriptor(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class VariableContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    VariableName(): antlr.TerminalNode;
+    FieldDescriptor(): antlr.TerminalNode[];
+    FieldDescriptor(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class EnumContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    EnumDescriptor(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class LiteralContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    String(): antlr.TerminalNode | null;
+    Number(): antlr.TerminalNode | null;
+    Char(): antlr.TerminalNode | null;
+    Date(): antlr.TerminalNode | null;
+    Time(): antlr.TerminalNode | null;
+    DateTime(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}
+export declare class OthersContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    Other(): antlr.TerminalNode[];
+    Other(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: RuleParserListener): void;
+    exitRule(listener: RuleParserListener): void;
+    accept<Result>(visitor: RuleParserVisitor<Result>): Result | null;
+}