export declare const NoMatch: unique symbol;
export declare type TNoMatch = typeof NoMatch;
export declare class ParseResult<T> {
    res: T;
    pos: number;
    constructor(res: T, pos: number);
}
export declare function escape(str: string): string;
export declare function Res<T>(res: T, pos: number): ParseResult<T>;
export declare class Rule<T> {
    parse: (input: string, pos: number, skip: RegExp | undefined) => TNoMatch | ParseResult<T>;
    constructor(parse: (input: string, pos: number, skip: RegExp | undefined) => TNoMatch | ParseResult<T>);
    map<U>(fn: (res: T, input: string, pos: number, skip: RegExp | undefined, start: number) => U | TNoMatch | ParseResult<U>): Rule<U>;
    tap(fn: (res: T, input: string, pos: number, skip: RegExp | undefined, start: number) => any): Rule<T>;
}
/**
 *
 */
export declare type RawRule<T> = Rule<T> | RegExp | string;
/**
 *
 */
export declare type Result<T> = T extends Rule<infer U> ? U : T extends RegExp ? RegExpMatchArray : T extends string ? string : never;
export declare function Str(str: string): Rule<string>;
export declare function Reg(reg: RegExp): Rule<RegExpMatchArray>;
/**
 *
 */
export declare function _(exp: RegExp): Rule<RegExpMatchArray>;
export declare function _(exp: string): Rule<string>;
export declare function _<T>(exp: Rule<T>): Rule<T>;
export declare function _<T>(exp: string | RegExp | Rule<T>): Rule<string | RegExpMatchArray | T>;
/**
 *
 */
export declare function Seq<T extends {
    [name: string]: RawRule<any>;
}>(obj: T): Rule<{
    [K in keyof T]: Result<T[K]>;
}>;
export declare function SeqArray<T extends RawRule<any>[]>(..._rules: T): Rule<{
    [K in keyof T]: Result<T[K]>;
}>;
/**
 *
 */
export declare function Either<T extends RawRule<any>[]>(...rules: T): Rule<{
    [K in keyof T]: Result<T[K]>;
}[number]>;
/**
 *
 */
export declare function OneOrMore<R extends RawRule<any>>(r: R): Rule<Result<R>[]>;
/**
 *
 */
export declare function Repeat<R extends RawRule<any>>(r: R): Rule<Result<R>[]>;
/**
 *
 */
export declare function Opt<R extends RawRule<any>>(r: R): Rule<Result<R> | null>;
/**
 *
 */
export declare function Not<R extends RawRule<any>>(r: R): Rule<null>;
/**
 * If provided with a skip rule, any will return a string containing all characters
 * until the next skip.
 */
export declare const Any: Rule<string>;
export declare function Until(reg: RawRule<any>): Rule<string[]>;
export declare function Parser<T>(rule: Rule<T>, skip?: RegExp): (input: string) => typeof NoMatch | ParseResult<T>;
/**
 *
 */
export declare function S<Rules extends RawRule<any>[]>(tpl: TemplateStringsArray, ...rules: Rules): Rule<Rules extends [] ? null : Rules extends [RawRule<infer T>] ? T : {
    [K in keyof Rules]: Result<Rules[K]>;
}>;
export declare const SeparatedBy: <T extends RawRule<any>>(rule: T, sep: RawRule<any>) => Rule<Result<T>[]>;