@opra/client 0.11.1 → 0.11.2

package/typings/antlr4ts/DiagnosticErrorListener.d.ts

@@ -1,60 +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 { ATNConfigSet } from "./atn/ATNConfigSet";
-import { BitSet } from "./misc/BitSet";
-import { DFA } from "./dfa/DFA";
-import { Parser } from "./Parser";
-import { ParserErrorListener } from "./ParserErrorListener";
-import { RecognitionException } from "./RecognitionException";
-import { Recognizer } from "./Recognizer";
-import { SimulatorState } from "./atn/SimulatorState";
-import { Token } from "./Token";
-/**
- * This implementation of {@link ANTLRErrorListener} can be used to identify
- * certain potential correctness and performance problems in grammars. "Reports"
- * are made by calling {@link Parser#notifyErrorListeners} with the appropriate
- * message.
- *
- * * **Ambiguities**: These are cases where more than one path through the
- *   grammar can match the input.
- * * **Weak context sensitivity**: These are cases where full-context
- *   prediction resolved an SLL conflict to a unique alternative which equaled the
- *   minimum alternative of the SLL conflict.
- * * **Strong (forced) context sensitivity**: These are cases where the
- *   full-context prediction resolved an SLL conflict to a unique alternative,
- *   *and* the minimum alternative of the SLL conflict was found to not be
- *   a truly viable alternative. Two-stage parsing cannot be used for inputs where
- *   this situation occurs.
- *
- * @author Sam Harwell
- */
-export declare class DiagnosticErrorListener implements ParserErrorListener {
-    protected exactOnly: boolean;
-    /**
-     * Initializes a new instance of {@link DiagnosticErrorListener}, specifying
-     * whether all ambiguities or only exact ambiguities are reported.
-     *
-     * @param exactOnly `true` to report only exact ambiguities, otherwise
-     * `false` to report all ambiguities.  Defaults to true.
-     */
-    constructor(exactOnly?: boolean);
-    syntaxError<T extends Token>(recognizer: Recognizer<T, any>, offendingSymbol: T | undefined, line: number, charPositionInLine: number, msg: string, e: RecognitionException | undefined): void;
-    reportAmbiguity(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, exact: boolean, ambigAlts: BitSet | undefined, configs: ATNConfigSet): void;
-    reportAttemptingFullContext(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, conflictingAlts: BitSet | undefined, conflictState: SimulatorState): void;
-    reportContextSensitivity(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, prediction: number, acceptState: SimulatorState): void;
-    protected getDecisionDescription(recognizer: Parser, dfa: DFA): string;
-    /**
-     * Computes the set of conflicting or ambiguous alternatives from a
-     * configuration set, if that information was not already provided by the
-     * parser.
-     *
-     * @param reportedAlts The set of conflicting or ambiguous alternatives, as
-     * reported by the parser.
-     * @param configs The conflicting or ambiguous configuration set.
-     * @returns Returns `reportedAlts` if it is not `undefined`, otherwise
-     * returns the set of alternatives represented in `configs`.
-     */
-    protected getConflictingAlts(reportedAlts: BitSet | undefined, configs: ATNConfigSet): BitSet;
-}

package/typings/antlr4ts/FailedPredicateException.d.ts

@@ -1,21 +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 { Parser } from "./Parser";
-import { RecognitionException } from "./RecognitionException";
-/** A semantic predicate failed during validation.  Validation of predicates
- *  occurs when normally parsing the alternative just like matching a token.
- *  Disambiguating predicate evaluation occurs when we test a predicate during
- *  prediction.
- */
-export declare class FailedPredicateException extends RecognitionException {
-    private _ruleIndex;
-    private _predicateIndex;
-    private _predicate?;
-    constructor(recognizer: Parser, predicate?: string, message?: string);
-    get ruleIndex(): number;
-    get predicateIndex(): number;
-    get predicate(): string | undefined;
-    private static formatMessage;
-}

package/typings/antlr4ts/InputMismatchException.d.ts

@@ -1,14 +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 { RecognitionException } from "./RecognitionException";
-import { Parser } from "./Parser";
-import { ParserRuleContext } from "./ParserRuleContext";
-/** This signifies any kind of mismatched input exceptions such as
- *  when the current input does not match the expected token.
- */
-export declare class InputMismatchException extends RecognitionException {
-    constructor(/*@NotNull*/ recognizer: Parser);
-    constructor(/*@NotNull*/ recognizer: Parser, state: number, context: ParserRuleContext);
-}

package/typings/antlr4ts/IntStream.d.ts

@@ -1,197 +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.
- */
-export declare namespace IntStream {
-    /**
-     * The value returned by {@link #LA LA()} when the end of the stream is
-     * reached.
-     */
-    const EOF: number;
-    /**
-     * The value returned by {@link #getSourceName} when the actual name of the
-     * underlying source is not known.
-     */
-    const UNKNOWN_SOURCE_NAME: string;
-}
-/**
- * A simple stream of symbols whose values are represented as integers. This
- * interface provides *marked ranges* with support for a minimum level
- * of buffering necessary to implement arbitrary lookahead during prediction.
- * For more information on marked ranges, see {@link #mark}.
- *
- * **Initializing Methods:** Some methods in this interface have
- * unspecified behavior if no call to an initializing method has occurred after
- * the stream was constructed. The following is a list of initializing methods:
- *
- * * {@link #LA}
- * * {@link #consume}
- * * {@link #size}
- */
-export interface IntStream {
-    /**
-     * Consumes the current symbol in the stream. This method has the following
-     * effects:
-     *
-     * * **Forward movement:** The value of `index`
-     *   before calling this method is less than the value of `index`
-     *   after calling this method.
-     * * **Ordered lookahead:** The value of `LA(1)` before
-     *   calling this method becomes the value of `LA(-1)` after calling
-     *   this method.
-     *
-     * Note that calling this method does not guarantee that `index` is
-     * incremented by exactly 1, as that would preclude the ability to implement
-     * filtering streams (e.g. {@link CommonTokenStream} which distinguishes
-     * between "on-channel" and "off-channel" tokens).
-     *
-     * @throws IllegalStateException if an attempt is made to consume the
-     * end of the stream (i.e. if `LA(1)==`{@link #EOF EOF} before calling
-     * `consume`).
-     */
-    consume(): void;
-    /**
-     * Gets the value of the symbol at offset `i` from the current
-     * position. When `i==1`, this method returns the value of the current
-     * symbol in the stream (which is the next symbol to be consumed). When
-     * `i==-1`, this method returns the value of the previously read
-     * symbol in the stream. It is not valid to call this method with
-     * `i==0`, but the specific behavior is unspecified because this
-     * method is frequently called from performance-critical code.
-     *
-     * This method is guaranteed to succeed if any of the following are true:
-     *
-     * * `i>0`
-     * * `i==-1` and `index` returns a value greater
-     *   than the value of `index` after the stream was constructed
-     *   and `LA(1)` was called in that order. Specifying the current
-     *   `index` relative to the index after the stream was created
-     *   allows for filtering implementations that do not return every symbol
-     *   from the underlying source. Specifying the call to `LA(1)`
-     *   allows for lazily initialized streams.
-     * * `LA(i)` refers to a symbol consumed within a marked region
-     *   that has not yet been released.
-     *
-     * If `i` represents a position at or beyond the end of the stream,
-     * this method returns {@link #EOF}.
-     *
-     * The return value is unspecified if `i<0` and fewer than `-i`
-     * calls to {@link #consume consume()} have occurred from the beginning of
-     * the stream before calling this method.
-     *
-     * @throws UnsupportedOperationException if the stream does not support
-     * retrieving the value of the specified symbol
-     */
-    LA(i: number): number;
-    /**
-     * A mark provides a guarantee that {@link #seek seek()} operations will be
-     * valid over a "marked range" extending from the index where `mark()`
-     * was called to the current `index`. This allows the use of
-     * streaming input sources by specifying the minimum buffering requirements
-     * to support arbitrary lookahead during prediction.
-     *
-     * The returned mark is an opaque handle (type `int`) which is passed
-     * to {@link #release release()} when the guarantees provided by the marked
-     * range are no longer necessary. When calls to
-     * `mark()`/`release()` are nested, the marks must be released
-     * in reverse order of which they were obtained. Since marked regions are
-     * used during performance-critical sections of prediction, the specific
-     * behavior of invalid usage is unspecified (i.e. a mark is not released, or
-     * a mark is released twice, or marks are not released in reverse order from
-     * which they were created).
-     *
-     * The behavior of this method is unspecified if no call to an
-     * {@link IntStream initializing method} has occurred after this stream was
-     * constructed.
-     *
-     * This method does not change the current position in the input stream.
-     *
-     * The following example shows the use of {@link #mark mark()},
-     * {@link #release release(mark)}, `index`, and
-     * {@link #seek seek(index)} as part of an operation to safely work within a
-     * marked region, then restore the stream position to its original value and
-     * release the mark.
-     *
-     * ```
-     * IntStream stream = ...;
-     * int index = -1;
-     * int mark = stream.mark();
-     * try {
-     *   index = stream.index;
-     *   // perform work here...
-     * } finally {
-     *   if (index != -1) {
-     *     stream.seek(index);
-     *   }
-     *   stream.release(mark);
-     * }
-     * ```
-     *
-     * @returns An opaque marker which should be passed to
-     * {@link #release release()} when the marked range is no longer required.
-     */
-    mark(): number;
-    /**
-     * This method releases a marked range created by a call to
-     * {@link #mark mark()}. Calls to `release()` must appear in the
-     * reverse order of the corresponding calls to `mark()`. If a mark is
-     * released twice, or if marks are not released in reverse order of the
-     * corresponding calls to `mark()`, the behavior is unspecified.
-     *
-     * For more information and an example, see {@link #mark}.
-     *
-     * @param marker A marker returned by a call to `mark()`.
-     * @see #mark
-     */
-    release(marker: number): void;
-    /**
-     * Return the index into the stream of the input symbol referred to by
-     * `LA(1)`.
-     *
-     * The behavior of this method is unspecified if no call to an
-     * {@link IntStream initializing method} has occurred after this stream was
-     * constructed.
-     */
-    readonly index: number;
-    /**
-     * Set the input cursor to the position indicated by `index`. If the
-     * specified index lies past the end of the stream, the operation behaves as
-     * though `index` was the index of the EOF symbol. After this method
-     * returns without throwing an exception, then at least one of the following
-     * will be true.
-     *
-     * * `index` will return the index of the first symbol
-     *   appearing at or after the specified `index`. Specifically,
-     *   implementations which filter their sources should automatically
-     *   adjust `index` forward the minimum amount required for the
-     *   operation to target a non-ignored symbol.
-     * * `LA(1)` returns {@link #EOF}
-     *
-     * This operation is guaranteed to not throw an exception if `index`
-     * lies within a marked region. For more information on marked regions, see
-     * {@link #mark}. The behavior of this method is unspecified if no call to
-     * an {@link IntStream initializing method} has occurred after this stream
-     * was constructed.
-     *
-     * @param index The absolute index to seek to.
-     *
-     * @throws IllegalArgumentException if `index` is less than 0
-     * @throws UnsupportedOperationException if the stream does not support
-     * seeking to the specified index
-     */
-    seek(index: number): void;
-    /**
-     * Returns the total number of symbols in the stream, including a single EOF
-     * symbol.
-     *
-     * @throws UnsupportedOperationException if the size of the stream is
-     * unknown.
-     */
-    readonly size: number;
-    /**
-     * Gets the name of the underlying symbol source. This method returns a
-     * non-undefined, non-empty string. If such a name is not known, this method
-     * returns {@link #UNKNOWN_SOURCE_NAME}.
-     */
-    readonly sourceName: string;
-}

package/typings/antlr4ts/InterpreterRuleContext.d.ts

@@ -1,33 +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 { ParserRuleContext } from "./ParserRuleContext";
-/**
- * This class extends {@link ParserRuleContext} by allowing the value of
- * {@link #getRuleIndex} to be explicitly set for the context.
- *
- * {@link ParserRuleContext} does not include field storage for the rule index
- * since the context classes created by the code generator override the
- * {@link #getRuleIndex} method to return the correct value for that context.
- * Since the parser interpreter does not use the context classes generated for a
- * parser, this class (with slightly more memory overhead per node) is used to
- * provide equivalent functionality.
- */
-export declare class InterpreterRuleContext extends ParserRuleContext {
-    /**
-     * This is the backing field for {@link #getRuleIndex}.
-     */
-    private _ruleIndex;
-    constructor(ruleIndex: number);
-    /**
-     * Constructs a new {@link InterpreterRuleContext} with the specified
-     * parent, invoking state, and rule index.
-     *
-     * @param ruleIndex The rule index for the current context.
-     * @param parent The parent context.
-     * @param invokingStateNumber The invoking state number.
-     */
-    constructor(ruleIndex: number, parent: ParserRuleContext | undefined, invokingStateNumber: number);
-    get ruleIndex(): number;
-}

package/typings/antlr4ts/Lexer.d.ts

@@ -1,141 +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 { CharStream } from "./CharStream";
-import { IntegerStack } from "./misc/IntegerStack";
-import { LexerATNSimulator } from "./atn/LexerATNSimulator";
-import { LexerNoViableAltException } from "./LexerNoViableAltException";
-import { RecognitionException } from "./RecognitionException";
-import { Recognizer } from "./Recognizer";
-import { Token } from "./Token";
-import { TokenFactory } from "./TokenFactory";
-import { TokenSource } from "./TokenSource";
-/** A lexer is recognizer that draws input symbols from a character stream.
- *  lexer grammars result in a subclass of this object. A Lexer object
- *  uses simplified match() and error recovery mechanisms in the interest
- *  of speed.
- */
-export declare abstract class Lexer extends Recognizer<number, LexerATNSimulator> implements TokenSource {
-    static readonly DEFAULT_MODE: number;
-    static readonly MORE: number;
-    static readonly SKIP: number;
-    static get DEFAULT_TOKEN_CHANNEL(): number;
-    static get HIDDEN(): number;
-    static readonly MIN_CHAR_VALUE: number;
-    static readonly MAX_CHAR_VALUE: number;
-    _input: CharStream;
-    protected _tokenFactorySourcePair: {
-        source: TokenSource;
-        stream: CharStream;
-    };
-    /** How to create token objects */
-    protected _factory: TokenFactory;
-    /** The goal of all lexer rules/methods is to create a token object.
-     *  This is an instance variable as multiple rules may collaborate to
-     *  create a single token.  nextToken will return this object after
-     *  matching lexer rule(s).  If you subclass to allow multiple token
-     *  emissions, then set this to the last token to be matched or
-     *  something non-undefined so that the auto token emit mechanism will not
-     *  emit another token.
-     */
-    _token: Token | undefined;
-    /** What character index in the stream did the current token start at?
-     *  Needed, for example, to get the text for current token.  Set at
-     *  the start of nextToken.
-     */
-    _tokenStartCharIndex: number;
-    /** The line on which the first character of the token resides */
-    _tokenStartLine: number;
-    /** The character position of first character within the line */
-    _tokenStartCharPositionInLine: number;
-    /** Once we see EOF on char stream, next token will be EOF.
-     *  If you have DONE : EOF ; then you see DONE EOF.
-     */
-    _hitEOF: boolean;
-    /** The channel number for the current token */
-    _channel: number;
-    /** The token type for the current token */
-    _type: number;
-    readonly _modeStack: IntegerStack;
-    _mode: number;
-    /** You can set the text for the current token to override what is in
-     *  the input char buffer.  Set `text` or can set this instance var.
-     */
-    _text: string | undefined;
-    constructor(input: CharStream);
-    reset(): void;
-    reset(resetInput: boolean): void;
-    /** Return a token from this source; i.e., match a token on the char
-     *  stream.
-     */
-    nextToken(): Token;
-    /** Instruct the lexer to skip creating a token for current lexer rule
-     *  and look for another token.  nextToken() knows to keep looking when
-     *  a lexer rule finishes with token set to SKIP_TOKEN.  Recall that
-     *  if token==undefined at end of any token rule, it creates one for you
-     *  and emits it.
-     */
-    skip(): void;
-    more(): void;
-    mode(m: number): void;
-    pushMode(m: number): void;
-    popMode(): number;
-    get tokenFactory(): TokenFactory;
-    set tokenFactory(factory: TokenFactory);
-    get inputStream(): CharStream;
-    /** Set the char stream and reset the lexer */
-    set inputStream(input: CharStream);
-    get sourceName(): string;
-    /** The standard method called to automatically emit a token at the
-     *  outermost lexical rule.  The token object should point into the
-     *  char buffer start..stop.  If there is a text override in 'text',
-     *  use that to set the token's text.  Override this method to emit
-     *  custom Token objects or provide a new factory.
-     */
-    emit(token: Token): Token;
-    /** By default does not support multiple emits per nextToken invocation
-     *  for efficiency reasons.  Subclass and override this method, nextToken,
-     *  and getToken (to push tokens into a list and pull from that list
-     *  rather than a single variable as this implementation does).
-     */
-    emit(): Token;
-    emitEOF(): Token;
-    get line(): number;
-    set line(line: number);
-    get charPositionInLine(): number;
-    set charPositionInLine(charPositionInLine: number);
-    /** What is the index of the current character of lookahead? */
-    get charIndex(): number;
-    /** Return the text matched so far for the current token or any
-     *  text override.
-     */
-    get text(): string;
-    /** Set the complete text of this token; it wipes any previous
-     *  changes to the text.
-     */
-    set text(text: string);
-    /** Override if emitting multiple tokens. */
-    get token(): Token | undefined;
-    set token(_token: Token | undefined);
-    set type(ttype: number);
-    get type(): number;
-    set channel(channel: number);
-    get channel(): number;
-    abstract readonly channelNames: string[];
-    abstract readonly modeNames: string[];
-    /** Return a list of all Token objects in input char stream.
-     *  Forces load of all tokens. Does not include EOF token.
-     */
-    getAllTokens(): Token[];
-    notifyListeners(e: LexerNoViableAltException): void;
-    getErrorDisplay(s: string | number): string;
-    getCharErrorDisplay(c: number): string;
-    /** Lexers can normally match any char in it's vocabulary after matching
-     *  a token, so do the easy thing and just kill a character and hope
-     *  it all works out.  You can instead use the rule invocation stack
-     *  to do sophisticated error recovery if you are in a fragment rule.
-     */
-    recover(re: RecognitionException): void;
-    recover(re: LexerNoViableAltException): void;
-}

package/typings/antlr4ts/LexerInterpreter.d.ts

@@ -1,23 +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 { CharStream } from "./CharStream";
-import { Lexer } from "./Lexer";
-import { Vocabulary } from "./Vocabulary";
-export declare class LexerInterpreter extends Lexer {
-    protected _grammarFileName: string;
-    protected _atn: ATN;
-    protected _ruleNames: string[];
-    protected _channelNames: string[];
-    protected _modeNames: string[];
-    private _vocabulary;
-    constructor(grammarFileName: string, vocabulary: Vocabulary, ruleNames: string[], channelNames: string[], modeNames: string[], atn: ATN, input: CharStream);
-    get atn(): ATN;
-    get grammarFileName(): string;
-    get ruleNames(): string[];
-    get channelNames(): string[];
-    get modeNames(): string[];
-    get vocabulary(): Vocabulary;
-}

package/typings/antlr4ts/LexerNoViableAltException.d.ts

@@ -1,19 +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 { ATNConfigSet } from "./atn/ATNConfigSet";
-import { RecognitionException } from "./RecognitionException";
-import { Lexer } from "./Lexer";
-import { CharStream } from "./CharStream";
-export declare class LexerNoViableAltException extends RecognitionException {
-    /** Matching attempted at what input index? */
-    private _startIndex;
-    /** Which configurations did we try at input.index that couldn't match input.LA(1)? */
-    private _deadEndConfigs?;
-    constructor(lexer: Lexer | undefined, input: CharStream, startIndex: number, deadEndConfigs: ATNConfigSet | undefined);
-    get startIndex(): number;
-    get deadEndConfigs(): ATNConfigSet | undefined;
-    get inputStream(): CharStream;
-    toString(): string;
-}

package/typings/antlr4ts/ListTokenSource.d.ts

@@ -1,86 +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 { CharStream } from "./CharStream";
-import { Token } from "./Token";
-import { TokenFactory } from "./TokenFactory";
-import { TokenSource } from "./TokenSource";
-/**
- * Provides an implementation of {@link TokenSource} as a wrapper around a list
- * of {@link Token} objects.
- *
- * If the final token in the list is an {@link Token#EOF} token, it will be used
- * as the EOF token for every call to {@link #nextToken} after the end of the
- * list is reached. Otherwise, an EOF token will be created.
- */
-export declare class ListTokenSource implements TokenSource {
-    /**
-     * The wrapped collection of {@link Token} objects to return.
-     */
-    protected tokens: Token[];
-    /**
-     * The name of the input source. If this value is `undefined`, a call to
-     * {@link #getSourceName} should return the source name used to create the
-     * the next token in {@link #tokens} (or the previous token if the end of
-     * the input has been reached).
-     */
-    private _sourceName?;
-    /**
-     * The index into {@link #tokens} of token to return by the next call to
-     * {@link #nextToken}. The end of the input is indicated by this value
-     * being greater than or equal to the number of items in {@link #tokens}.
-     */
-    protected i: number;
-    /**
-     * This field caches the EOF token for the token source.
-     */
-    protected eofToken?: Token;
-    /**
-     * This is the backing field for {@link #getTokenFactory} and
-     * {@link setTokenFactory}.
-     */
-    private _factory;
-    /**
-     * Constructs a new {@link ListTokenSource} instance from the specified
-     * collection of {@link Token} objects and source name.
-     *
-     * @param tokens The collection of {@link Token} objects to provide as a
-     * {@link TokenSource}.
-     * @param sourceName The name of the {@link TokenSource}. If this value is
-     * `undefined`, {@link #getSourceName} will attempt to infer the name from
-     * the next {@link Token} (or the previous token if the end of the input has
-     * been reached).
-     *
-     * @exception NullPointerException if `tokens` is `undefined`
-     */
-    constructor(tokens: Token[], sourceName?: string);
-    /**
-     * {@inheritDoc}
-     */
-    get charPositionInLine(): number;
-    /**
-     * {@inheritDoc}
-     */
-    nextToken(): Token;
-    /**
-     * {@inheritDoc}
-     */
-    get line(): number;
-    /**
-     * {@inheritDoc}
-     */
-    get inputStream(): CharStream | undefined;
-    /**
-     * {@inheritDoc}
-     */
-    get sourceName(): string;
-    /**
-     * {@inheritDoc}
-     */
-    set tokenFactory(factory: TokenFactory);
-    /**
-     * {@inheritDoc}
-     */
-    get tokenFactory(): TokenFactory;
-}

package/typings/antlr4ts/NoViableAltException.d.ts

@@ -1,30 +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 { ATNConfigSet } from "./atn/ATNConfigSet";
-import { Parser } from "./Parser";
-import { ParserRuleContext } from "./ParserRuleContext";
-import { RecognitionException } from "./RecognitionException";
-import { Recognizer } from "./Recognizer";
-import { Token } from "./Token";
-import { TokenStream } from "./TokenStream";
-/** Indicates that the parser could not decide which of two or more paths
- *  to take based upon the remaining input. It tracks the starting token
- *  of the offending input and also knows where the parser was
- *  in the various paths when the error. Reported by reportNoViableAlternative()
- */
-export declare class NoViableAltException extends RecognitionException {
-    /** Which configurations did we try at input.index that couldn't match input.LT(1)? */
-    private _deadEndConfigs?;
-    /** The token object at the start index; the input stream might
-     * 	not be buffering tokens so get a reference to it. (At the
-     *  time the error occurred, of course the stream needs to keep a
-     *  buffer all of the tokens but later we might not have access to those.)
-     */
-    private _startToken;
-    constructor(/*@NotNull*/ recognizer: Parser);
-    constructor(recognizer: Recognizer<Token, any>, input: TokenStream, startToken: Token, offendingToken: Token, deadEndConfigs: ATNConfigSet | undefined, ctx: ParserRuleContext);
-    get startToken(): Token;
-    get deadEndConfigs(): ATNConfigSet | undefined;
-}