import * as antlr from "antlr4ng";
import { ANTLRv4ParserListener } from "./ANTLRv4ParserListener.js";
export declare class ANTLRv4Parser extends antlr.Parser {
    static readonly ACTION = 4;
    static readonly ARG_ACTION = 5;
    static readonly ARG_OR_CHARSET = 6;
    static readonly ASSIGN = 7;
    static readonly LEXER_CHAR_SET = 8;
    static readonly RULE_REF = 9;
    static readonly SEMPRED = 10;
    static readonly STRING_LITERAL = 11;
    static readonly TOKEN_REF = 13;
    static readonly UNICODE_ESC = 14;
    static readonly UNICODE_EXTENDED_ESC = 15;
    static readonly WS = 16;
    static readonly ALT = 17;
    static readonly BLOCK = 18;
    static readonly CLOSURE = 19;
    static readonly ELEMENT_OPTIONS = 20;
    static readonly EPSILON = 21;
    static readonly LEXER_ACTION_CALL = 22;
    static readonly LEXER_ALT_ACTION = 23;
    static readonly OPTIONAL = 24;
    static readonly POSITIVE_CLOSURE = 25;
    static readonly RULE = 26;
    static readonly RULEMODIFIERS = 27;
    static readonly RULES = 28;
    static readonly SET = 29;
    static readonly WILDCARD = 30;
    static readonly DOC_COMMENT = 31;
    static readonly BLOCK_COMMENT = 32;
    static readonly LINE_COMMENT = 33;
    static readonly INT = 34;
    static readonly UNTERMINATED_STRING_LITERAL = 35;
    static readonly BEGIN_ARGUMENT = 36;
    static readonly OPTIONS = 37;
    static readonly TOKENS = 38;
    static readonly CHANNELS = 39;
    static readonly IMPORT = 40;
    static readonly FRAGMENT = 41;
    static readonly LEXER = 42;
    static readonly PARSER = 43;
    static readonly GRAMMAR = 44;
    static readonly PROTECTED = 45;
    static readonly PUBLIC = 46;
    static readonly PRIVATE = 47;
    static readonly RETURNS = 48;
    static readonly LOCALS = 49;
    static readonly THROWS = 50;
    static readonly CATCH = 51;
    static readonly FINALLY = 52;
    static readonly MODE = 53;
    static readonly COLON = 54;
    static readonly COLONCOLON = 55;
    static readonly COMMA = 56;
    static readonly SEMI = 57;
    static readonly LPAREN = 58;
    static readonly RPAREN = 59;
    static readonly RBRACE = 60;
    static readonly RARROW = 61;
    static readonly LT = 62;
    static readonly GT = 63;
    static readonly QUESTION = 64;
    static readonly STAR = 65;
    static readonly PLUS_ASSIGN = 66;
    static readonly PLUS = 67;
    static readonly OR = 68;
    static readonly DOLLAR = 69;
    static readonly RANGE = 70;
    static readonly DOT = 71;
    static readonly AT = 72;
    static readonly POUND = 73;
    static readonly NOT = 74;
    static readonly ID = 75;
    static readonly END_ARGUMENT = 76;
    static readonly UNTERMINATED_ARGUMENT = 77;
    static readonly ARGUMENT_CONTENT = 78;
    static readonly UNTERMINATED_CHAR_SET = 79;
    static readonly RULE_grammarSpec = 0;
    static readonly RULE_grammarDecl = 1;
    static readonly RULE_grammarType = 2;
    static readonly RULE_prequelConstruct = 3;
    static readonly RULE_optionsSpec = 4;
    static readonly RULE_option = 5;
    static readonly RULE_optionValue = 6;
    static readonly RULE_delegateGrammars = 7;
    static readonly RULE_delegateGrammar = 8;
    static readonly RULE_tokensSpec = 9;
    static readonly RULE_channelsSpec = 10;
    static readonly RULE_idList = 11;
    static readonly RULE_action_ = 12;
    static readonly RULE_actionScopeName = 13;
    static readonly RULE_actionBlock = 14;
    static readonly RULE_argActionBlock = 15;
    static readonly RULE_modeSpec = 16;
    static readonly RULE_rules = 17;
    static readonly RULE_ruleSpec = 18;
    static readonly RULE_parserRuleSpec = 19;
    static readonly RULE_exceptionGroup = 20;
    static readonly RULE_exceptionHandler = 21;
    static readonly RULE_finallyClause = 22;
    static readonly RULE_rulePrequel = 23;
    static readonly RULE_ruleReturns = 24;
    static readonly RULE_throwsSpec = 25;
    static readonly RULE_localsSpec = 26;
    static readonly RULE_ruleAction = 27;
    static readonly RULE_ruleModifiers = 28;
    static readonly RULE_ruleModifier = 29;
    static readonly RULE_ruleBlock = 30;
    static readonly RULE_ruleAltList = 31;
    static readonly RULE_labeledAlt = 32;
    static readonly RULE_lexerRuleSpec = 33;
    static readonly RULE_lexerRuleBlock = 34;
    static readonly RULE_lexerAltList = 35;
    static readonly RULE_lexerAlt = 36;
    static readonly RULE_lexerElements = 37;
    static readonly RULE_lexerElement = 38;
    static readonly RULE_lexerBlock = 39;
    static readonly RULE_lexerCommands = 40;
    static readonly RULE_lexerCommand = 41;
    static readonly RULE_lexerCommandName = 42;
    static readonly RULE_lexerCommandExpr = 43;
    static readonly RULE_altList = 44;
    static readonly RULE_alternative = 45;
    static readonly RULE_element = 46;
    static readonly RULE_predicateOptions = 47;
    static readonly RULE_predicateOption = 48;
    static readonly RULE_labeledElement = 49;
    static readonly RULE_ebnf = 50;
    static readonly RULE_blockSuffix = 51;
    static readonly RULE_ebnfSuffix = 52;
    static readonly RULE_lexerAtom = 53;
    static readonly RULE_atom = 54;
    static readonly RULE_wildcard = 55;
    static readonly RULE_notSet = 56;
    static readonly RULE_blockSet = 57;
    static readonly RULE_setElement = 58;
    static readonly RULE_block = 59;
    static readonly RULE_ruleref = 60;
    static readonly RULE_characterRange = 61;
    static readonly RULE_terminalDef = 62;
    static readonly RULE_elementOptions = 63;
    static readonly RULE_elementOption = 64;
    static readonly RULE_identifier = 65;
    static readonly RULE_qualifiedIdentifier = 66;
    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);
    grammarSpec(): GrammarSpecContext;
    grammarDecl(): GrammarDeclContext;
    grammarType(): GrammarTypeContext;
    prequelConstruct(): PrequelConstructContext;
    optionsSpec(): OptionsSpecContext;
    option(): OptionContext;
    optionValue(): OptionValueContext;
    delegateGrammars(): DelegateGrammarsContext;
    delegateGrammar(): DelegateGrammarContext;
    tokensSpec(): TokensSpecContext;
    channelsSpec(): ChannelsSpecContext;
    idList(): IdListContext;
    action_(): Action_Context;
    actionScopeName(): ActionScopeNameContext;
    actionBlock(): ActionBlockContext;
    argActionBlock(): ArgActionBlockContext;
    modeSpec(): ModeSpecContext;
    rules(): RulesContext;
    ruleSpec(): RuleSpecContext;
    parserRuleSpec(): ParserRuleSpecContext;
    exceptionGroup(): ExceptionGroupContext;
    exceptionHandler(): ExceptionHandlerContext;
    finallyClause(): FinallyClauseContext;
    rulePrequel(): RulePrequelContext;
    ruleReturns(): RuleReturnsContext;
    throwsSpec(): ThrowsSpecContext;
    localsSpec(): LocalsSpecContext;
    ruleAction(): RuleActionContext;
    ruleModifiers(): RuleModifiersContext;
    ruleModifier(): RuleModifierContext;
    ruleBlock(): RuleBlockContext;
    ruleAltList(): RuleAltListContext;
    labeledAlt(): LabeledAltContext;
    lexerRuleSpec(): LexerRuleSpecContext;
    lexerRuleBlock(): LexerRuleBlockContext;
    lexerAltList(): LexerAltListContext;
    lexerAlt(): LexerAltContext;
    lexerElements(): LexerElementsContext;
    lexerElement(): LexerElementContext;
    lexerBlock(): LexerBlockContext;
    lexerCommands(): LexerCommandsContext;
    lexerCommand(): LexerCommandContext;
    lexerCommandName(): LexerCommandNameContext;
    lexerCommandExpr(): LexerCommandExprContext;
    altList(): AltListContext;
    alternative(): AlternativeContext;
    element(): ElementContext;
    predicateOptions(): PredicateOptionsContext;
    predicateOption(): PredicateOptionContext;
    labeledElement(): LabeledElementContext;
    ebnf(): EbnfContext;
    blockSuffix(): BlockSuffixContext;
    ebnfSuffix(): EbnfSuffixContext;
    lexerAtom(): LexerAtomContext;
    atom(): AtomContext;
    wildcard(): WildcardContext;
    notSet(): NotSetContext;
    blockSet(): BlockSetContext;
    setElement(): SetElementContext;
    block(): BlockContext;
    ruleref(): RulerefContext;
    characterRange(): CharacterRangeContext;
    terminalDef(): TerminalDefContext;
    elementOptions(): ElementOptionsContext;
    elementOption(): ElementOptionContext;
    identifier(): IdentifierContext;
    qualifiedIdentifier(): QualifiedIdentifierContext;
    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 GrammarSpecContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    grammarDecl(): GrammarDeclContext;
    rules(): RulesContext;
    EOF(): antlr.TerminalNode;
    prequelConstruct(): PrequelConstructContext[];
    prequelConstruct(i: number): PrequelConstructContext | null;
    modeSpec(): ModeSpecContext[];
    modeSpec(i: number): ModeSpecContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class GrammarDeclContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    grammarType(): GrammarTypeContext;
    identifier(): IdentifierContext;
    SEMI(): antlr.TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class GrammarTypeContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    LEXER(): antlr.TerminalNode | null;
    GRAMMAR(): antlr.TerminalNode;
    PARSER(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class PrequelConstructContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    optionsSpec(): OptionsSpecContext | null;
    delegateGrammars(): DelegateGrammarsContext | null;
    tokensSpec(): TokensSpecContext | null;
    channelsSpec(): ChannelsSpecContext | null;
    action_(): Action_Context | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class OptionsSpecContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    OPTIONS(): antlr.TerminalNode;
    RBRACE(): antlr.TerminalNode;
    option(): OptionContext[];
    option(i: number): OptionContext | null;
    SEMI(): antlr.TerminalNode[];
    SEMI(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class OptionContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    identifier(): IdentifierContext;
    ASSIGN(): antlr.TerminalNode;
    optionValue(): OptionValueContext;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class OptionValueContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext | null;
    DOT(): antlr.TerminalNode[];
    DOT(i: number): antlr.TerminalNode | null;
    STRING_LITERAL(): antlr.TerminalNode | null;
    actionBlock(): ActionBlockContext | null;
    INT(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class DelegateGrammarsContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    IMPORT(): antlr.TerminalNode;
    delegateGrammar(): DelegateGrammarContext[];
    delegateGrammar(i: number): DelegateGrammarContext | null;
    SEMI(): antlr.TerminalNode;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class DelegateGrammarContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext | null;
    ASSIGN(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class TokensSpecContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    TOKENS(): antlr.TerminalNode;
    RBRACE(): antlr.TerminalNode;
    idList(): IdListContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ChannelsSpecContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    CHANNELS(): antlr.TerminalNode;
    RBRACE(): antlr.TerminalNode;
    idList(): IdListContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class IdListContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class Action_Context extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    AT(): antlr.TerminalNode;
    identifier(): IdentifierContext;
    actionBlock(): ActionBlockContext;
    actionScopeName(): ActionScopeNameContext | null;
    COLONCOLON(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ActionScopeNameContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    identifier(): IdentifierContext | null;
    LEXER(): antlr.TerminalNode | null;
    PARSER(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ActionBlockContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ACTION(): antlr.TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ArgActionBlockContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    BEGIN_ARGUMENT(): antlr.TerminalNode;
    END_ARGUMENT(): antlr.TerminalNode;
    ARGUMENT_CONTENT(): antlr.TerminalNode[];
    ARGUMENT_CONTENT(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ModeSpecContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    MODE(): antlr.TerminalNode;
    identifier(): IdentifierContext;
    SEMI(): antlr.TerminalNode;
    lexerRuleSpec(): LexerRuleSpecContext[];
    lexerRuleSpec(i: number): LexerRuleSpecContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class RulesContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ruleSpec(): RuleSpecContext[];
    ruleSpec(i: number): RuleSpecContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class RuleSpecContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    parserRuleSpec(): ParserRuleSpecContext | null;
    lexerRuleSpec(): LexerRuleSpecContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ParserRuleSpecContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    RULE_REF(): antlr.TerminalNode;
    COLON(): antlr.TerminalNode;
    ruleBlock(): RuleBlockContext;
    SEMI(): antlr.TerminalNode;
    exceptionGroup(): ExceptionGroupContext;
    ruleModifiers(): RuleModifiersContext | null;
    argActionBlock(): ArgActionBlockContext | null;
    ruleReturns(): RuleReturnsContext | null;
    throwsSpec(): ThrowsSpecContext | null;
    localsSpec(): LocalsSpecContext | null;
    rulePrequel(): RulePrequelContext[];
    rulePrequel(i: number): RulePrequelContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ExceptionGroupContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    exceptionHandler(): ExceptionHandlerContext[];
    exceptionHandler(i: number): ExceptionHandlerContext | null;
    finallyClause(): FinallyClauseContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ExceptionHandlerContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    CATCH(): antlr.TerminalNode;
    argActionBlock(): ArgActionBlockContext;
    actionBlock(): ActionBlockContext;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class FinallyClauseContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    FINALLY(): antlr.TerminalNode;
    actionBlock(): ActionBlockContext;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class RulePrequelContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    optionsSpec(): OptionsSpecContext | null;
    ruleAction(): RuleActionContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class RuleReturnsContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    RETURNS(): antlr.TerminalNode;
    argActionBlock(): ArgActionBlockContext;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ThrowsSpecContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    THROWS(): antlr.TerminalNode;
    qualifiedIdentifier(): QualifiedIdentifierContext[];
    qualifiedIdentifier(i: number): QualifiedIdentifierContext | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LocalsSpecContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    LOCALS(): antlr.TerminalNode;
    argActionBlock(): ArgActionBlockContext;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class RuleActionContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    AT(): antlr.TerminalNode;
    identifier(): IdentifierContext;
    actionBlock(): ActionBlockContext;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class RuleModifiersContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ruleModifier(): RuleModifierContext[];
    ruleModifier(i: number): RuleModifierContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class RuleModifierContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    PUBLIC(): antlr.TerminalNode | null;
    PRIVATE(): antlr.TerminalNode | null;
    PROTECTED(): antlr.TerminalNode | null;
    FRAGMENT(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class RuleBlockContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ruleAltList(): RuleAltListContext;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class RuleAltListContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    labeledAlt(): LabeledAltContext[];
    labeledAlt(i: number): LabeledAltContext | null;
    OR(): antlr.TerminalNode[];
    OR(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LabeledAltContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    alternative(): AlternativeContext;
    POUND(): antlr.TerminalNode | null;
    identifier(): IdentifierContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerRuleSpecContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    TOKEN_REF(): antlr.TerminalNode;
    COLON(): antlr.TerminalNode;
    lexerRuleBlock(): LexerRuleBlockContext;
    SEMI(): antlr.TerminalNode;
    FRAGMENT(): antlr.TerminalNode | null;
    optionsSpec(): OptionsSpecContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerRuleBlockContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    lexerAltList(): LexerAltListContext;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerAltListContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    lexerAlt(): LexerAltContext[];
    lexerAlt(i: number): LexerAltContext | null;
    OR(): antlr.TerminalNode[];
    OR(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerAltContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    lexerElements(): LexerElementsContext | null;
    lexerCommands(): LexerCommandsContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerElementsContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    lexerElement(): LexerElementContext[];
    lexerElement(i: number): LexerElementContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerElementContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    lexerAtom(): LexerAtomContext | null;
    ebnfSuffix(): EbnfSuffixContext | null;
    lexerBlock(): LexerBlockContext | null;
    actionBlock(): ActionBlockContext | null;
    QUESTION(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerBlockContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    LPAREN(): antlr.TerminalNode;
    lexerAltList(): LexerAltListContext;
    RPAREN(): antlr.TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerCommandsContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    RARROW(): antlr.TerminalNode;
    lexerCommand(): LexerCommandContext[];
    lexerCommand(i: number): LexerCommandContext | null;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerCommandContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    lexerCommandName(): LexerCommandNameContext;
    LPAREN(): antlr.TerminalNode | null;
    lexerCommandExpr(): LexerCommandExprContext | null;
    RPAREN(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerCommandNameContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    identifier(): IdentifierContext | null;
    MODE(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerCommandExprContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    identifier(): IdentifierContext | null;
    INT(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class AltListContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    alternative(): AlternativeContext[];
    alternative(i: number): AlternativeContext | null;
    OR(): antlr.TerminalNode[];
    OR(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class AlternativeContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    elementOptions(): ElementOptionsContext | null;
    element(): ElementContext[];
    element(i: number): ElementContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ElementContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    labeledElement(): LabeledElementContext | null;
    ebnfSuffix(): EbnfSuffixContext | null;
    atom(): AtomContext | null;
    ebnf(): EbnfContext | null;
    actionBlock(): ActionBlockContext | null;
    QUESTION(): antlr.TerminalNode | null;
    predicateOptions(): PredicateOptionsContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class PredicateOptionsContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    LT(): antlr.TerminalNode;
    predicateOption(): PredicateOptionContext[];
    predicateOption(i: number): PredicateOptionContext | null;
    GT(): antlr.TerminalNode;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class PredicateOptionContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    elementOption(): ElementOptionContext | null;
    identifier(): IdentifierContext | null;
    ASSIGN(): antlr.TerminalNode | null;
    actionBlock(): ActionBlockContext | null;
    INT(): antlr.TerminalNode | null;
    STRING_LITERAL(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LabeledElementContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    identifier(): IdentifierContext;
    ASSIGN(): antlr.TerminalNode | null;
    PLUS_ASSIGN(): antlr.TerminalNode | null;
    atom(): AtomContext | null;
    block(): BlockContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class EbnfContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    block(): BlockContext;
    blockSuffix(): BlockSuffixContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class BlockSuffixContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    ebnfSuffix(): EbnfSuffixContext;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class EbnfSuffixContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    QUESTION(): antlr.TerminalNode[];
    QUESTION(i: number): antlr.TerminalNode | null;
    STAR(): antlr.TerminalNode | null;
    PLUS(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class LexerAtomContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    characterRange(): CharacterRangeContext | null;
    terminalDef(): TerminalDefContext | null;
    notSet(): NotSetContext | null;
    LEXER_CHAR_SET(): antlr.TerminalNode | null;
    wildcard(): WildcardContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class AtomContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    terminalDef(): TerminalDefContext | null;
    ruleref(): RulerefContext | null;
    notSet(): NotSetContext | null;
    wildcard(): WildcardContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class WildcardContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    DOT(): antlr.TerminalNode;
    elementOptions(): ElementOptionsContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class NotSetContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    NOT(): antlr.TerminalNode;
    setElement(): SetElementContext | null;
    blockSet(): BlockSetContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class BlockSetContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    LPAREN(): antlr.TerminalNode;
    setElement(): SetElementContext[];
    setElement(i: number): SetElementContext | null;
    RPAREN(): antlr.TerminalNode;
    OR(): antlr.TerminalNode[];
    OR(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class SetElementContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    TOKEN_REF(): antlr.TerminalNode | null;
    elementOptions(): ElementOptionsContext | null;
    STRING_LITERAL(): antlr.TerminalNode | null;
    characterRange(): CharacterRangeContext | null;
    LEXER_CHAR_SET(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class BlockContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    LPAREN(): antlr.TerminalNode;
    altList(): AltListContext;
    RPAREN(): antlr.TerminalNode;
    COLON(): antlr.TerminalNode | null;
    optionsSpec(): OptionsSpecContext | null;
    ruleAction(): RuleActionContext[];
    ruleAction(i: number): RuleActionContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class RulerefContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    RULE_REF(): antlr.TerminalNode;
    argActionBlock(): ArgActionBlockContext | null;
    elementOptions(): ElementOptionsContext | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class CharacterRangeContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    STRING_LITERAL(): antlr.TerminalNode[];
    STRING_LITERAL(i: number): antlr.TerminalNode | null;
    RANGE(): antlr.TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class TerminalDefContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    TOKEN_REF(): antlr.TerminalNode | null;
    elementOptions(): ElementOptionsContext | null;
    STRING_LITERAL(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ElementOptionsContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    LT(): antlr.TerminalNode;
    elementOption(): ElementOptionContext[];
    elementOption(i: number): ElementOptionContext | null;
    GT(): antlr.TerminalNode;
    COMMA(): antlr.TerminalNode[];
    COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class ElementOptionContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    qualifiedIdentifier(): QualifiedIdentifierContext | null;
    identifier(): IdentifierContext | null;
    ASSIGN(): antlr.TerminalNode | null;
    STRING_LITERAL(): antlr.TerminalNode | null;
    INT(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class IdentifierContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    RULE_REF(): antlr.TerminalNode | null;
    TOKEN_REF(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}
export declare class QualifiedIdentifierContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext | null;
    DOT(): antlr.TerminalNode[];
    DOT(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    enterRule(listener: ANTLRv4ParserListener): void;
    exitRule(listener: ANTLRv4ParserListener): void;
}