import { Params, Route, RouteOptions, Router as TRRouter } from "tiny-request-router";
import { Context } from "../context";
import { Middleware, MiddlewareNextFunction, SyncMiddleware } from "../middlewareTypes";
export declare type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
export declare type MethodWildcard = "ALL";
/**
 * A handler function just takes a context, you have to type the generic <Environment, Params> to use params
 * in your Handler in a type-checked manner.
 *
 * Consider a handler your "final" middleware, usually it's the one that adds the HTML or JSON to the response.
 *
 * Example:
 * ```
 * const myHandler: Handler<{}, {username: string}> = (ctx) => {
 *   ctx.response.body = `Hello ${ctx.params.username}!`;
 * }
 * ```
 */
export declare type Handler<EnvironmentType = Record<string, any>, ParamsType = {}, ContextDataType = any> = Middleware<EnvironmentType, ParamsType, ContextDataType> | SyncMiddleware<EnvironmentType, ParamsType, ContextDataType>;
/**
 * A stronger-typed version of `RouteMatch` in tiny-request-router
 */
export declare type RouteHandlerMatch<S extends string> = {
    params: PathParams<S> & Params;
    matches?: RegExpExecArray;
} & Route<Handler<PathParams<S>>>;
export declare type SplitRoute<S extends string> = string extends S ? string[] : S extends `${infer Start}/:${infer Param}/${infer Rest}` ? [Param, ...SplitRoute<Rest>] : S extends `${infer Start}/:${infer Param}+` ? [Param] : S extends `${infer Start}/:${infer Param}` ? [Param] : [];
export declare type PathParams<S extends string> = {
    [P in SplitRoute<S>[number]]: string;
} & {
    [P in SplitRoute<S>[number]]?: string;
};
/**
 * Router wraps the tiny-request-router `Router` with a more strict RouteHandler type and automatic params typings.
 *
 * Optionally you can supply a generic type definition for userdata that is shared between all endpoints in this router.
 */
export declare class Router<EnvironmentType = Record<string, any>, InitialContextDataType = {}> {
    /**
       * The wrapped tiny-request-router Router.
       */
    readonly internalRouter: TRRouter;
    constructor();
    get<S extends string>(path: S, handler: Handler<EnvironmentType, PathParams<S>, InitialContextDataType>, opts?: RouteOptions): this;
    post<S extends string>(path: S, handler: Handler<EnvironmentType, PathParams<S>, InitialContextDataType>, opts?: RouteOptions): this;
    head<S extends string>(path: S, handler: Handler<EnvironmentType, PathParams<S>, InitialContextDataType>, opts?: RouteOptions): this;
    patch<S extends string>(path: S, handler: Handler<EnvironmentType, PathParams<S>, InitialContextDataType>, opts?: RouteOptions): this;
    put<S extends string>(path: S, handler: Handler<EnvironmentType, PathParams<S>, InitialContextDataType>, opts?: RouteOptions): this;
    delete<S extends string>(path: S, handler: Handler<EnvironmentType, PathParams<S>, InitialContextDataType>, opts?: RouteOptions): this;
    options<S extends string>(path: S, handler: Handler<EnvironmentType, PathParams<S>, InitialContextDataType>, opts?: RouteOptions): this;
    all<S extends string>(path: S, handler: Handler<EnvironmentType, PathParams<S>, InitialContextDataType>, opts?: RouteOptions): this;
    match<S extends string>(method: string, path: S): RouteHandlerMatch<S> | null;
    readonly middleware: (ctx: Context, next?: MiddlewareNextFunction) => Promise<void>;
}