import { ParserLike, ParserValue } from "./combinators";
declare type DeepFlattened<T> = T extends ReadonlyArray<infer U> ? DeepFlattened<U> : T;
declare type Tail<T extends readonly unknown[]> = T extends readonly [any, ...infer U] ? U : [];
declare type Flatten<T extends readonly unknown[]> = {
    0: [];
    1: T[0] extends unknown[] ? [...T[0], ...Flatten<Tail<T>>] : [T[0], ...Flatten<Tail<T>>];
}[T extends [] ? 0 : 1];
declare module "./parser" {
    interface Parser<T> {
        map: <U>(mapFn: (v: T) => U) => Parser<U>;
        tap: (tapFn: (v: T) => any) => Parser<T>;
        desc: (expected: string) => this;
        join: (sep?: string) => T extends string[] ? Parser<string> : never;
        concat<U extends ParserLike>(unit: U): ParserValue<U> extends unknown[] ? T extends unknown[] ? Parser<[...T, ...ParserValue<U>]> : Parser<[T, ...ParserValue<U>]> : T extends unknown[] ? Parser<[...T, ParserValue<U>]> : Parser<[T, ParserValue<U>]>;
        plus<U extends ParserLike>(unit: U): ParserValue<U> extends unknown[] ? T extends unknown[] ? Parser<[...T, ...ParserValue<U>]> : Parser<[T, ...ParserValue<U>]> : T extends unknown[] ? Parser<[...T, ParserValue<U>]> : Parser<[T, ParserValue<U>]>;
        flatDeep(): T extends [...unknown[]] ? Parser<DeepFlattened<T>[]> : Parser<T>;
        flat(): T extends readonly any[] ? Parser<Flatten<T>> : Parser<T>;
        pick1: <I extends keyof T>(key: I) => T extends object | any[] ? Parser<T[I]> : never;
        sepBy: (sepLike: ParserLike) => Parser<T[]>;
        sepBy1: (sepLike: ParserLike) => Parser<T[]>;
        many: () => Parser<T[]>;
        chain: <U>(chainFn: (v: T) => Parser<U>) => Parser<U>;
        assert: (checkFn: (v: T) => boolean) => this;
        not: (notParser: ParserLike) => Parser<T>;
        fallback: <U>(fallbackResult: U) => Parser<T | U>;
        wrap: (leftLike: ParserLike, rightLike?: ParserLike) => Parser<T>;
        trim(): Parser<T>;
        trim(quoteLike: ParserLike): Parser<T>;
        trim(leftLike: ParserLike, rightLike: ParserLike): Parser<T>;
        trimL: (leftLike?: ParserLike) => Parser<T>;
        trimR: (rightLike?: ParserLike) => Parser<T>;
        or: <U extends ParserLike>(altLike: U) => Parser<T | ParserValue<U>>;
        times(min: number, max: number): Parser<T[]>;
        times(count: number): Parser<T[]>;
        atLeast: (count: number) => Parser<T[]>;
        atMost: (count: number) => Parser<T[]>;
        premap: (fn: (input: string) => string) => Parser<T>;
        skip: (skip: ParserLike) => Parser<T>;
        then: <U extends ParserLike>(parser: U) => Parser<ParserValue<U>>;
        mark: () => Parser<Mark<T>>;
        of: <U>(value: U) => Parser<U>;
        node: <NAME extends string>(nodeName: NAME) => Parser<Node<T, NAME>>;
        notFollowedBy: (notParser: ParserLike) => Parser<T>;
        followedBy: (followParser: ParserLike) => Parser<T>;
        withRawText: () => Parser<{
            value: T;
            rawText: string;
        }>;
        label: <U extends string>(name: U) => readonly [U, Parser<T>];
        pipe<A>(a: (t: this) => A): A;
        pipe<A, B>(a: (t: this) => A, ab: (a: A) => B): B;
        pipe<A, B, C>(a: (t: this) => A, ab: (a: A) => B, bc: (b: B) => C): C;
        pipe<A, B, C, D>(a: (t: this) => A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
        pipe<A, B, C, D, E>(a: (t: this) => A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
    }
}
export {};
//# sourceMappingURL=parser-method.d.ts.map