@opra/client 0.11.1 → 0.11.2

package/typings/antlr4ts/atn/LL1Analyzer.d.ts

@@ -1,98 +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 { Array2DHashSet } from "../misc/Array2DHashSet";
-import { ATN } from "./ATN";
-import { ATNConfig } from "./ATNConfig";
-import { ATNState } from "./ATNState";
-import { BitSet } from "../misc/BitSet";
-import { IntervalSet } from "../misc/IntervalSet";
-import { PredictionContext } from "./PredictionContext";
-export declare class LL1Analyzer {
-    /** Special value added to the lookahead sets to indicate that we hit
-     *  a predicate during analysis if `seeThruPreds==false`.
-     */
-    static readonly HIT_PRED: number;
-    atn: ATN;
-    constructor(atn: ATN);
-    /**
-     * Calculates the SLL(1) expected lookahead set for each outgoing transition
-     * of an {@link ATNState}. The returned array has one element for each
-     * outgoing transition in `s`. If the closure from transition
-     * *i* leads to a semantic predicate before matching a symbol, the
-     * element at index *i* of the result will be `undefined`.
-     *
-     * @param s the ATN state
-     * @returns the expected symbols for each outgoing transition of `s`.
-     */
-    getDecisionLookahead(s: ATNState | undefined): Array<IntervalSet | undefined> | undefined;
-    /**
-     * Compute set of tokens that can follow `s` in the ATN in the
-     * specified `ctx`.
-     *
-     * If `ctx` is `undefined` and the end of the rule containing
-     * `s` is reached, {@link Token#EPSILON} is added to the result set.
-     * If `ctx` is not `undefined` and the end of the outermost rule is
-     * reached, {@link Token#EOF} is added to the result set.
-     *
-     * @param s the ATN state
-     * @param ctx the complete parser context, or `undefined` if the context
-     * should be ignored
-     *
-     * @returns The set of tokens that can follow `s` in the ATN in the
-     * specified `ctx`.
-     */
-    LOOK(/*@NotNull*/ s: ATNState, /*@NotNull*/ ctx: PredictionContext): IntervalSet;
-    /**
-     * Compute set of tokens that can follow `s` in the ATN in the
-     * specified `ctx`.
-     *
-     * If `ctx` is `undefined` and the end of the rule containing
-     * `s` is reached, {@link Token#EPSILON} is added to the result set.
-     * If `ctx` is not `PredictionContext#EMPTY_LOCAL` and the end of the outermost rule is
-     * reached, {@link Token#EOF} is added to the result set.
-     *
-     * @param s the ATN state
-     * @param stopState the ATN state to stop at. This can be a
-     * {@link BlockEndState} to detect epsilon paths through a closure.
-     * @param ctx the complete parser context, or `undefined` if the context
-     * should be ignored
-     *
-     * @returns The set of tokens that can follow `s` in the ATN in the
-     * specified `ctx`.
-     */
-    LOOK(/*@NotNull*/ s: ATNState, /*@NotNull*/ ctx: PredictionContext, stopState: ATNState | null): IntervalSet;
-    /**
-     * Compute set of tokens that can follow `s` in the ATN in the
-     * specified `ctx`.
-     * <p/>
-     * If `ctx` is {@link PredictionContext#EMPTY_LOCAL} and
-     * `stopState` or the end of the rule containing `s` is reached,
-     * {@link Token#EPSILON} is added to the result set. If `ctx` is not
-     * {@link PredictionContext#EMPTY_LOCAL} and `addEOF` is `true`
-     * and `stopState` or the end of the outermost rule is reached,
-     * {@link Token#EOF} is added to the result set.
-     *
-     * @param s the ATN state.
-     * @param stopState the ATN state to stop at. This can be a
-     * {@link BlockEndState} to detect epsilon paths through a closure.
-     * @param ctx The outer context, or {@link PredictionContext#EMPTY_LOCAL} if
-     * the outer context should not be used.
-     * @param look The result lookahead set.
-     * @param lookBusy A set used for preventing epsilon closures in the ATN
-     * from causing a stack overflow. Outside code should pass
-     * `new HashSet<ATNConfig>` for this argument.
-     * @param calledRuleStack A set used for preventing left recursion in the
-     * ATN from causing a stack overflow. Outside code should pass
-     * `new BitSet()` for this argument.
-     * @param seeThruPreds `true` to true semantic predicates as
-     * implicitly `true` and "see through them", otherwise `false`
-     * to treat semantic predicates as opaque and add {@link #HIT_PRED} to the
-     * result if one is encountered.
-     * @param addEOF Add {@link Token#EOF} to the result if the end of the
-     * outermost context is reached. This parameter has no effect if `ctx`
-     * is {@link PredictionContext#EMPTY_LOCAL}.
-     */
-    protected _LOOK(s: ATNState, stopState: ATNState | undefined, ctx: PredictionContext, look: IntervalSet, lookBusy: Array2DHashSet<ATNConfig>, calledRuleStack: BitSet, seeThruPreds: boolean, addEOF: boolean): void;
-}

package/typings/antlr4ts/atn/LexerATNSimulator.d.ts

@@ -1,153 +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";
-import { ATNConfig } from "./ATNConfig";
-import { ATNConfigSet } from "./ATNConfigSet";
-import { ATNSimulator } from "./ATNSimulator";
-import { ATNState } from "./ATNState";
-import { CharStream } from "../CharStream";
-import { DFA } from "../dfa/DFA";
-import { DFAState } from "../dfa/DFAState";
-import { Lexer } from "../Lexer";
-import { LexerActionExecutor } from "./LexerActionExecutor";
-import { Transition } from "./Transition";
-/** "dup" of ParserInterpreter */
-export declare class LexerATNSimulator extends ATNSimulator {
-    optimize_tail_calls: boolean;
-    protected recog: Lexer | undefined;
-    /** The current token's starting index into the character stream.
-     *  Shared across DFA to ATN simulation in case the ATN fails and the
-     *  DFA did not have a previous accept state. In this case, we use the
-     *  ATN-generated exception object.
-     */
-    protected startIndex: number;
-    /** line number 1..n within the input */
-    private _line;
-    /** The index of the character relative to the beginning of the line 0..n-1 */
-    private _charPositionInLine;
-    protected mode: number;
-    /** Used during DFA/ATN exec to record the most recent accept configuration info */
-    protected prevAccept: LexerATNSimulator.SimState;
-    constructor(/*@NotNull*/ atn: ATN);
-    constructor(/*@NotNull*/ atn: ATN, recog: Lexer | undefined);
-    copyState(simulator: LexerATNSimulator): void;
-    match(input: CharStream, mode: number): number;
-    reset(): void;
-    protected matchATN(input: CharStream): number;
-    protected execATN(input: CharStream, ds0: DFAState): number;
-    /**
-     * Get an existing target state for an edge in the DFA. If the target state
-     * for the edge has not yet been computed or is otherwise not available,
-     * this method returns `undefined`.
-     *
-     * @param s The current DFA state
-     * @param t The next input symbol
-     * @returns The existing target DFA state for the given input symbol
-     * `t`, or `undefined` if the target state for this edge is not
-     * already cached
-     */
-    protected getExistingTargetState(s: DFAState, t: number): DFAState | undefined;
-    /**
-     * Compute a target state for an edge in the DFA, and attempt to add the
-     * computed state and corresponding edge to the DFA.
-     *
-     * @param input The input stream
-     * @param s The current DFA state
-     * @param t The next input symbol
-     *
-     * @returns The computed target DFA state for the given input symbol
-     * `t`. If `t` does not lead to a valid DFA state, this method
-     * returns {@link #ERROR}.
-     */
-    protected computeTargetState(input: CharStream, s: DFAState, t: number): DFAState;
-    protected failOrAccept(prevAccept: LexerATNSimulator.SimState, input: CharStream, reach: ATNConfigSet, t: number): number;
-    /** Given a starting configuration set, figure out all ATN configurations
-     *  we can reach upon input `t`. Parameter `reach` is a return
-     *  parameter.
-     */
-    protected getReachableConfigSet(input: CharStream, closure: ATNConfigSet, reach: ATNConfigSet, t: number): void;
-    protected accept(input: CharStream, lexerActionExecutor: LexerActionExecutor | undefined, startIndex: number, index: number, line: number, charPos: number): void;
-    protected getReachableTarget(trans: Transition, t: number): ATNState | undefined;
-    protected computeStartState(input: CharStream, p: ATNState): ATNConfigSet;
-    /**
-     * Since the alternatives within any lexer decision are ordered by
-     * preference, this method stops pursuing the closure as soon as an accept
-     * state is reached. After the first accept state is reached by depth-first
-     * search from `config`, all other (potentially reachable) states for
-     * this rule would have a lower priority.
-     *
-     * @returns `true` if an accept state is reached, otherwise
-     * `false`.
-     */
-    protected closure(input: CharStream, config: ATNConfig, configs: ATNConfigSet, currentAltReachedAcceptState: boolean, speculative: boolean, treatEofAsEpsilon: boolean): boolean;
-    protected getEpsilonTarget(input: CharStream, config: ATNConfig, t: Transition, configs: ATNConfigSet, speculative: boolean, treatEofAsEpsilon: boolean): ATNConfig | undefined;
-    /**
-     * Evaluate a predicate specified in the lexer.
-     *
-     * If `speculative` is `true`, this method was called before
-     * {@link #consume} for the matched character. This method should call
-     * {@link #consume} before evaluating the predicate to ensure position
-     * sensitive values, including {@link Lexer#getText}, {@link Lexer#getLine},
-     * and {@link Lexer#getCharPositionInLine}, properly reflect the current
-     * lexer state. This method should restore `input` and the simulator
-     * to the original state before returning (i.e. undo the actions made by the
-     * call to {@link #consume}.
-     *
-     * @param input The input stream.
-     * @param ruleIndex The rule containing the predicate.
-     * @param predIndex The index of the predicate within the rule.
-     * @param speculative `true` if the current index in `input` is
-     * one character before the predicate's location.
-     *
-     * @returns `true` if the specified predicate evaluates to
-     * `true`.
-     */
-    protected evaluatePredicate(input: CharStream, ruleIndex: number, predIndex: number, speculative: boolean): boolean;
-    protected captureSimState(settings: LexerATNSimulator.SimState, input: CharStream, dfaState: DFAState): void;
-    protected addDFAEdge(/*@NotNull*/ p: DFAState, t: number, /*@NotNull*/ q: ATNConfigSet): DFAState;
-    protected addDFAEdge(/*@NotNull*/ p: DFAState, t: number, /*@NotNull*/ q: DFAState): void;
-    /** Add a new DFA state if there isn't one with this set of
-     * 	configurations already. This method also detects the first
-     * 	configuration containing an ATN rule stop state. Later, when
-     * 	traversing the DFA, we will know which rule to accept.
-     */
-    protected addDFAState(configs: ATNConfigSet): DFAState;
-    getDFA(mode: number): DFA;
-    /** Get the text matched so far for the current token.
-     */
-    getText(input: CharStream): string;
-    get line(): number;
-    set line(line: number);
-    get charPositionInLine(): number;
-    set charPositionInLine(charPositionInLine: number);
-    consume(input: CharStream): void;
-    getTokenName(t: number): string;
-}
-export declare namespace LexerATNSimulator {
-    const debug: boolean;
-    const dfa_debug: boolean;
-    /** When we hit an accept state in either the DFA or the ATN, we
-     *  have to notify the character stream to start buffering characters
-     *  via {@link IntStream#mark} and record the current state. The current sim state
-     *  includes the current index into the input, the current line,
-     *  and current character position in that line. Note that the Lexer is
-     *  tracking the starting line and characterization of the token. These
-     *  variables track the "state" of the simulator when it hits an accept state.
-     *
-     *  We track these variables separately for the DFA and ATN simulation
-     *  because the DFA simulation often has to fail over to the ATN
-     *  simulation. If the ATN simulation fails, we need the DFA to fall
-     *  back to its previously accepted state, if any. If the ATN succeeds,
-     *  then the ATN does the accept and the DFA simulator that invoked it
-     *  can simply return the predicted token type.
-     */
-    class SimState {
-        index: number;
-        line: number;
-        charPos: number;
-        dfaState?: DFAState;
-        reset(): void;
-    }
-}

package/typings/antlr4ts/atn/LexerAction.d.ts

@@ -1,47 +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 { Equatable } from "../misc/Stubs";
-import { Lexer } from "../Lexer";
-import { LexerActionType } from "./LexerActionType";
-/**
- * Represents a single action which can be executed following the successful
- * match of a lexer rule. Lexer actions are used for both embedded action syntax
- * and ANTLR 4's new lexer command syntax.
- *
- * @author Sam Harwell
- * @since 4.2
- */
-export interface LexerAction extends Equatable {
-    /**
-     * Gets the serialization type of the lexer action.
-     *
-     * @returns The serialization type of the lexer action.
-     */
-    readonly actionType: LexerActionType;
-    /**
-     * Gets whether the lexer action is position-dependent. Position-dependent
-     * actions may have different semantics depending on the {@link CharStream}
-     * index at the time the action is executed.
-     *
-     * Many lexer commands, including `type`, `skip`, and
-     * `more`, do not check the input index during their execution.
-     * Actions like this are position-independent, and may be stored more
-     * efficiently as part of the `ATNConfig.lexerActionExecutor`.
-     *
-     * @returns `true` if the lexer action semantics can be affected by the
-     * position of the input {@link CharStream} at the time it is executed;
-     * otherwise, `false`.
-     */
-    readonly isPositionDependent: boolean;
-    /**
-     * Execute the lexer action in the context of the specified {@link Lexer}.
-     *
-     * For position-dependent actions, the input stream must already be
-     * positioned correctly prior to calling this method.
-     *
-     * @param lexer The lexer instance.
-     */
-    execute(/*@NotNull*/ lexer: Lexer): void;
-}

package/typings/antlr4ts/atn/LexerActionExecutor.d.ts

@@ -1,104 +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 { Lexer } from "../Lexer";
-import { LexerAction } from "./LexerAction";
-/**
- * Represents an executor for a sequence of lexer actions which traversed during
- * the matching operation of a lexer rule (token).
- *
- * The executor tracks position information for position-dependent lexer actions
- * efficiently, ensuring that actions appearing only at the end of the rule do
- * not cause bloating of the {@link DFA} created for the lexer.
- *
- * @author Sam Harwell
- * @since 4.2
- */
-export declare class LexerActionExecutor {
-    private _lexerActions;
-    /**
-     * Caches the result of {@link #hashCode} since the hash code is an element
-     * of the performance-critical {@link LexerATNConfig#hashCode} operation.
-     */
-    private cachedHashCode;
-    /**
-     * Constructs an executor for a sequence of {@link LexerAction} actions.
-     * @param lexerActions The lexer actions to execute.
-     */
-    constructor(lexerActions: LexerAction[]);
-    /**
-     * Creates a {@link LexerActionExecutor} which executes the actions for
-     * the input `lexerActionExecutor` followed by a specified
-     * `lexerAction`.
-     *
-     * @param lexerActionExecutor The executor for actions already traversed by
-     * the lexer while matching a token within a particular
-     * {@link ATNConfig}. If this is `undefined`, the method behaves as though
-     * it were an empty executor.
-     * @param lexerAction The lexer action to execute after the actions
-     * specified in `lexerActionExecutor`.
-     *
-     * @returns A {@link LexerActionExecutor} for executing the combine actions
-     * of `lexerActionExecutor` and `lexerAction`.
-     */
-    static append(lexerActionExecutor: LexerActionExecutor | undefined, lexerAction: LexerAction): LexerActionExecutor;
-    /**
-     * Creates a {@link LexerActionExecutor} which encodes the current offset
-     * for position-dependent lexer actions.
-     *
-     * Normally, when the executor encounters lexer actions where
-     * {@link LexerAction#isPositionDependent} returns `true`, it calls
-     * {@link IntStream#seek} on the input {@link CharStream} to set the input
-     * position to the *end* of the current token. This behavior provides
-     * for efficient DFA representation of lexer actions which appear at the end
-     * of a lexer rule, even when the lexer rule matches a variable number of
-     * characters.
-     *
-     * Prior to traversing a match transition in the ATN, the current offset
-     * from the token start index is assigned to all position-dependent lexer
-     * actions which have not already been assigned a fixed offset. By storing
-     * the offsets relative to the token start index, the DFA representation of
-     * lexer actions which appear in the middle of tokens remains efficient due
-     * to sharing among tokens of the same length, regardless of their absolute
-     * position in the input stream.
-     *
-     * If the current executor already has offsets assigned to all
-     * position-dependent lexer actions, the method returns `this`.
-     *
-     * @param offset The current offset to assign to all position-dependent
-     * lexer actions which do not already have offsets assigned.
-     *
-     * @returns A {@link LexerActionExecutor} which stores input stream offsets
-     * for all position-dependent lexer actions.
-     */
-    fixOffsetBeforeMatch(offset: number): LexerActionExecutor;
-    /**
-     * Gets the lexer actions to be executed by this executor.
-     * @returns The lexer actions to be executed by this executor.
-     */
-    get lexerActions(): LexerAction[];
-    /**
-     * Execute the actions encapsulated by this executor within the context of a
-     * particular {@link Lexer}.
-     *
-     * This method calls {@link IntStream#seek} to set the position of the
-     * `input` {@link CharStream} prior to calling
-     * {@link LexerAction#execute} on a position-dependent action. Before the
-     * method returns, the input position will be restored to the same position
-     * it was in when the method was invoked.
-     *
-     * @param lexer The lexer instance.
-     * @param input The input stream which is the source for the current token.
-     * When this method is called, the current {@link IntStream#index} for
-     * `input` should be the start of the following token, i.e. 1
-     * character past the end of the current token.
-     * @param startIndex The token start index. This value may be passed to
-     * {@link IntStream#seek} to set the `input` position to the beginning
-     * of the token.
-     */
-    execute(lexer: Lexer, input: CharStream, startIndex: number): void;
-    hashCode(): number;
-    equals(obj: any): boolean;
-}

package/typings/antlr4ts/atn/LexerActionType.d.ts

@@ -1,44 +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.
- */
-/**
- * Represents the serialization type of a {@link LexerAction}.
- *
- * @author Sam Harwell
- * @since 4.2
- */
-export declare const enum LexerActionType {
-    /**
-     * The type of a {@link LexerChannelAction} action.
-     */
-    CHANNEL = 0,
-    /**
-     * The type of a {@link LexerCustomAction} action.
-     */
-    CUSTOM = 1,
-    /**
-     * The type of a {@link LexerModeAction} action.
-     */
-    MODE = 2,
-    /**
-     * The type of a {@link LexerMoreAction} action.
-     */
-    MORE = 3,
-    /**
-     * The type of a {@link LexerPopModeAction} action.
-     */
-    POP_MODE = 4,
-    /**
-     * The type of a {@link LexerPushModeAction} action.
-     */
-    PUSH_MODE = 5,
-    /**
-     * The type of a {@link LexerSkipAction} action.
-     */
-    SKIP = 6,
-    /**
-     * The type of a {@link LexerTypeAction} action.
-     */
-    TYPE = 7
-}

package/typings/antlr4ts/atn/LexerChannelAction.d.ts

@@ -1,48 +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 { Lexer } from "../Lexer";
-import { LexerAction } from "./LexerAction";
-import { LexerActionType } from "./LexerActionType";
-/**
- * Implements the `channel` lexer action by calling
- * {@link Lexer#setChannel} with the assigned channel.
- *
- * @author Sam Harwell
- * @since 4.2
- */
-export declare class LexerChannelAction implements LexerAction {
-    private readonly _channel;
-    /**
-     * Constructs a new `channel` action with the specified channel value.
-     * @param channel The channel value to pass to {@link Lexer#setChannel}.
-     */
-    constructor(channel: number);
-    /**
-     * Gets the channel to use for the {@link Token} created by the lexer.
-     *
-     * @returns The channel to use for the {@link Token} created by the lexer.
-     */
-    get channel(): number;
-    /**
-     * {@inheritDoc}
-     * @returns This method returns {@link LexerActionType#CHANNEL}.
-     */
-    get actionType(): LexerActionType;
-    /**
-     * {@inheritDoc}
-     * @returns This method returns `false`.
-     */
-    get isPositionDependent(): boolean;
-    /**
-     * {@inheritDoc}
-     *
-     * This action is implemented by calling {@link Lexer#setChannel} with the
-     * value provided by {@link #getChannel}.
-     */
-    execute(lexer: Lexer): void;
-    hashCode(): number;
-    equals(obj: any): boolean;
-    toString(): string;
-}

package/typings/antlr4ts/atn/LexerCustomAction.d.ts

@@ -1,73 +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 { Lexer } from "../Lexer";
-import { LexerAction } from "./LexerAction";
-import { LexerActionType } from "./LexerActionType";
-/**
- * Executes a custom lexer action by calling {@link Recognizer#action} with the
- * rule and action indexes assigned to the custom action. The implementation of
- * a custom action is added to the generated code for the lexer in an override
- * of {@link Recognizer#action} when the grammar is compiled.
- *
- * This class may represent embedded actions created with the `{...}`
- * syntax in ANTLR 4, as well as actions created for lexer commands where the
- * command argument could not be evaluated when the grammar was compiled.
- *
- * @author Sam Harwell
- * @since 4.2
- */
-export declare class LexerCustomAction implements LexerAction {
-    private readonly _ruleIndex;
-    private readonly _actionIndex;
-    /**
-     * Constructs a custom lexer action with the specified rule and action
-     * indexes.
-     *
-     * @param ruleIndex The rule index to use for calls to
-     * {@link Recognizer#action}.
-     * @param actionIndex The action index to use for calls to
-     * {@link Recognizer#action}.
-     */
-    constructor(ruleIndex: number, actionIndex: number);
-    /**
-     * Gets the rule index to use for calls to {@link Recognizer#action}.
-     *
-     * @returns The rule index for the custom action.
-     */
-    get ruleIndex(): number;
-    /**
-     * Gets the action index to use for calls to {@link Recognizer#action}.
-     *
-     * @returns The action index for the custom action.
-     */
-    get actionIndex(): number;
-    /**
-     * {@inheritDoc}
-     *
-     * @returns This method returns {@link LexerActionType#CUSTOM}.
-     */
-    get actionType(): LexerActionType;
-    /**
-     * Gets whether the lexer action is position-dependent. Position-dependent
-     * actions may have different semantics depending on the {@link CharStream}
-     * index at the time the action is executed.
-     *
-     * Custom actions are position-dependent since they may represent a
-     * user-defined embedded action which makes calls to methods like
-     * {@link Lexer#getText}.
-     *
-     * @returns This method returns `true`.
-     */
-    get isPositionDependent(): boolean;
-    /**
-     * {@inheritDoc}
-     *
-     * Custom actions are implemented by calling {@link Lexer#action} with the
-     * appropriate rule and action indexes.
-     */
-    execute(lexer: Lexer): void;
-    hashCode(): number;
-    equals(obj: any): boolean;
-}

package/typings/antlr4ts/atn/LexerIndexedCustomAction.d.ts

@@ -1,74 +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 { Lexer } from "../Lexer";
-import { LexerAction } from "./LexerAction";
-import { LexerActionType } from "./LexerActionType";
-/**
- * This implementation of {@link LexerAction} is used for tracking input offsets
- * for position-dependent actions within a {@link LexerActionExecutor}.
- *
- * This action is not serialized as part of the ATN, and is only required for
- * position-dependent lexer actions which appear at a location other than the
- * end of a rule. For more information about DFA optimizations employed for
- * lexer actions, see {@link LexerActionExecutor#append} and
- * {@link LexerActionExecutor#fixOffsetBeforeMatch}.
- *
- * @author Sam Harwell
- * @since 4.2
- */
-export declare class LexerIndexedCustomAction implements LexerAction {
-    private readonly _offset;
-    private readonly _action;
-    /**
-     * Constructs a new indexed custom action by associating a character offset
-     * with a {@link LexerAction}.
-     *
-     * Note: This class is only required for lexer actions for which
-     * {@link LexerAction#isPositionDependent} returns `true`.
-     *
-     * @param offset The offset into the input {@link CharStream}, relative to
-     * the token start index, at which the specified lexer action should be
-     * executed.
-     * @param action The lexer action to execute at a particular offset in the
-     * input {@link CharStream}.
-     */
-    constructor(offset: number, action: LexerAction);
-    /**
-     * Gets the location in the input {@link CharStream} at which the lexer
-     * action should be executed. The value is interpreted as an offset relative
-     * to the token start index.
-     *
-     * @returns The location in the input {@link CharStream} at which the lexer
-     * action should be executed.
-     */
-    get offset(): number;
-    /**
-     * Gets the lexer action to execute.
-     *
-     * @returns A {@link LexerAction} object which executes the lexer action.
-     */
-    get action(): LexerAction;
-    /**
-     * {@inheritDoc}
-     *
-     * @returns This method returns the result of calling {@link #getActionType}
-     * on the {@link LexerAction} returned by {@link #getAction}.
-     */
-    get actionType(): LexerActionType;
-    /**
-     * {@inheritDoc}
-     * @returns This method returns `true`.
-     */
-    get isPositionDependent(): boolean;
-    /**
-     * {@inheritDoc}
-     *
-     * This method calls {@link #execute} on the result of {@link #getAction}
-     * using the provided `lexer`.
-     */
-    execute(lexer: Lexer): void;
-    hashCode(): number;
-    equals(obj: any): boolean;
-}