import GRule, { GElement } from "./grammar/GRule";
import IGRuleContext from "./grammar/IGRuleContext";
export default class GrammarCompiler {
    private static WS;
    static mergeTokens(existing?: Array<string>, v1?: any, v2?: any): Array<string>;
    /**
     * Recursive iteration across rules and elements to calculate next element tokens, ie tokens that cause the parser
     * to skip to a further rule.
     *
     * <p>
     * 	 Which, recall, differers from possible next tokens is that it's only valid as the first character of a match
     *
     *   ie (var1)?, X(var2)  // upon hitting (var1), if we encounter an X, skip to X(var2)
     *
     *
     * </p>
     *
     * @param isOR
     * @param parentTokens
     * @param asChild
     * @param parentAllowNone
     * @param suffixTokens - used only when we have a `(var) construct
     */
    static setUpNextTokens(r: GRule, isOR: boolean, stack: IGRuleContext, parentElementIndex?: number, parentTokens?: Array<string>, asChild?: boolean, parentAllowNone?: boolean, parentAllowMany?: boolean, suffixTokens?: Array<string>, parentIsOptional?: boolean, parentContextTokens?: Array<string>): boolean;
    static requiresNextTokens(e: GElement): boolean;
    static getElementTokens(e: GElement, getRule: Function): Array<string>;
    /**
     * Calculated the possible next token of a variable.
     *
     * <p> Used when an element's prefix has already been matched. Output is vector of tokens of characters that
     *  indicate the start of a new rule.</p>
     *
     *  examples:
     *
     *    X(var1).[Y | Z]   // <-- possible next tokens are [Y, Z, ' ' ];
     * 	  PAREN[(var1)]      // <-- possible next token with be [')', ' '], as suffix of parent needs to propagate down.
     * ,
     *
     * <p> Differs from nextElementToken in that
     *      a) Used when matching (or attempting to match) a variable within an element (ie after a prefix token, if present has
     *         been matched. Wheras nextElement token is used to detetermin which element to attempt to match by
     *         looking at possible prefix tokens
     *
     *      b) It therfore pays attention to whitespace, and it's own suffix  and prefix tokens, wheras nextElementTtoken
     *         only cares about tokes of possible next prefix (or content) token
     *
     * </p>
     *
     * @param parentTokens tokens from subsequent elements (as we iterate backwards)
     * 		ie   [(var1) | Y].  Z?. Q?.   <-- Z and Q will are parent tokens
     *
     * @param ixTokens parent prefix and suffix(ie *ix) tokens
     * 		  ie PAREN[X[(var1) | Y?]*]   <--- 'X' is repeated prefix token that needs to propagate down
     * 									  <--- ')' also needs to propagate
     *
     *
     */
    static setPossibleNextTokens(rule: GRule, parentTokens_pnt?: Array<string>, ixTokens?: Array<string>): Array<string>;
    static isPrefixRepeat(e: GElement): boolean;
    /**
     * forward iteration
     *
     * Note that this is non-context dependant, so could readily be cached, including on parents if cloned.
     *
     * @param stopOnWS whether required ws should halt iteration if it hits ws (ie (var)~ :rule).
     *        (True when calculaating possible next token as opposed to next element token).
     *
     *
     *
     * @return true if completed  (and false if we've hit a token that we ca
     */
    static getDeterminateTokensFromReferencedRule(rule: GRule, out: Array<string>, stopOnWS?: boolean, getRule?: Function): boolean;
    /**
     * Context independant forward iteration over tokens.
     */
    static calculateReferencedTokens_low(rule: GRule, out: Array<string>, stopOnWS?: boolean, getRule?: Function): boolean;
    static cloneTokens(v: Array<string>): Array<string>;
    /**
* recurse through rules and their elements inverting the order of the calculated tokens
*/
    static invertTokenOrders(rule: GRule): void;
    /**
     * swaps the order of
     */
    static reverseTokens(v: Array<string>): void;
}