import { AST } from './core';
import { Parser } from './parser-combinators';
export declare type SimpleASTAlt = {
    type: 'alt';
    exprs: Array<SimpleASTSeq>;
};
export declare type SimpleASTSeq = {
    type: 'seq';
    exprs: SimpleASTNode[];
};
declare type SeqFn = (...xs: unknown[]) => unknown;
export declare type SimpleASTNode = {
    type: 'literal';
    value: string;
} | {
    type: 'identifier';
} | {
    type: 'value';
} | {
    type: 'nonterminal';
    value: symbol;
} | {
    type: 'reduce';
    arity: number;
    fn: SeqFn | null;
};
export declare type SimpleAST = SimpleASTNode | SimpleASTSeq | SimpleASTAlt;
declare class ScopeManager {
    private stack;
    lookup(value: string): symbol;
    compileRuleset(rules: Array<{
        name: string;
        expr: AST;
    }>, addRule: (name: symbol, expr: AST) => void): SimpleASTNode;
}
declare class LiteralManager {
    private keywords;
    private operators;
    private keywordRule;
    private operatorRule;
    add(literal: string): SimpleASTNode;
    terminal(node: AST & {
        type: 'terminal';
    }): SimpleASTNode;
    compile(map: Map<symbol, SimpleASTAlt>): {
        keywords: Set<string>;
        operators: Set<string>;
    };
}
export declare class ASTSimplifier {
    rules: Map<symbol, SimpleASTAlt>;
    scope: ScopeManager;
    literals: LiteralManager;
    static simplifyAll(node: AST): {
        startRule: symbol;
        rules: Map<symbol, SimpleASTAlt>;
        keywords: Set<string>;
        operators: Set<string>;
    };
    private simplifyAll;
    private simplifyAlt;
    private simplifySeq;
    private simplifyNode;
}
declare class FirstSetBuilder {
    private rules;
    cache: Map<SimpleAST, Set<string & {
        __brand: "Terminal";
    }>>;
    constructor(rules: Map<symbol, SimpleAST>);
    get(node: SimpleAST, recurSet?: Set<symbol>): any;
    private getInner;
}
export declare class ParserCompiler {
    compiledRules: Map<symbol, Parser>;
    firstSet: FirstSetBuilder;
    constructor(ruleASTMap: Map<symbol, SimpleASTAlt>);
    static compileRuleset(ruleASTMap: Map<symbol, SimpleASTAlt>): Map<symbol, Parser>;
    compile(node: SimpleAST): Parser;
}
export declare function createParser<T>(ast: AST): (strs: readonly string[], ...xs: unknown[]) => T;
export {};