import { Token } from "./Token.js";
import { Recognizer } from "./Recognizer.js";
import { RecognitionException } from "./RecognitionException.js";
import { LexerNoViableAltException } from "./LexerNoViableAltException.js";
import { LexerATNSimulator } from "./atn/LexerATNSimulator.js";
import { CharStream } from "./CharStream.js";
import { TokenFactory } from "./TokenFactory.js";
import { TokenSource } from "./TokenSource.js";
/**
 * Options used during lexer execution.
 */
export interface LexerOptions {
    /**
     * A DFA edge is a DFA state set in the edge cache of another DFA state to quickly look up the next state
     * for a given input symbol (usually a Unicode codepoint). This speeds up the performance of the lexer at the cost
     * of memory. The edge cache is a sparse array, so the actual memory usage is proportional to the number of
     * unique input symbols.
     *
     * For input symbols outside of the specified range, the lexer will always use the full computation to determine
     * the next state. The same is true for lexer rules with predicates, since the next state is not known until the
     * predicate is evaluated.
     *
     * The min DFA edge is 0 by default.
     */
    minDFAEdge: number;
    /**
     * This is the upper bound of the edge cache. Only input symbols smaller than this value are cached.
     * The default value is 256, which encompasses the entire ASCII range, but leaves most of the other Unicode
     * codepoints uncached. If you need to parse other languages instead of Latin, you can set the min and max
     * edge values to Unicode block ranges that cover that particular language.
     */
    maxDFAEdge: number;
    /** The minimum input symbol value that is allowed. The default value is 0. */
    minCodePoint: number;
    /**
     * The maximum input value that is allowed. The default value is 0x10FFFF (the full Unicode range).
     * Values outside of this range will be treated as invalid input and will cause the lexer to throw an error.
     */
    maxCodePoint: number;
}
/**
 * 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<LexerATNSimulator> implements TokenSource {
    #private;
    static readonly DEFAULT_MODE = 0;
    static readonly MORE = -2;
    static readonly SKIP = -3;
    static readonly DEFAULT_TOKEN_CHANNEL: number;
    static readonly HIDDEN: number;
    readonly options: LexerOptions;
    /**
     * 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 channel number for the current token */
    channel: number;
    /** The token type for the current token */
    type: number;
    mode: number;
    /** The start column of the current token (the one that was last read by `nextToken`). */
    protected currentTokenColumn: number;
    /**
     * The line on which the first character of the current token (the one that was last read by `nextToken`) resides.
     */
    protected currentTokenStartLine: number;
    private input;
    /**
     * 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-null so that the auto token emit mechanism will not
     *  emit another token.
     */
    private token;
    /**
     * Once we see EOF on char stream, next token will be EOF.
     * If you have DONE : EOF ; then you see DONE EOF.
     */
    private hitEOF;
    private factory;
    constructor(input: CharStream, options?: Partial<LexerOptions>);
    reset(seekBack?: boolean): void;
    /** @returns 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==null at end of any token rule, it creates one for you
     * and emits it.
     */
    skip(): void;
    more(): void;
    pushMode(m: number): void;
    popMode(): number;
    get modeStack(): number[];
    /**
     * 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).
     */
    emitToken(token: Token): void;
    /**
     * 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;
    emitEOF(): Token;
    /** What is the index of the current character of lookahead? */
    getCharIndex(): number;
    /**
     * 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): string;
    getErrorDisplayForChar(c: string): string;
    getCharErrorDisplay(c: string): 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: LexerNoViableAltException | RecognitionException): void;
    get inputStream(): CharStream;
    set inputStream(input: CharStream);
    set tokenFactory(factory: TokenFactory<Token>);
    get tokenFactory(): TokenFactory<Token>;
    get sourceName(): string;
    get line(): number;
    set line(line: number);
    get column(): number;
    set column(column: number);
    get text(): string;
    set text(text: string);
}