import { Grammar as _Grammar, Parser as _Parser } from "./pkg/dotlr";
import { ActionTable, Automaton, FirstTable, FollowTable, GoToTable, GrammarError, LALR1ParserOfGrammar, LR1ParserOfGrammar, ParserError, ParsingError, ParsingTables, Rule, Spanned, Token, Trace, Tree } from "./types";
import { Err, Ok } from "ts-results-es";
export declare class Grammar<T extends string = string, NT extends string = string, R extends string = string> {
    grammar: _Grammar;
    private cache;
    private constructor();
    static parse<T extends string = string, NT extends string = string, R extends string = string>(grammar: string): Ok<Grammar<T, NT, R>> | Err<GrammarError>;
    getSymbols(): NT[];
    getConstantTokens(): T[];
    getStartSymbol(): NT;
    getProductions(): Rule<Token<T, R>>[];
    getRegexTokens(): Map<R, string>;
    stringify(): string;
    clone(): Grammar<T, NT, R>;
}
export declare class Parser<T extends string = string, NT extends string = string, R extends string = string> {
    private parser;
    private cache;
    constructor(parser: _Parser);
    parse(input: string): Ok<Tree<NT, Token<T, R>>> | Err<ParsingError>;
    getActionTable(): ActionTable<Token<T, R>>;
    getGotoTable(): GoToTable<NT>;
    getParseTables(): ParsingTables<NT, Token<T, R>>;
    getAutomaton(): Automaton<Token<T, R>>;
    getFirstTable(): FirstTable<Token<T, R>>;
    getFollowTable(): FollowTable<Token<T, R>>;
    tokenize(input: string): Err<ParsingError> | Ok<{
        token: Spanned<Token<T, R>>;
        slice: string;
    }[]>;
    trace(input: string): Err<ParsingError> | Ok<{
        trace: Trace<Tree<NT, Token<T, R>>>;
        tree: Tree<NT, Token<T, R>>;
    }>;
}
export declare class LR1Parser<T extends string = string, NT extends string = string, R extends string = string> extends Parser<T, NT, R> {
    private constructor();
    /**
     * Consumes a grammar and returns a parser, the grammar is consumed and the ownership is transferred to the parser
     */
    static fromGrammar<G extends Grammar>(grammar: G): Ok<LR1ParserOfGrammar<G>> | Err<ParserError<LR1ParserOfGrammar<G>>>;
}
export declare class LALR1Parser<T extends string = string, NT extends string = string, R extends string = string> extends Parser<T, NT, R> {
    private constructor();
    /**
     * Consumes a grammar and returns a parser, the grammar is consumed and the ownership is transferred to the parser
     */
    static fromGrammar<G extends Grammar>(grammar: G): Ok<LALR1ParserOfGrammar<G>> | Err<ParserError<LALR1ParserOfGrammar<G>>>;
}