export interface OkResult<T> {
    ok: true;
    index: number;
    value: T;
    expect: string;
}
export interface FailResult {
    ok: false;
    index: number;
    expect: string;
}
export declare type ParseResult<T> = OkResult<T> | FailResult;
export declare type ParseFn<T> = (input: string, index: number, makeOk: <U>(index: number, value: U, expected?: string) => OkResult<U>, makeFail: (index: number, expected: string) => FailResult) => ParseResult<T>;
export declare type Index = {
    offset: number;
    line: number;
    column: number;
};
export declare type Mark<T> = {
    start: Index;
    end: Index;
    value: T;
};
export declare type Node<T, U extends string> = {
    start: Index;
    end: Index;
    name: U;
    value: T;
};
export declare type Tree<T, U extends string, I extends string> = {
    start: Index;
    end: Index;
    name: U;
    value: Node<T, I> | Tree<T, U, I>[] | (Tree<T, U, I> | Node<T, I>)[];
};
interface To<T> {
    <A>(a: (t: T) => A): A;
    <A, B>(a: (t: T) => A, ab: (a: A) => B): B;
    <A, B, C>(a: (t: T) => A, ab: (a: A) => B, bc: (b: B) => C): C;
    <A, B, C, D>(a: (t: T) => A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
    <A, B, C, D, E>(a: (t: T) => A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
    <A, B, C, D, E, F>(a: (t: T) => A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
}
declare const isOk: <T>(x: ParseResult<T>) => x is OkResult<T>;
declare const isFail: <T>(x: ParseResult<T>) => x is FailResult;
declare const offsetToPosition: (input: string, offset: number) => {
    offset: number;
    line: number;
    column: number;
};
declare const makeOk: <T>(index: number, value: T, expect?: string) => OkResult<T>;
declare const makeFail: (index: number, expect: string) => FailResult;
declare const makeParser: <T>(action: ParseFn<T>) => Parser<T>;
declare type ErrorFormatter = (input: string, index: number, expected: string) => string;
declare class Parser<T> {
    private action;
    constructor(action: ParseFn<T>);
    static formatter: ErrorFormatter;
    parse(input: string, index?: number): ParseResult<T>;
    static setDefaultErrorFormatter(formatter: ErrorFormatter): void;
    tryParse(input: string, formatter?: ErrorFormatter): T;
    to: To<this>;
}
declare const isParser: <T>(x: unknown) => x is Parser<T>;
declare const string: <T extends string>(str: T) => Parser<T>;
declare const ok: <T>(value: T) => Parser<T>;
declare const fail: (expected: string) => Parser<unknown>;
declare const regexp: (re: RegExp, group?: number) => Parser<string>;
export { Parser, string, makeOk, makeFail, makeParser, ok, fail, regexp, isParser, isFail, isOk, offsetToPosition, };
//# sourceMappingURL=parser.d.ts.map