import { Pattern } from 'regexp-composer';
export declare function buildGrammar<T extends {
    [key: string]: any;
}>(obj: T | (new () => T), startProductionName: keyof T): Grammar<T>;
export declare function detectAndErrorOnLeftRecursion(rootNode: GrammarElement): void;
export declare function oneOrMore(content: Production): Repetition;
export declare function zeroOrMore(content: Production): Repetition;
export declare function anyOf(...members: Production[]): Choice;
export declare function bestOf(...members: Production[]): Choice;
export declare function possibly<T extends Production>(content: Production): T;
export declare function cached<T extends Production>(content: Production): T;
export declare function uncached<T extends Production>(content: Production): T;
export declare function pattern(pattern: Pattern): PatternTerminal;
export interface Grammar<T> {
    rootElement: Nonterminal;
    productions: {
        [key in keyof T]: any;
    };
    maxElementId: number;
}
export type Production = string | GrammarElement | (() => Production) | Production[];
export type GrammarElement = StringTerminal | PatternTerminal | Nonterminal | Sequence | Repetition | Choice | NonterminalReference;
interface GrammarElementBase {
    type: string;
    optional: boolean;
    uniqueId?: number;
    cached?: boolean;
}
export type Terminal = StringTerminal | PatternTerminal;
export interface StringTerminal extends GrammarElementBase {
    type: 'StringTerminal';
    content: string;
}
export interface PatternTerminal extends GrammarElementBase {
    type: 'PatternTerminal';
    name: string;
    pattern: Pattern | Pattern[];
    regExp: RegExp;
}
export interface Nonterminal extends GrammarElementBase {
    type: 'Nonterminal';
    name: string;
    content: GrammarElement;
}
export interface Sequence extends GrammarElementBase {
    type: 'Sequence';
    members: GrammarElement[];
}
export interface Repetition extends GrammarElementBase {
    type: 'Repetition';
    content: GrammarElement;
}
export interface Choice extends GrammarElementBase {
    type: 'Choice';
    members: GrammarElement[];
    exhaustive: boolean;
}
export interface NonterminalReference extends GrammarElementBase {
    type: 'NonterminalReference';
    reference: Function;
}
export {};