import type { AltSpec, Config, Context, FuncRef, FuncRefMap, Jsonic, Lex, ListMods, Rule, RuleSpec, RuleState, RuleStep, StateAction, Tin, Token } from './types';
declare class RuleImpl implements Rule {
    i: number;
    name: string;
    node: null;
    state: RuleState;
    n: any;
    d: number;
    u: any;
    k: any;
    bo: boolean;
    ao: boolean;
    bc: boolean;
    ac: boolean;
    os: number;
    cs: number;
    spec: RuleSpec;
    child: Rule;
    parent: Rule;
    prev: Rule;
    next: Rule;
    o0: Token;
    o1: Token;
    c0: Token;
    c1: Token;
    need: number;
    constructor(spec: RuleSpec, ctx: Context, node?: any);
    process(ctx: Context, lex: Lex): Rule;
    eq(counter: string, limit?: number): boolean;
    lt(counter: string, limit?: number): boolean;
    gt(counter: string, limit?: number): boolean;
    lte(counter: string, limit?: number): boolean;
    gte(counter: string, limit?: number): boolean;
    toString(): string;
}
declare const makeRule: (...params: ConstructorParameters<typeof RuleImpl>) => RuleImpl;
declare const makeNoRule: (j: Jsonic, ctx: Context) => RuleImpl;
declare class RuleSpecImpl implements RuleSpec {
    name: string;
    def: {
        open: AltSpec[];
        close: AltSpec[];
        bo: StateAction[];
        bc: StateAction[];
        ao: StateAction[];
        ac: StateAction[];
        tcol: Tin[][][];
        fnref: FuncRefMap<Function>;
    };
    cfg: Config;
    ji: Jsonic;
    constructor(j: Jsonic, cfg: Config, def: any);
    tin<R extends string | Tin, T extends R extends Tin ? string : Tin>(ref: R): T;
    fnref(frm: Record<FuncRef, Function>): RuleSpec;
    add(rs: RuleState, a: AltSpec | AltSpec[], mods?: ListMods): RuleSpec;
    open(a: AltSpec | AltSpec[], mods?: ListMods): RuleSpec;
    close(a: AltSpec | AltSpec[], mods?: ListMods): RuleSpec;
    action(append: boolean, step: RuleStep, state: RuleState, action: StateAction): RuleSpec;
    bo(append: StateAction | boolean | FuncRef, action?: StateAction): RuleSpec;
    ao(append: StateAction | boolean, action?: StateAction): RuleSpec;
    bc(append: StateAction | boolean, action?: StateAction): RuleSpec;
    ac(append: StateAction | boolean, action?: StateAction): RuleSpec;
    clear(): this;
    norm(): this;
    process(rule: Rule, ctx: Context, lex: Lex, state: RuleState): Rule;
    bad(tkn: Token, rule: Rule, ctx: Context, parse: {
        is_open: boolean;
    }): Rule;
    unknownRule(tkn: Token, name: string): Token;
}
declare const makeRuleSpec: (...params: ConstructorParameters<typeof RuleSpecImpl>) => RuleSpecImpl;
export { makeRule, makeNoRule, makeRuleSpec };