export type ParseResult<T> = {
    value: T;
    restInput: string;
};
export declare class ParseError extends Error {
    readonly restInput: string;
    name: string;
    constructor(message: string, restInput: string);
}
export declare class Parser<T> {
    readonly run: (input: string) => ParseResult<T>;
    constructor(run: (input: string) => ParseResult<T>);
    andThen<U>(restParser: (result: T) => Parser<U>): Parser<U>;
    map<U>(fn: (value: T) => U): Parser<U>;
}
export declare function failure<T>(message: string): Parser<T>;
export declare function sequence<Ts extends unknown[]>(parsers: {
    [K in keyof Ts]: Parser<Ts[K]>;
}): Parser<Ts>;
export declare function pure<T>(value: T): Parser<T>;
export declare function string(str: string): Parser<string>;
export declare function char(char: string): Parser<string>;
export declare function between<T>(open: Parser<unknown>, close: Parser<unknown>, middle: Parser<T>): Parser<T>;
export declare function choice<T>(parserOptions: Parser<T>[]): Parser<T>;
export declare function many<T>(parser: Parser<T>): Parser<T[]>;
export declare function some<T>(parser: Parser<T>): Parser<[T, ...T[]]>;
export declare function count<T>(n: number, parser: Parser<T>): Parser<T[]>;
export declare function optional<T>(parser: Parser<T>): Parser<T | undefined>;
export declare function satisfy(predicate: (char: string) => boolean): Parser<string>;
export declare const digitChar: Parser<string>;
export declare const hexChar: Parser<string>;
export declare const anyChar: Parser<string>;
export declare const decimal: Parser<number>;
export declare function lazy<T>(createParser: () => Parser<T>): Parser<T>;
export declare function tryElseBacktrack<T>(parser: Parser<T>): Parser<T>;
export declare namespace Expr {
    type UnaryOperator<T> = Parser<(inner: T) => T>;
    type BinaryOperator<T, R = T> = Parser<(left: T, right: T) => R>;
    function infixOpLeftAssoc<T>(left: T, operatorParser: BinaryOperator<T>, rightParser: Parser<T>): Parser<T>;
    function infixOpRightAssoc<T>(left: T, operatorParser: BinaryOperator<T>, rightParser: Parser<T>): Parser<T>;
    function infixOpLeftAssocOptional<T>(left: T | undefined, operatorParser: BinaryOperator<T | undefined, T>, rightParser: Parser<T>): Parser<T>;
    function infixOpRightAssocOptional<T>(left: T | undefined, operatorParser: BinaryOperator<T | undefined, T>, rightParser: Parser<T>): Parser<T>;
    type Operator<T> = Readonly<{
        type: 'prefix';
        op: Expr.UnaryOperator<T>;
    } | {
        type: 'postfix';
        op: Expr.UnaryOperator<T>;
    } | {
        type: 'infixLeft';
        op: Expr.BinaryOperator<T>;
    } | {
        type: 'infixRight';
        op: Expr.BinaryOperator<T>;
    } | {
        type: 'infixLeftOptional';
        op: Expr.BinaryOperator<T | undefined, T>;
    } | {
        type: 'infixRightOptional';
        op: Expr.BinaryOperator<T | undefined, T>;
    }>;
    function makeExprParser<T>(termParser: Parser<T>, operators: Operator<T>[]): Parser<T>;
}