/// <reference types="node" />
/// <reference types="node" />
import type { Readable } from 'node:stream';
import type { HttpMethod } from 'router-tree-map';
import type { Type } from './annotations/controller.annotation.js';
import { ControllerDependencyCollector } from './annotations/controller.annotation.js';
import type { RouteMetadata, PathMap } from './route-resolve.js';
import type { Middleware, Ingress, NextFn, CoreContext } from '@ingress/core';
import type { Func } from './type-resolver.js';
export { ControllerDependencyCollector };
export { Route } from './annotations/route.annotation.js';
export type Pathname = string;
export type QueryString = string;
export declare function readUrl(path?: string): [Pathname, QueryString];
export declare class Router {
    private collector;
    metadata: Set<RouteMetadata>;
    registeredMetadata: Map<PathMap, RouteMetadata>;
    hasUpgrade: boolean;
    Controller: ControllerDependencyCollector;
    private map;
    private app;
    private _root;
    constructor({ routes }?: {
        routes?: Iterable<Type<any>>;
    });
    initializeContext(ctx: RouterContext): RouterContext;
    start(app: Ingress<any>, next: NextFn): Promise<{
        router: Router;
    }>;
    private typeResolver;
    registerTypeResolver(type: Type<any>, resolver: Func): this;
    registerTypePredicateResolver(predicate: Func<boolean>, resolver: Func): this;
    registerRouteClass(type: Type<any>): this;
    registerRouteMetadata(routeMetadata: RouteMetadata): this;
    on(method: HttpMethod, route: string, handle: Handle): Router;
    middleware(context: RouterContext, next: any): any;
}
export declare class RouteData {
    params: ParamEntries;
    exec: Handle;
    constructor(params: ParamEntries, exec: Handle);
}
export type Body = any;
export type ParamEntries = [string, string][];
export type Handle = Middleware<any>;
export interface RouterContext extends CoreContext {
    app: Ingress<RouterContext>;
    request: {
        method: string;
        body: any;
        pathname: string;
        searchParams: URLSearchParams;
        headers: Record<string, string | string[] | undefined>;
        parse(options: {
            mode: 'string';
        } & ParseOptions): Promise<string>;
        parse(options: {
            mode: 'buffer';
        } & ParseOptions): Promise<Buffer>;
        parse<T = any>(options: {
            mode: 'json';
        } & ParseOptions): Promise<T>;
        parse(options: {
            mode: 'stream';
        } & ParseOptions): Readable;
        toRequest(): Request;
    };
    response: {
        code: (code: number) => void;
    };
    route: RouteData | null;
}
export type ParseOptions = {
    sizeLimit?: number;
    deserializer?: <T>(body: string) => T | Promise<T>;
};