import { Parser, ParseResult, OkResult, FailResult } from "./parser";
declare type ParserLike = string | (() => string) | RegExp | (() => RegExp) | Parser<unknown> | (() => Parser<unknown>);
declare type ParserValue<T> = T extends ParserLike ? T extends string ? T : T extends RegExp ? string : T extends Parser<infer P> ? P : T extends () => infer R ? R extends string ? R : R extends RegExp ? string : R extends Parser<infer P> ? P : never : never : never;
declare type ToParser<T> = Parser<ParserValue<T>>;
export declare type ParserValues<T extends readonly any[]> = {
    [P in keyof T]: P extends `${number}` ? ParserValue<T[P]> : T[P];
};
export declare type LanguageInfo<T> = {
    [P in keyof T]: T[P] extends (...args: infer R1) => infer R2 ? (...args: R1) => Parser<R2> : Parser<T[P]>;
};
export declare type ParserContainer<T> = {
    [P in keyof T]: T[P] extends (A1: infer R1, ...rest: infer R2) => infer R3 ? (info: LanguageInfo<T>, A1: R1, ...rest: R2) => Parser<R3> : (info: LanguageInfo<T>) => Parser<T[P]>;
};
export declare type Markable = readonly [ParserLike] | ParserLike;
export declare type MarkableToMono<T extends readonly Markable[]> = NotUnion<{
    [P in keyof T]: T[P] extends readonly [ParserLike] ? ToParser<T[P][0]> : never;
}[number]>;
declare type NotUnion<T, Org = T> = T extends any ? Org[] extends T[] ? Org : never : never;
declare type Labelable = readonly [string, ParserLike] | ParserLike;
declare type LabelableToObj<T extends readonly Labelable[], Obj = {}> = T extends [] ? Obj : T extends [readonly [infer Key, infer Value], ...infer Rest] ? Key extends string ? Value extends ParserLike ? Rest extends readonly Labelable[] ? LabelableToObj<[
    ...Rest
], {
    [K in Key | keyof Obj]: K extends Key ? ParserValue<Value> : K extends keyof Obj ? Obj[K] : never;
}> : {
    [K in Key | keyof Obj]: K extends Key ? ParserValue<Value> : K extends keyof Obj ? Obj[K] : never;
} : Value : Key : T extends [ParserLike, ...infer Rest] ? Rest extends readonly Labelable[] ? LabelableToObj<[...Rest], Obj> : Obj : Obj;
declare type PipeFn<T1, T2> = (value: T1) => T2;
interface Pipe {
    <A extends string, B>(a: A, ab: PipeFn<A, B>): B;
    <A extends string, B, C>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>): C;
    <A extends string, B, C, D>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>): D;
    <A extends string, B, C, D, E>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>): E;
    <A extends string, B, C, D, E, F>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>): F;
    <A extends string, B, C, D, E, F, G>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>, fg: PipeFn<F, G>): G;
    <A extends string, B, C, D, E, F, G, H>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>, fg: PipeFn<F, G>, gh: PipeFn<G, H>): H;
    <A extends string, B, C, D, E, F, G, H, I>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>, fg: PipeFn<F, G>, gh: PipeFn<G, H>, hi: PipeFn<H, I>): I;
    <A, B>(a: A, ab: PipeFn<A, B>): B;
    <A, B, C>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>): C;
    <A, B, C, D>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>): D;
    <A, B, C, D, E>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>): E;
    <A, B, C, D, E, F>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>): F;
    <A, B, C, D, E, F, G>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>, fg: PipeFn<F, G>): G;
    <A, B, C, D, E, F, G, H>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>, fg: PipeFn<F, G>, gh: PipeFn<G, H>): H;
    <A, B, C, D, E, F, G, H, I>(a: A, ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>, fg: PipeFn<F, G>, gh: PipeFn<G, H>, hi: PipeFn<H, I>): I;
}
declare const pipe: Pipe;
interface Combine {
    <A, B>(ab: PipeFn<A, B>): B;
    <A, B, C>(ab: PipeFn<A, B>, bc: PipeFn<B, C>): PipeFn<A, C>;
    <A, B, C, D>(ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>): PipeFn<A, D>;
    <A, B, C, D, E>(ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>): PipeFn<A, E>;
    <A, B, C, D, E, F>(ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>): PipeFn<A, F>;
    <A, B, C, D, E, F, G>(ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>, fg: PipeFn<F, G>): PipeFn<A, G>;
    <A, B, C, D, E, F, G, H>(ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>, fg: PipeFn<F, G>, gh: PipeFn<G, H>): PipeFn<A, H>;
    <A, B, C, D, E, F, G, H, I>(ab: PipeFn<A, B>, bc: PipeFn<B, C>, cd: PipeFn<C, D>, de: PipeFn<D, E>, ef: PipeFn<E, F>, fg: PipeFn<F, G>, gh: PipeFn<G, H>, hi: PipeFn<H, I>): PipeFn<A, I>;
}
declare const combine: Combine;
declare type Lazy = <T>(func: () => Parser<T>) => Parser<T>;
declare const lazy: Lazy;
declare const toParser: <T extends ParserLike>(x: T) => Parser<ParserValue<T>>;
declare const toParsers: <T extends readonly ParserLike[]>(xs: readonly [...T]) => Parser<ParserValue<T[number]>>[];
interface Of {
    <T extends string>(v1: T): Parser<T>;
    <T extends RegExp>(v2: T): Parser<string>;
    <T extends string>(func1: () => T): Parser<T>;
    (func2: () => RegExp): Parser<string>;
    <T>(fn3: () => Parser<T>): Parser<T>;
    <T extends readonly [ParserLike, ...ParserLike[]]>(...parserLikes: T): Parser<ParserValues<T>>;
    <T extends [Labelable, ...Labelable[]]>(...parserLikeOrLabeled: T): Parser<LabelableToObj<T>>;
}
declare const of: Of;
declare type DescFn = (prev: string, i: number) => string;
interface Desc {
    (expect: string): <T>(parser: Parser<T>) => Parser<T>;
    (descFn: DescFn): <T>(parser: Parser<T>) => Parser<T>;
}
declare const desc: Desc;
interface ParseResultDetail {
    readonly wholeText: string;
    readonly ok: boolean;
    readonly start: number;
    readonly end: number;
    readonly expect: string;
    readonly parsed: () => string;
}
interface MapResult {
    <Value, U1>(onOk: (result: OkResult<Value>, i: ParseResultDetail) => ParseResult<U1>): (parser2: Parser<Value>) => Parser<U1>;
    <Value, U1, U2>(onOk: (result: OkResult<Value>, i: ParseResultDetail) => ParseResult<U1>, onFail: (result: FailResult, i: ParseResultDetail) => ParseResult<U2>): (parser2: Parser<Value>) => Parser<U1 | U2>;
}
declare const mapResult: MapResult;
declare type MapOperator = {
    <V, R>(mapFn1: (value: V, i: ParseResultDetail) => R): (parser: Parser<V>) => Parser<R>;
};
declare const map: MapOperator;
declare const seq: <T extends readonly [ParserLike, ...ParserLike[]]>(...parserLikes: T) => Parser<ParserValues<T>>;
declare const seqToMono: <T extends readonly [Markable, ...Markable[]]>(...markables: T) => NotUnion<{ [P in keyof T]: T[P] extends readonly [ParserLike] ? ToParser<T[P][0]> : never; }[number], { [P in keyof T]: T[P] extends readonly [ParserLike] ? ToParser<T[P][0]> : never; }[number]>;
declare const seqObj: <T extends [Labelable, ...Labelable[]]>(...p: T) => Parser<LabelableToObj<T, {}>>;
declare const createLanguage: <T>(parsers: ParserContainer<T>) => LanguageInfo<T>;
declare const alt: <T extends readonly [ParserLike, ...ParserLike[]]>(...p: T) => Parser<ParserValue<T[number]>>;
declare const peek: <T extends ParserLike>(x: T) => Parser<ParserValue<T>>;
declare const takeWhile: (predicate: ParserLike) => Parser<string>;
declare const takeTo: (stop_0: ParserLike, ...stop_1: ParserLike[]) => Parser<string>;
declare const between: (start: ParserLike, end: ParserLike) => Parser<string>;
interface Prev {
    (text: string): Parser<string>;
    <T>(parser: Parser<T>, backTo: number): Parser<T>;
}
declare const prev: Prev;
export { toParser, toParsers, lazy, desc, map, mapResult, seq, seqToMono, seqObj, createLanguage, alt, peek, takeWhile, takeTo, pipe, prev, combine, between, alt as anyOf, of, };
export type { ParserValue, ToParser, ParserLike, ParseResultDetail as ParseResultDetaill, Labelable, };
//# sourceMappingURL=combinators.d.ts.map