import { Key } from 'path-to-regexp';

declare const METHODS: readonly ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
type Methods = (typeof METHODS)[number];

type Request<T extends string> = {
    method: Methods;
    url: string;
    host: string;
    query: ExtractQueryParams<RemoveParentheses<T>>;
    params: ExtractRouteParams<RemoveParentheses<T>>;
    headers: HttpHeader;
    body: Record<string, string> | null;
};
type Response = {
    setHeader(key: string, value: string): Response;
    status: (code: number) => Response;
    send: (data: object | string | number | unknown[]) => Response;
    json: (data: object | string | number | unknown[]) => Response;
    end: () => void;
};
type Next = () => void;
type Handler<T extends string> = (req: Request<T>, res: Response, next: Next) => void | Promise<void> | Response | Promise<Response | undefined | unknown>;
type ExtractRouteParams<T> = T extends `${string}/:${infer Param}/${infer Rest}` ? {
    [K in Param | keyof ExtractRouteParams<`/${Rest}`>]: string;
} : T extends `${string}/:${infer Param}` ? {
    [K in Param]: string;
} : Record<string, string>;
type RemoveParentheses<T extends string> = T extends `${infer Before}\(${string}\)${infer After}` ? `${Before}${After}` : T;
type ExtractQueryParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}?${infer U}` ? U extends `${infer Query}&${infer Rest}` ? Record<Query extends `${infer Key}=${string}` ? Key : never, Query extends `${string}=${infer Value}` ? Value : never> & ExtractQueryParams<`?${Rest}`> : U extends `${infer Query}` ? Record<Query extends `${infer Key}=${string}` ? Key : never, Query extends `${string}=${infer Value}` ? Value : never> : Record<string, string> : Record<string, string>;
type RouterError = Error;
type HttpHeader = {
    [key: string]: string | string[] | undefined;
};
type UseHandler<T extends string> = (handler: Handler<T>) => RestRouter;
type UseRouterWithPath<T extends string> = (path: T, router: RestRouter) => RestRouter;
type UseRouter = (router: RestRouter) => RestRouter;
type ErrorHandler = (err: RouterError, req: Request<string>, res: Response, next: Next) => void | Promise<void>;
type UseErrorHandler = (handler: ErrorHandler) => RestRouter;
type Route = {
    method?: Methods;
    path: string | null;
    handler: Handler<string> | RestRouter;
    regexp: RegExp;
    keys: Key[];
};
type RestRouter = {
    get routes(): Route[];
    get errorHandlers(): ErrorHandler[];
    use: UseHandler<string> & UseRouter & UseRouterWithPath<string>;
    useError: UseErrorHandler;
    METHOD: <Path extends string>(method: Methods, path: Path, handler: Handler<Path>) => RestRouter;
    delete: <Path extends string>(path: Path, handler: Handler<Path>) => RestRouter;
    get: <Path extends string>(path: Path, handler: Handler<Path>) => RestRouter;
    head: <Path extends string>(path: Path, handler: Handler<Path>) => RestRouter;
    options: <Path extends string>(path: Path, handler: Handler<Path>) => RestRouter;
    patch: <Path extends string>(path: Path, handler: Handler<Path>) => RestRouter;
    post: <Path extends string>(path: Path, handler: Handler<Path>) => RestRouter;
    put: <Path extends string>(path: Path, handler: Handler<Path>) => RestRouter;
};
type AnyFunction = (...args: any[]) => any;

declare const createRouter: () => RestRouter;
declare const isHandler: (o: RestRouter | string | Handler<string>) => o is Handler<string>;

declare const enableLogger: () => void;

export { AnyFunction as A, ErrorHandler as E, Handler as H, Next as N, Request as R, UseHandler as U, Response as a, RouterError as b, createRouter as c, HttpHeader as d, enableLogger as e, UseRouterWithPath as f, UseRouter as g, UseErrorHandler as h, isHandler as i, Route as j, RestRouter as k };