import { Url } from './index';
import Maybe from '../Maybe';
interface Queries {
    readonly [key: string]: Array<string>;
}
interface State<T> {
    readonly unvisited: Array<string>;
    readonly queries: Queries;
    readonly fragment: Maybe<string>;
    readonly value: T;
}
declare type FA<F, R> = F extends (value: infer A) => R ? A : R;
declare type FF<F, R> = F extends (value: infer A) => infer N ? (value: A) => FF<N, R> : R;
declare type FN<F, R> = F extends (arg0: infer A0) => infer F1 ? (arg0: A0) => F1 extends (arg1: infer A1) => infer F2 ? (arg1: A1) => F2 extends (arg2: infer A2) => infer F3 ? (arg2: A2) => F3 extends (arg3: infer A3) => infer F4 ? (arg3: A3) => F4 extends (arg4: infer A4) => infer F5 ? (arg4: A4) => F5 extends (arg5: infer A5) => infer F6 ? (arg5: A5) => F6 extends (arg6: infer A6) => infer F7 ? (arg6: A6) => F7 extends (arg7: infer A7) => infer F8 ? (arg7: A7) => F8 extends (arg8: infer A8) => infer F9 ? (arg8: A8) => F9 extends (arg9: infer A9) => infer F10 ? (arg9: A9) => F10 extends (arg10: infer A10) => infer F11 ? (arg10: A10) => F11 extends (arg11: infer A11) => infer F12 ? (arg11: A11) => F12 extends (arg12: infer A12) => infer F13 ? (arg12: A12) => F13 extends (arg13: infer A13) => infer F14 ? (arg13: A13) => F14 extends (arg14: infer A14) => infer F15 ? (arg14: A14) => F15 extends (arg15: infer A15) => infer F16 ? (arg15: A15) => F16 extends (arg16: infer A16) => infer F17 ? (arg16: A16) => F17 extends (arg17: infer A17) => infer F18 ? (arg17: A17) => F18 extends (arg18: infer A18) => infer F19 ? (arg18: A18) => F19 extends (arg19: infer A19) => infer F20 ? (arg19: A19) => FN<F20, R> : R : R : R : R : R : R : R : R : R : R : R : R : R : R : R : R : R : R : R : R;
export declare abstract class Parser<A, B> {
    static readonly root: Parser<unknown, unknown>;
    static s(path: string): Parser<unknown, unknown>;
    static custom<A>(converter: (path: string) => Maybe<A>): Parser<(str: A) => unknown, unknown>;
    static readonly string: Parser<(str: string) => unknown, unknown>;
    static readonly number: Parser<(num: number) => unknown, unknown>;
    static oneOf<A, B>(parsers: Array<Parser<A, B>>): Parser<A, B>;
    map<B_ extends B, C>(tagger: FN<A, B_>): Parser<(value: B_) => C, C>;
    readonly slash: Slash<A, B>;
    query(key: string): Query<A, B>;
    fragment<B_ extends B, C>(converter: (valeu: Maybe<string>) => B_): Parser<FF<A, (value: B_) => C>, C>;
    parse(url: Url): Maybe<FA<A, B>>;
    abstract dive(state: State<A>): Array<State<B>>;
}
export interface Slash<A, B> {
    string: Parser<FF<A, (value: string) => B>, B>;
    number: Parser<FF<A, (value: number) => B>, B>;
    s(path: string): Parser<A, B>;
    custom<B_ extends B, C>(converter: (str: string) => Maybe<B_>): Parser<FF<A, (value: B_) => C>, C>;
    oneOf<B_ extends B, C>(parsers: Array<Parser<B_, C>>): Parser<FF<A, B_>, C>;
}
export interface Query<A, B> {
    string: Parser<FF<A, (value: Maybe<string>) => B>, B>;
    number: Parser<FF<A, (value: Maybe<number>) => B>, B>;
    boolean: Parser<FF<A, (value: Maybe<boolean>) => B>, B>;
    list: QueryList<A, B>;
    enum<B_ extends B, C>(variants: Array<[string, B_]>): Parser<FF<A, (value: Maybe<B_>) => C>, C>;
    custom<B_ extends B, C>(converter: (values: Maybe<string>) => B_): Parser<FF<A, (value: B_) => C>, C>;
}
export interface QueryList<A, B> {
    string: Parser<FF<A, (values: Array<string>) => B>, B>;
    number: Parser<FF<A, (values: Array<number>) => B>, B>;
    boolean: Parser<FF<A, (values: Array<boolean>) => B>, B>;
    enum<B_ extends B, C>(variants: Array<[string, B_]>): Parser<FF<A, (values: Array<B_>) => C>, C>;
    custom<B_ extends B, C>(converter: (values: Array<string>) => B_): Parser<FF<A, (value: B_) => C>, C>;
}
export {};