@opra/client 0.11.1 → 0.11.2

package/typings/antlr4ts/Parser.d.ts

@@ -1,372 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-import { ANTLRErrorStrategy } from "./ANTLRErrorStrategy";
-import { ATN } from "./atn/ATN";
-import { ErrorNode } from "./tree/ErrorNode";
-import { IntegerStack } from "./misc/IntegerStack";
-import { IntervalSet } from "./misc/IntervalSet";
-import { Lexer } from "./Lexer";
-import { ParseInfo } from "./atn/ParseInfo";
-import { ParserATNSimulator } from "./atn/ParserATNSimulator";
-import { ParserErrorListener } from "./ParserErrorListener";
-import { ParserRuleContext } from "./ParserRuleContext";
-import { ParseTreeListener } from "./tree/ParseTreeListener";
-import { ParseTreePattern } from "./tree/pattern/ParseTreePattern";
-import { RecognitionException } from "./RecognitionException";
-import { Recognizer } from "./Recognizer";
-import { RuleContext } from "./RuleContext";
-import { TerminalNode } from "./tree/TerminalNode";
-import { Token } from "./Token";
-import { TokenFactory } from "./TokenFactory";
-import { TokenStream } from "./TokenStream";
-/** This is all the parsing support code essentially; most of it is error recovery stuff. */
-export declare abstract class Parser extends Recognizer<Token, ParserATNSimulator> {
-    /**
-     * This field maps from the serialized ATN string to the deserialized {@link ATN} with
-     * bypass alternatives.
-     *
-     * @see ATNDeserializationOptions.isGenerateRuleBypassTransitions
-     */
-    private static readonly bypassAltsAtnCache;
-    /**
-     * The error handling strategy for the parser. The default value is a new
-     * instance of {@link DefaultErrorStrategy}.
-     *
-     * @see #getErrorHandler
-     * @see #setErrorHandler
-     */
-    protected _errHandler: ANTLRErrorStrategy;
-    /**
-     * The input stream.
-     *
-     * @see #getInputStream
-     * @see #setInputStream
-     */
-    protected _input: TokenStream;
-    protected readonly _precedenceStack: IntegerStack;
-    /**
-     * The {@link ParserRuleContext} object for the currently executing rule.
-     *
-     * This is always non-undefined during the parsing process.
-     */
-    protected _ctx: ParserRuleContext;
-    /**
-     * Specifies whether or not the parser should construct a parse tree during
-     * the parsing process. The default value is `true`.
-     *
-     * @see `buildParseTree`
-     */
-    private _buildParseTrees;
-    /**
-     * When {@link #setTrace}`(true)` is called, a reference to the
-     * {@link TraceListener} is stored here so it can be easily removed in a
-     * later call to {@link #setTrace}`(false)`. The listener itself is
-     * implemented as a parser listener so this field is not directly used by
-     * other parser methods.
-     */
-    private _tracer;
-    /**
-     * The list of {@link ParseTreeListener} listeners registered to receive
-     * events during the parse.
-     *
-     * @see #addParseListener
-     */
-    protected _parseListeners: ParseTreeListener[];
-    /**
-     * The number of syntax errors reported during parsing. This value is
-     * incremented each time {@link #notifyErrorListeners} is called.
-     */
-    protected _syntaxErrors: number;
-    /** Indicates parser has match()ed EOF token. See {@link #exitRule()}. */
-    protected matchedEOF: boolean;
-    constructor(input: TokenStream);
-    /** reset the parser's state */
-    reset(): void;
-    reset(resetInput: boolean): void;
-    /**
-     * Match current input symbol against `ttype`. If the symbol type
-     * matches, {@link ANTLRErrorStrategy#reportMatch} and {@link #consume} are
-     * called to complete the match process.
-     *
-     * If the symbol type does not match,
-     * {@link ANTLRErrorStrategy#recoverInline} is called on the current error
-     * strategy to attempt recovery. If {@link #getBuildParseTree} is
-     * `true` and the token index of the symbol returned by
-     * {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
-     * the parse tree by calling {@link #createErrorNode(ParserRuleContext, Token)} then
-     * {@link ParserRuleContext#addErrorNode(ErrorNode)}.
-     *
-     * @param ttype the token type to match
-     * @returns the matched symbol
-     * @ if the current input symbol did not match
-     * `ttype` and the error strategy could not recover from the
-     * mismatched symbol
-     */
-    match(ttype: number): Token;
-    /**
-     * Match current input symbol as a wildcard. If the symbol type matches
-     * (i.e. has a value greater than 0), {@link ANTLRErrorStrategy#reportMatch}
-     * and {@link #consume} are called to complete the match process.
-     *
-     * If the symbol type does not match,
-     * {@link ANTLRErrorStrategy#recoverInline} is called on the current error
-     * strategy to attempt recovery. If {@link #getBuildParseTree} is
-     * `true` and the token index of the symbol returned by
-     * {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
-     * the parse tree by calling {@link Parser#createErrorNode(ParserRuleContext, Token)} then
-     * {@link ParserRuleContext#addErrorNode(ErrorNode)}.
-     *
-     * @returns the matched symbol
-     * @ if the current input symbol did not match
-     * a wildcard and the error strategy could not recover from the mismatched
-     * symbol
-     */
-    matchWildcard(): Token;
-    /**
-     * Track the {@link ParserRuleContext} objects during the parse and hook
-     * them up using the {@link ParserRuleContext#children} list so that it
-     * forms a parse tree. The {@link ParserRuleContext} returned from the start
-     * rule represents the root of the parse tree.
-     *
-     * Note that if we are not building parse trees, rule contexts only point
-     * upwards. When a rule exits, it returns the context but that gets garbage
-     * collected if nobody holds a reference. It points upwards but nobody
-     * points at it.
-     *
-     * When we build parse trees, we are adding all of these contexts to
-     * {@link ParserRuleContext#children} list. Contexts are then not candidates
-     * for garbage collection.
-     */
-    set buildParseTree(buildParseTrees: boolean);
-    /**
-     * Gets whether or not a complete parse tree will be constructed while
-     * parsing. This property is `true` for a newly constructed parser.
-     *
-     * @returns `true` if a complete parse tree will be constructed while
-     * parsing, otherwise `false`
-     */
-    get buildParseTree(): boolean;
-    getParseListeners(): ParseTreeListener[];
-    /**
-     * Registers `listener` to receive events during the parsing process.
-     *
-     * To support output-preserving grammar transformations (including but not
-     * limited to left-recursion removal, automated left-factoring, and
-     * optimized code generation), calls to listener methods during the parse
-     * may differ substantially from calls made by
-     * {@link ParseTreeWalker#DEFAULT} used after the parse is complete. In
-     * particular, rule entry and exit events may occur in a different order
-     * during the parse than after the parser. In addition, calls to certain
-     * rule entry methods may be omitted.
-     *
-     * With the following specific exceptions, calls to listener events are
-     * *deterministic*, i.e. for identical input the calls to listener
-     * methods will be the same.
-     *
-     * * Alterations to the grammar used to generate code may change the
-     *   behavior of the listener calls.
-     * * Alterations to the command line options passed to ANTLR 4 when
-     *   generating the parser may change the behavior of the listener calls.
-     * * Changing the version of the ANTLR Tool used to generate the parser
-     *   may change the behavior of the listener calls.
-     *
-     * @param listener the listener to add
-     *
-     * @throws {@link TypeError} if `listener` is `undefined`
-     */
-    addParseListener(listener: ParseTreeListener): void;
-    /**
-     * Remove `listener` from the list of parse listeners.
-     *
-     * If `listener` is `undefined` or has not been added as a parse
-     * listener, this method does nothing.
-     *
-     * @see #addParseListener
-     *
-     * @param listener the listener to remove
-     */
-    removeParseListener(listener: ParseTreeListener): void;
-    /**
-     * Remove all parse listeners.
-     *
-     * @see #addParseListener
-     */
-    removeParseListeners(): void;
-    /**
-     * Notify any parse listeners of an enter rule event.
-     *
-     * @see #addParseListener
-     */
-    protected triggerEnterRuleEvent(): void;
-    /**
-     * Notify any parse listeners of an exit rule event.
-     *
-     * @see #addParseListener
-     */
-    protected triggerExitRuleEvent(): void;
-    /**
-     * Gets the number of syntax errors reported during parsing. This value is
-     * incremented each time {@link #notifyErrorListeners} is called.
-     *
-     * @see #notifyErrorListeners
-     */
-    get numberOfSyntaxErrors(): number;
-    get tokenFactory(): TokenFactory;
-    /**
-     * The ATN with bypass alternatives is expensive to create so we create it
-     * lazily.
-     *
-     * @ if the current parser does not
-     * implement the `serializedATN` property.
-     */
-    getATNWithBypassAlts(): ATN;
-    /**
-     * The preferred method of getting a tree pattern. For example, here's a
-     * sample use:
-     *
-     * ```
-     * let t: ParseTree = parser.expr();
-     * let p: ParseTreePattern = await parser.compileParseTreePattern("<ID>+0", MyParser.RULE_expr);
-     * let m: ParseTreeMatch = p.match(t);
-     * let id: string = m.get("ID");
-     * ```
-     */
-    compileParseTreePattern(pattern: string, patternRuleIndex: number): Promise<ParseTreePattern>;
-    /**
-     * The same as {@link #compileParseTreePattern(String, int)} but specify a
-     * {@link Lexer} rather than trying to deduce it from this parser.
-     */
-    compileParseTreePattern(pattern: string, patternRuleIndex: number, lexer?: Lexer): Promise<ParseTreePattern>;
-    get errorHandler(): ANTLRErrorStrategy;
-    set errorHandler(handler: ANTLRErrorStrategy);
-    get inputStream(): TokenStream;
-    /** Set the token stream and reset the parser. */
-    set inputStream(input: TokenStream);
-    /** Match needs to return the current input symbol, which gets put
-     *  into the label for the associated token ref; e.g., x=ID.
-     */
-    get currentToken(): Token;
-    notifyErrorListeners(/*@NotNull*/ msg: string): void;
-    notifyErrorListeners(/*@NotNull*/ msg: string, /*@NotNull*/ offendingToken: Token | null, e: RecognitionException | undefined): void;
-    /**
-     * Consume and return the [current symbol](`currentToken`).
-     *
-     * E.g., given the following input with `A` being the current
-     * lookahead symbol, this function moves the cursor to `B` and returns
-     * `A`.
-     *
-     * ```
-     * A B
-     * ^
-     * ```
-     *
-     * If the parser is not in error recovery mode, the consumed symbol is added
-     * to the parse tree using {@link ParserRuleContext#addChild(TerminalNode)}, and
-     * {@link ParseTreeListener#visitTerminal} is called on any parse listeners.
-     * If the parser *is* in error recovery mode, the consumed symbol is
-     * added to the parse tree using {@link #createErrorNode(ParserRuleContext, Token)} then
-     * {@link ParserRuleContext#addErrorNode(ErrorNode)} and
-     * {@link ParseTreeListener#visitErrorNode} is called on any parse
-     * listeners.
-     */
-    consume(): Token;
-    /**
-     * How to create a token leaf node associated with a parent.
-     * Typically, the terminal node to create is not a function of the parent.
-     *
-     * @since 4.7
-     */
-    createTerminalNode(parent: ParserRuleContext, t: Token): TerminalNode;
-    /**
-     * How to create an error node, given a token, associated with a parent.
-     * Typically, the error node to create is not a function of the parent.
-     *
-     * @since 4.7
-     */
-    createErrorNode(parent: ParserRuleContext, t: Token): ErrorNode;
-    protected addContextToParseTree(): void;
-    /**
-     * Always called by generated parsers upon entry to a rule. Access field
-     * {@link #_ctx} get the current context.
-     */
-    enterRule(localctx: ParserRuleContext, state: number, ruleIndex: number): void;
-    enterLeftFactoredRule(localctx: ParserRuleContext, state: number, ruleIndex: number): void;
-    exitRule(): void;
-    enterOuterAlt(localctx: ParserRuleContext, altNum: number): void;
-    /**
-     * Get the precedence level for the top-most precedence rule.
-     *
-     * @returns The precedence level for the top-most precedence rule, or -1 if
-     * the parser context is not nested within a precedence rule.
-     */
-    get precedence(): number;
-    enterRecursionRule(localctx: ParserRuleContext, state: number, ruleIndex: number, precedence: number): void;
-    /** Like {@link #enterRule} but for recursive rules.
-     *  Make the current context the child of the incoming localctx.
-     */
-    pushNewRecursionContext(localctx: ParserRuleContext, state: number, ruleIndex: number): void;
-    unrollRecursionContexts(_parentctx: ParserRuleContext): void;
-    getInvokingContext(ruleIndex: number): ParserRuleContext | undefined;
-    get context(): ParserRuleContext;
-    set context(ctx: ParserRuleContext);
-    precpred(localctx: RuleContext, precedence: number): boolean;
-    getErrorListenerDispatch(): ParserErrorListener;
-    inContext(context: string): boolean;
-    /**
-     * Checks whether or not `symbol` can follow the current state in the
-     * ATN. The behavior of this method is equivalent to the following, but is
-     * implemented such that the complete context-sensitive follow set does not
-     * need to be explicitly constructed.
-     *
-     * ```
-     * return getExpectedTokens().contains(symbol);
-     * ```
-     *
-     * @param symbol the symbol type to check
-     * @returns `true` if `symbol` can follow the current state in
-     * the ATN, otherwise `false`.
-     */
-    isExpectedToken(symbol: number): boolean;
-    get isMatchedEOF(): boolean;
-    /**
-     * Computes the set of input symbols which could follow the current parser
-     * state and context, as given by {@link #getState} and {@link #getContext},
-     * respectively.
-     *
-     * @see ATN#getExpectedTokens(int, RuleContext)
-     */
-    getExpectedTokens(): IntervalSet;
-    getExpectedTokensWithinCurrentRule(): IntervalSet;
-    /** Get a rule's index (i.e., `RULE_ruleName` field) or -1 if not found. */
-    getRuleIndex(ruleName: string): number;
-    get ruleContext(): ParserRuleContext;
-    /** Return List&lt;String&gt; of the rule names in your parser instance
-     *  leading up to a call to the current rule.  You could override if
-     *  you want more details such as the file/line info of where
-     *  in the ATN a rule is invoked.
-     *
-     *  This is very useful for error messages.
-     */
-    getRuleInvocationStack(ctx?: RuleContext): string[];
-    /** For debugging and other purposes. */
-    getDFAStrings(): string[];
-    /** For debugging and other purposes. */
-    dumpDFA(): void;
-    get sourceName(): string;
-    get parseInfo(): Promise<ParseInfo | undefined>;
-    /**
-     * @since 4.3
-     */
-    setProfile(profile: boolean): Promise<void>;
-    /** During a parse is sometimes useful to listen in on the rule entry and exit
-     *  events as well as token matches. This is for quick and dirty debugging.
-     */
-    set isTrace(trace: boolean);
-    /**
-     * Gets whether a {@link TraceListener} is registered as a parse listener
-     * for the parser.
-     */
-    get isTrace(): boolean;
-}

package/typings/antlr4ts/ParserErrorListener.d.ts

@@ -1,112 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-import { ANTLRErrorListener } from "./ANTLRErrorListener";
-import { ATNConfigSet } from "./atn/ATNConfigSet";
-import { BitSet } from "./misc/BitSet";
-import { DFA } from "./dfa/DFA";
-import { Parser } from "./Parser";
-import { SimulatorState } from "./atn/SimulatorState";
-import { Token } from "./Token";
-/** How to emit recognition errors for parsers.
- */
-export interface ParserErrorListener extends ANTLRErrorListener<Token> {
-    /**
-     * This method is called by the parser when a full-context prediction
-     * results in an ambiguity.
-     *
-     * Each full-context prediction which does not result in a syntax error
-     * will call either {@link #reportContextSensitivity} or
-     * {@link #reportAmbiguity}.
-     *
-     * When `ambigAlts` is not `undefined`, it contains the set of potentially
-     * viable alternatives identified by the prediction algorithm. When
-     * `ambigAlts` is `undefined`, use
-     * {@link ATNConfigSet#getRepresentedAlternatives} to obtain the represented
-     * alternatives from the `configs` argument.
-     *
-     * When `exact` is `true`, *all* of the potentially
-     * viable alternatives are truly viable, i.e. this is reporting an exact
-     * ambiguity. When `exact` is `false`, *at least two* of
-     * the potentially viable alternatives are viable for the current input, but
-     * the prediction algorithm terminated as soon as it determined that at
-     * least the *minimum* potentially viable alternative is truly
-     * viable.
-     *
-     * When the {@link PredictionMode#LL_EXACT_AMBIG_DETECTION} prediction
-     * mode is used, the parser is required to identify exact ambiguities so
-     * `exact` will always be `true`.
-     *
-     * @param recognizer the parser instance
-     * @param dfa the DFA for the current decision
-     * @param startIndex the input index where the decision started
-     * @param stopIndex the input input where the ambiguity was identified
-     * @param exact `true` if the ambiguity is exactly known, otherwise
-     * `false`. This is always `true` when
-     * {@link PredictionMode#LL_EXACT_AMBIG_DETECTION} is used.
-     * @param ambigAlts the potentially ambiguous alternatives, or `undefined`
-     * to indicate that the potentially ambiguous alternatives are the complete
-     * set of represented alternatives in `configs`
-     * @param configs the ATN configuration set where the ambiguity was
-     * identified
-     */
-    reportAmbiguity?: (recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, exact: boolean, ambigAlts: BitSet | undefined, configs: ATNConfigSet) => void;
-    /**
-     * This method is called when an SLL conflict occurs and the parser is about
-     * to use the full context information to make an LL decision.
-     *
-     * If one or more configurations in `configs` contains a semantic
-     * predicate, the predicates are evaluated before this method is called. The
-     * subset of alternatives which are still viable after predicates are
-     * evaluated is reported in `conflictingAlts`.
-     *
-     * @param recognizer the parser instance
-     * @param dfa the DFA for the current decision
-     * @param startIndex the input index where the decision started
-     * @param stopIndex the input index where the SLL conflict occurred
-     * @param conflictingAlts The specific conflicting alternatives. If this is
-     * `undefined`, the conflicting alternatives are all alternatives
-     * represented in `configs`.
-     * @param conflictState the simulator state when the SLL conflict was
-     * detected
-     */
-    reportAttemptingFullContext?: (recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, conflictingAlts: BitSet | undefined, conflictState: SimulatorState) => void;
-    /**
-     * This method is called by the parser when a full-context prediction has a
-     * unique result.
-     *
-     * Each full-context prediction which does not result in a syntax error
-     * will call either {@link #reportContextSensitivity} or
-     * {@link #reportAmbiguity}.
-     *
-     * For prediction implementations that only evaluate full-context
-     * predictions when an SLL conflict is found (including the default
-     * {@link ParserATNSimulator} implementation), this method reports cases
-     * where SLL conflicts were resolved to unique full-context predictions,
-     * i.e. the decision was context-sensitive. This report does not necessarily
-     * indicate a problem, and it may appear even in completely unambiguous
-     * grammars.
-     *
-     * `configs` may have more than one represented alternative if the
-     * full-context prediction algorithm does not evaluate predicates before
-     * beginning the full-context prediction. In all cases, the final prediction
-     * is passed as the `prediction` argument.
-     *
-     * Note that the definition of "context sensitivity" in this method
-     * differs from the concept in {@link DecisionInfo#contextSensitivities}.
-     * This method reports all instances where an SLL conflict occurred but LL
-     * parsing produced a unique result, whether or not that unique result
-     * matches the minimum alternative in the SLL conflicting set.
-     *
-     * @param recognizer the parser instance
-     * @param dfa the DFA for the current decision
-     * @param startIndex the input index where the decision started
-     * @param stopIndex the input index where the context sensitivity was
-     * finally determined
-     * @param prediction the unambiguous result of the full-context prediction
-     * @param acceptState the simulator state when the unambiguous prediction
-     * was determined
-     */
-    reportContextSensitivity?: (recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, prediction: number, acceptState: SimulatorState) => void;
-}

package/typings/antlr4ts/ParserInterpreter.d.ts

@@ -1,151 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-import { ATN } from "./atn/ATN";
-import { ATNState } from "./atn/ATNState";
-import { BitSet } from "./misc/BitSet";
-import { DecisionState } from "./atn/DecisionState";
-import { InterpreterRuleContext } from "./InterpreterRuleContext";
-import { Parser } from "./Parser";
-import { ParserRuleContext } from "./ParserRuleContext";
-import { RecognitionException } from "./RecognitionException";
-import { Token } from "./Token";
-import { TokenStream } from "./TokenStream";
-import { Vocabulary } from "./Vocabulary";
-/** A parser simulator that mimics what ANTLR's generated
- *  parser code does. A ParserATNSimulator is used to make
- *  predictions via adaptivePredict but this class moves a pointer through the
- *  ATN to simulate parsing. ParserATNSimulator just
- *  makes us efficient rather than having to backtrack, for example.
- *
- *  This properly creates parse trees even for left recursive rules.
- *
- *  We rely on the left recursive rule invocation and special predicate
- *  transitions to make left recursive rules work.
- *
- *  See TestParserInterpreter for examples.
- */
-export declare class ParserInterpreter extends Parser {
-    protected _grammarFileName: string;
-    protected _atn: ATN;
-    /** This identifies StarLoopEntryState's that begin the (...)*
-     *  precedence loops of left recursive rules.
-     */
-    protected pushRecursionContextStates: BitSet;
-    protected _ruleNames: string[];
-    private _vocabulary;
-    /** This stack corresponds to the _parentctx, _parentState pair of locals
-     *  that would exist on call stack frames with a recursive descent parser;
-     *  in the generated function for a left-recursive rule you'd see:
-     *
-     *  private EContext e(int _p) {
-     *      ParserRuleContext _parentctx = _ctx;    // Pair.a
-     *      int _parentState = state;          // Pair.b
-     *      ...
-     *  }
-     *
-     *  Those values are used to create new recursive rule invocation contexts
-     *  associated with left operand of an alt like "expr '*' expr".
-     */
-    protected readonly _parentContextStack: Array<[ParserRuleContext, number]>;
-    /** We need a map from (decision,inputIndex)->forced alt for computing ambiguous
-     *  parse trees. For now, we allow exactly one override.
-     */
-    protected overrideDecision: number;
-    protected overrideDecisionInputIndex: number;
-    protected overrideDecisionAlt: number;
-    protected overrideDecisionReached: boolean;
-    /** What is the current context when we override a decisions?  This tells
-     *  us what the root of the parse tree is when using override
-     *  for an ambiguity/lookahead check.
-     */
-    protected _overrideDecisionRoot?: InterpreterRuleContext;
-    protected _rootContext: InterpreterRuleContext;
-    /** A copy constructor that creates a new parser interpreter by reusing
-     *  the fields of a previous interpreter.
-     *
-     *  @param old The interpreter to copy
-     *
-     *  @since 4.5
-     */
-    constructor(/*@NotNull*/ old: ParserInterpreter);
-    constructor(grammarFileName: string, /*@NotNull*/ vocabulary: Vocabulary, ruleNames: string[], atn: ATN, input: TokenStream);
-    reset(resetInput?: boolean): void;
-    get atn(): ATN;
-    get vocabulary(): Vocabulary;
-    get ruleNames(): string[];
-    get grammarFileName(): string;
-    /** Begin parsing at startRuleIndex */
-    parse(startRuleIndex: number): ParserRuleContext;
-    enterRecursionRule(localctx: ParserRuleContext, state: number, ruleIndex: number, precedence: number): void;
-    protected get atnState(): ATNState;
-    protected visitState(p: ATNState): void;
-    /** Method visitDecisionState() is called when the interpreter reaches
-     *  a decision state (instance of DecisionState). It gives an opportunity
-     *  for subclasses to track interesting things.
-     */
-    protected visitDecisionState(p: DecisionState): number;
-    /** Provide simple "factory" for InterpreterRuleContext's.
-     *  @since 4.5.1
-     */
-    protected createInterpreterRuleContext(parent: ParserRuleContext | undefined, invokingStateNumber: number, ruleIndex: number): InterpreterRuleContext;
-    protected visitRuleStopState(p: ATNState): void;
-    /** Override this parser interpreters normal decision-making process
-     *  at a particular decision and input token index. Instead of
-     *  allowing the adaptive prediction mechanism to choose the
-     *  first alternative within a block that leads to a successful parse,
-     *  force it to take the alternative, 1..n for n alternatives.
-     *
-     *  As an implementation limitation right now, you can only specify one
-     *  override. This is sufficient to allow construction of different
-     *  parse trees for ambiguous input. It means re-parsing the entire input
-     *  in general because you're never sure where an ambiguous sequence would
-     *  live in the various parse trees. For example, in one interpretation,
-     *  an ambiguous input sequence would be matched completely in expression
-     *  but in another it could match all the way back to the root.
-     *
-     *  s : e '!'? ;
-     *  e : ID
-     *    | ID '!'
-     *    ;
-     *
-     *  Here, x! can be matched as (s (e ID) !) or (s (e ID !)). In the first
-     *  case, the ambiguous sequence is fully contained only by the root.
-     *  In the second case, the ambiguous sequences fully contained within just
-     *  e, as in: (e ID !).
-     *
-     *  Rather than trying to optimize this and make
-     *  some intelligent decisions for optimization purposes, I settled on
-     *  just re-parsing the whole input and then using
-     *  {link Trees#getRootOfSubtreeEnclosingRegion} to find the minimal
-     *  subtree that contains the ambiguous sequence. I originally tried to
-     *  record the call stack at the point the parser detected and ambiguity but
-     *  left recursive rules create a parse tree stack that does not reflect
-     *  the actual call stack. That impedance mismatch was enough to make
-     *  it it challenging to restart the parser at a deeply nested rule
-     *  invocation.
-     *
-     *  Only parser interpreters can override decisions so as to avoid inserting
-     *  override checking code in the critical ALL(*) prediction execution path.
-     *
-     *  @since 4.5
-     */
-    addDecisionOverride(decision: number, tokenIndex: number, forcedAlt: number): void;
-    get overrideDecisionRoot(): InterpreterRuleContext | undefined;
-    /** Rely on the error handler for this parser but, if no tokens are consumed
-     *  to recover, add an error node. Otherwise, nothing is seen in the parse
-     *  tree.
-     */
-    protected recover(e: RecognitionException): void;
-    protected recoverInline(): Token;
-    /** Return the root of the parse, which can be useful if the parser
-     *  bails out. You still can access the top node. Note that,
-     *  because of the way left recursive rules add children, it's possible
-     *  that the root will not have any children if the start rule immediately
-     *  called and left recursive rule that fails.
-     *
-     * @since 4.5.1
-     */
-    get rootContext(): InterpreterRuleContext;
-}