import { ParserLike, ParserValue } from "./combinators";
import type { ParseResultDetaill } from "./combinators";
import { Parser, Mark, Node } from "./parser";
interface Chain {
    <Value, U>(onOk: (value: Value, i: ParseResultDetaill) => Parser<U>): (parser2: Parser<Value>) => Parser<U>;
    <Value, U1, U2>(onOk: (value: Value, i: ParseResultDetaill) => Parser<U1>, onFail: (i: ParseResultDetaill) => Parser<U2>): (parser2: Parser<Value>) => Parser<U1 | U2>;
}
declare const chain: Chain;
declare const mapToParser: Chain;
declare const join: <T extends string[]>(sep?: string) => (parser: Parser<T>) => Parser<string>;
declare const many: <T extends ParserLike>(parserLike: T) => Parser<ParserValue<T>[]>;
declare type Concat = <T extends ParserLike>(unit: T) => <U extends ParserLike>(parserLike: U) => ParserValue<T> extends unknown[] ? ParserValue<U> extends unknown[] ? Parser<[...ParserValue<U>, ...ParserValue<T>]> : Parser<[ParserValue<U>, ...ParserValue<T>]> : ParserValue<U> extends unknown[] ? Parser<[...ParserValue<U>, ParserValue<T>]> : Parser<[ParserValue<U>, ParserValue<T>]>;
declare const concat: Concat;
declare const plus: Concat;
declare const and: Concat;
declare const pick1: <T extends object | any[], I extends keyof T>(key: I) => (parser: Parser<T>) => Parser<T[I]>;
declare type Remap = {
    <K1 extends string, V1 extends number, I extends Readonly<{
        [key in K1]: V1;
    }>>(mapTemplate: I): <T extends ReadonlyArray<unknown>>(parser: Parser<T>) => Parser<{
        [K in keyof I]: I[K] extends keyof T ? T[I[K]] : I[K];
    }>;
    <K1 extends string, V1 extends string, I extends Readonly<{
        [key in K1]: V1;
    }>>(mapTemplate: I): <T extends Readonly<Object>>(parser: Parser<T>) => Parser<{
        [K in keyof I]: I[K] extends keyof T ? T[I[K]] : I[K];
    }>;
    <I extends Readonly<Object>>(mapTemplate: I): <T extends ReadonlyArray<unknown> | Readonly<Object>>(parser: Parser<T>) => Parser<{
        [K in keyof I]: I[K] extends keyof T ? T[I[K]] : I[K];
    }>;
    <I extends ReadonlyArray<unknown>>(mapTemplate: readonly [...I]): <T extends ReadonlyArray<unknown> | Readonly<Object>>(parser: Parser<T>) => Parser<{
        [K in keyof I]: I[K] extends keyof T ? T[I[K]] : I[K];
    }>;
};
declare const remap: Remap;
declare type MakeObj<Template extends ReadonlyArray<string>, Values extends ReadonlyArray<unknown> & {
    length: Template["length"];
}, Obj = {}> = Template extends [] ? Obj : Template extends [infer Key, ...infer RestKeys] ? Values extends [infer Value, ...infer RestValues] ? Key extends string ? RestKeys extends ReadonlyArray<string> ? Key extends "" ? MakeObj<RestKeys, RestValues, Obj> : MakeObj<RestKeys, RestValues, {
    [K in Key | keyof Obj]: K extends Key ? Value : K extends keyof Obj ? Obj[K] : never;
}> : {
    [K in Key | keyof Obj]: K extends Key ? Value : K extends keyof Obj ? Obj[K] : never;
} : never : never : never;
declare type ToObj = {
    <T extends ReadonlyArray<"" | string>>(...objTemplate: T): <P extends ReadonlyArray<unknown> & {
        length: T["length"];
    }>(parser: Parser<P>) => Parser<MakeObj<T, P>>;
};
declare const toObj: ToObj;
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 const flatDeep: <T extends Parser<unknown>>(parser: T) => Parser<DeepFlattened<ParserValue<T>>[]>;
declare const flat: <T extends Parser<unknown>>(parser: T) => ParserValue<T> extends any[] ? Parser<Flatten<ParserValue<T>>> : Parser<ParserValue<T>>;
declare const sepBy1: <T extends ParserLike>(sep: T) => <U extends ParserLike>(parser: U) => Parser<[readonly [ParserValue<U>], ...ParserValue<U>[]]>;
declare const sepBy: <T extends ParserLike>(sep: T) => <U extends ParserLike>(parser: U) => Parser<[readonly [ParserValue<U>], ...ParserValue<U>[]] | ParserValue<U>[]>;
declare const assert: <T>(func: (value: T) => boolean, desc?: string) => (parser2: Parser<T>) => Parser<T>;
declare const not: <T extends ParserLike>(notParser: T) => <U extends ParserLike>(parserLike: U) => Parser<unknown>;
interface Fallback {
    (result1: undefined): <U extends ParserLike>(parser: U) => Parser<ParserValue<U> | undefined>;
    (result2: null): <U extends ParserLike>(parser: U) => Parser<null | ParserValue<U>>;
    <T>(result3: T): <U extends ParserLike>(parser: U) => Parser<ParserValue<U> | T>;
}
declare const fallback: Fallback;
declare const wrap: <L extends ParserLike, R extends ParserLike>(left: L, right?: R | undefined) => <U extends ParserLike>(parser: U) => Parser<ParserValue<U>>;
declare const trim: <T extends ParserLike>(trimParser?: T | undefined) => <U extends ParserLike>(parser: U) => Parser<ParserValue<U>>;
declare const or: <T extends ParserLike>(altParser: T) => <U extends ParserLike>(parser: U) => Parser<ParserValue<T> | ParserValue<U>>;
declare function times(count: number): <U extends ParserLike>(parserLike: U) => Parser<ParserValue<U>[]>;
declare function times(min: number, max: number): <U extends ParserLike>(parserLike: U) => Parser<ParserValue<U>[]>;
declare const atMost: (n: number) => <U extends ParserLike>(parserLike: U) => Parser<ParserValue<U>[]>;
declare const atLeast: (n: number) => <U extends ParserLike>(parser: U) => Parser<ParserValue<U>[]>;
declare const premap: (fn: (input: string) => string) => <U extends ParserLike>(parserLike: U) => Parser<ParserValue<U>>;
declare const skip: <T extends ParserLike>(next: T) => <U extends ParserLike>(parser: U) => Parser<ParserValue<U>>;
declare const then: <T extends ParserLike>(next: T) => <U extends ParserLike>(parser: U) => Parser<ParserValue<T>>;
declare const mark: <U extends ParserLike>(parser: U) => Parser<Mark<ParserValue<U>>>;
declare const node: <Name extends string>(name: Name) => <U extends ParserLike>(parser: U) => Parser<Node<ParserValue<U>, Name>>;
interface Label {
    <Name extends string>(name: Name): <U extends ParserLike>(parser: U) => readonly [Name, Parser<ParserValue<U>>];
    <Name extends string, U extends ParserLike>(name: Name, parser: U): readonly [
        Name,
        Parser<ParserValue<U>>
    ];
}
declare const label: Label;
declare const notFollowedBy: (notParser: ParserLike) => <U extends ParserLike>(parserLike: U) => Parser<ParserValue<U>>;
declare const followedBy: (followParserLike: ParserLike) => <U extends ParserLike>(parserLike: U) => Parser<ParserValue<U>>;
declare const tap: <T extends ParserLike>(tapFn: (v: ParserValue<T>) => any) => (parser: T) => Parser<ParserValue<T>>;
declare const mapTo: <U>(value: U) => (parser: Parser<unknown>) => Parser<U>;
declare const toInnerParser: <T extends ParserLike>(innerParser: T) => <U extends string | Parser<string> | (() => Parser<string>)>(outerParser: U) => Parser<ParserValue<T>>;
declare const inSingleLine: <T extends ParserLike>(parser: T) => Parser<ParserValue<T>>;
declare const asSingleLine: <T extends ParserLike>(parser: T) => Parser<ParserValue<T>>;
export { map, desc, pipe, combine } from "./combinators";
export { join, sepBy, sepBy1, many, followedBy, not, notFollowedBy, node, mark, skip, premap, atLeast, atMost, times, or, trim, wrap, fallback, assert, chain, mapToParser, toInnerParser, inSingleLine, asSingleLine, concat, plus, and, then, pick1, flat, tap, mapTo, flatDeep, remap, label, toObj, pick1 as pick, };
//# sourceMappingURL=operators.d.ts.map