import * as TSU from "@panyam/tsutils";
import { Grammar, Sym, Str, Rule } from "./grammar";
type NumMap<T> = TSU.NumMap<T>;
type StringMap<T> = TSU.StringMap<T>;
type Nullable<T> = TSU.Nullable<T>;
export declare class Trie<T> {
    protected keyFunc: (t: T) => string;
    readonly root: TrieNode<T>;
    constructor(keyFunc: (t: T) => string);
    add(values: T[], fromIndex?: number): TrieNode<T>;
    get debugValue(): any;
}
export declare class TrieNode<T> {
    isLeaf: boolean;
    value: Nullable<T>;
    parent: Nullable<TrieNode<T>>;
    children: Map<string, TrieNode<T>>;
    get debugValue(): any;
}
export declare class IDSet<T extends {
    id: number;
}> {
    protected _entries: T[];
    protected _entriesByKey: StringMap<T>;
    protected keyFunc: (t: T) => string;
    constructor(keyFunc?: (t: T) => string);
    clear(): void;
    remove(predicate: (t: T) => boolean): boolean;
    get entries(): ReadonlyArray<T>;
    get(id: number): T;
    getByKey(key: string): Nullable<T>;
    ensure(entry: T, throwIfExists?: boolean): T;
    has(entry: T): boolean;
    get size(): number;
}
export declare class SymbolSet {
    readonly grammar: Grammar;
    readonly enforceSymbolType: Nullable<boolean>;
    entries: Set<number>;
    hasNull: boolean;
    constructor(grammar: Grammar, enforceSymbolType?: Nullable<boolean>);
    get debugString(): string;
    labels(skipAux?: boolean): string[];
    addFrom(another: SymbolSet, includeNull?: boolean): number;
    addTo(another: SymbolSet, includeNull?: boolean): number;
    has(term: Sym): boolean;
    add(term: Sym): this;
    delete(term: Sym): boolean;
    get size(): number;
}
export declare class NullableSet {
    readonly grammar: Grammar;
    entries: Set<number>;
    private visited;
    constructor(grammar: Grammar);
    get nonterms(): Sym[];
    refresh(): void;
    protected visit(nt: Sym): void;
    isNullable(nt: Sym): boolean;
    isStrNullable(str: Str, fromIndex?: number, toIndex?: Nullable<number>): boolean;
    add(nt: Sym): void;
}
declare class SymSymbolSets {
    readonly grammar: Grammar;
    entries: NumMap<SymbolSet>;
    private _count;
    constructor(grammar: Grammar);
    refresh(): void;
    forEachTerm(nt: Sym, visitor: (x: Nullable<Sym>) => boolean | void): void;
    get debugValue(): any;
    get count(): number;
    entriesFor(sym: Sym): SymbolSet;
    addNull(nt: Sym): boolean;
    add(nt: Sym, source: Sym, includeNull?: boolean): boolean;
}
export declare class FirstSets extends SymSymbolSets {
    readonly nullables: NullableSet;
    constructor(grammar: Grammar, nullables?: NullableSet);
    forEachTermIn(str: Str, fromIndex: number | undefined, visitor: (term: Nullable<Sym>) => void): void;
    refresh(): void;
    processRule(rule: Rule): void;
}
export declare class FollowSets extends SymSymbolSets {
    readonly firstSets: FirstSets;
    constructor(grammar: Grammar, firstSets?: FirstSets);
    get nullables(): NullableSet;
    refresh(): void;
    processRule(rule: Rule): void;
}
export {};