import type { Handler } from '../types';
import { ConcatPath } from '../utils/concatPath';
import { lowercaseMethods } from '../utils/methods';
import { t } from 'wint-js';
type Merge<A, B> = B extends object ? (A extends object ? (keyof A extends never ? B : A & B) : (keyof B extends never ? A : B)) : B;
type MergeRoutes<A extends GenericRoutes, B extends GenericRoutes> = Routes<A['base'], Merge<A['stateInfer'], B['stateInfer']>>;
export type Route = [method: string, path: string, handlers: Handler[]];
export type PluginResult<T extends Plugin<any, any>> = ReturnType<T['plugin']>;
export interface RouteHandler<Root extends string, State extends t.BaseState> {
    <Path extends string>(path: Path, ...handlers: Handler<ConcatPath<Root, Path>, State>[]): Routes<Root, State>;
}
export interface Routes<Root extends string, State extends t.BaseState> extends Record<typeof lowercaseMethods[number], RouteHandler<Root, State>> {
}
export interface GenericRoutes extends Routes<any, Record<string, any>> {
}
export interface GenericPlugin extends Plugin<any, any> {
}
/**
 * A routes plugin
 */
export interface Plugin<B extends Routes = GenericRoutes, R extends B = B> {
    plugin<T extends B>(routes: T): R;
}
export declare class Routes<Root extends string = any, State extends t.BaseState = {}> implements Plugin {
    base: Root;
    /**
     * Properties for correct type inference. Set to null by default
     */
    stateInfer: State;
    /**
     * Fallback when guard functions reject
     */
    fallback: Handler<Root>;
    /**
     * Routes record
     */
    readonly record: Route[];
    /**
     * Route guards - before handling
     */
    readonly guards: Handler<Root, State>[];
    /**
     * Route wrappers - after handling
     */
    readonly wraps: Handler<Root, State>[];
    /**
     * Create a route group
     */
    constructor(base?: Root);
    /**
     * Add prefix
     */
    prefix<B extends string>(base: B): Routes<ConcatPath<B, Root>, State>;
    /**
     * Add guards
     */
    guard(...fns: Handler<Root, State>[]): this;
    /**
     * Add layers (Guards with no validation)
     */
    layer(...fns: Handler<Root, State>[]): this;
    /**
     * Non-typesafe plugins
     */
    plug<T extends Plugin<this, any>[]>(...plugins: T): this;
    /**
     * Register a plugin
     */
    use<T extends Plugin<this, any>>(f: T): MergeRoutes<this, PluginResult<T>>;
    /**
     * Add wraps
     */
    wrap(...fns: Handler<Root, State>[]): this;
    /**
     * Add a state as a guard
     */
    state<F extends Handler<Root, State>>(fn: F, reject?: Handler<Root, State>): Routes<Root, NonNullable<Awaited<ReturnType<F>>>>;
    /**
     * Add multiple fields to the state
     */
    state<O extends Record<string, Handler<Root, State>>>(rec: O, reject?: Handler<Root, State>): Routes<Root, {
        [key in keyof O]: NonNullable<Awaited<ReturnType<O[key]>>>;
    } & State>;
    private hasMultipleState;
    private registerMultipleState;
    private registerSingleState;
    /**
     * Prepend guard. This function is considered internal API.
     */
    prependGuards(...fns: Handler<Root, State>[]): this;
    /**
     * Register a reject handler for current handlers
     */
    reject(fn: Handler<Root, State>): this;
    /**
     * Extend other routes
     */
    extend(...routes: Routes[]): this;
    /**
     * Routes can be used as a plugin
     */
    plugin<T extends Routes>(routes: T): T;
    /**
     * Infer all routes to the router
     */
    infer<T extends t.FastWint>(router: T): T;
}
/**
 * Route groups
 */
export declare const routes: <Root extends string = any>(base?: Root) => Routes<Root, {}>;
/**
 * Create reusable states
 */
export declare const state: <T extends Handler<any, {}> | Record<string, Handler<any, {}>>>(s: T) => T;
/**
 * Create a plugin from a function
 */
export declare const plugin: <R extends Routes<any, any>>(plugin: (routes: GenericRoutes) => R) => Plugin<GenericRoutes, R>;
export {};