import { ClassType, CompilerContext } from '@deepkit/core';
import { ReflectionFunction, ReflectionParameter, SerializationOptions, Serializer, Type } from '@deepkit/type';
import { HttpDecorator } from './decorator.js';
import { HttpRequest, HttpRequestPositionedParameters, HttpRequestQuery, HttpRequestResolvedParameters } from './model.js';
import { InjectorContext, InjectorModule } from '@deepkit/injector';
import { LoggerInterface } from '@deepkit/logger';
import { HttpControllers } from './controllers.js';
import { MiddlewareRegistry } from '@deepkit/app';
import { HttpMiddlewareConfig, HttpMiddlewareFn } from './middleware.js';
import { ParameterForRequestParser } from './request-parser.js';
import { HttpConfig } from './module.config.js';
export type RouteParameterResolverForInjector = ((injector: InjectorContext) => HttpRequestPositionedParameters | Promise<HttpRequestPositionedParameters>);
interface ResolvedController {
    parameters: RouteParameterResolverForInjector;
    routeConfig: RouteConfig;
    uploadedFiles: {
        [name: string]: UploadedFile;
    };
    middlewares?: (injector: InjectorContext) => {
        fn: HttpMiddlewareFn;
        timeout?: number;
    }[];
}
export declare const UploadedFileSymbol: unique symbol;
export declare class UploadedFile {
    /**
     * Validator to ensure the file was provided by the framework, and not the user spoofing it.
     */
    validator: typeof UploadedFileSymbol | null;
    /**
     * The size of the uploaded file in bytes.
     */
    size: number;
    /**
     * The local path this file is being written to. Will be deleted when request is handled.
     */
    path: string;
    /**
     * The name this file had according to the uploading client.
     */
    name: string | null;
    /**
     * The mime type of this file, according to the uploading client.
     */
    type: string | null;
    /**
     * A Date object (or `null`) containing the time this file was last written to.
     * Mostly here for compatibility with the [W3C File API Draft](http://dev.w3.org/2006/webapi/FileAPI/).
     */
    lastModifiedDate: Date | null;
}
export interface RouteFunctionControllerAction {
    type: 'function';
    module?: InjectorModule<any>;
    fn: (...args: any[]) => any;
}
export interface RouteClassControllerAction {
    type: 'controller';
    module?: InjectorModule<any>;
    controller: ClassType;
    methodName: string;
}
export declare function getRouteActionLabel(action: RouteClassControllerAction | RouteFunctionControllerAction): string;
export declare class RouteConfig {
    readonly name: string;
    readonly httpMethods: string[];
    readonly path: string;
    readonly action: RouteClassControllerAction | RouteFunctionControllerAction;
    internal: boolean;
    baseUrl: string;
    responses: {
        statusCode: number;
        description: string;
        type?: Type;
    }[];
    description: string;
    groups: string[];
    category: string;
    returnType?: Type;
    serializationOptions?: SerializationOptions;
    serializer?: Serializer;
    /**
     * When assigned defines where this route came from.
     */
    module?: InjectorModule<any>;
    resolverForToken: Map<any, ClassType>;
    middlewares: {
        config: HttpMiddlewareConfig;
        module?: InjectorModule<any>;
    }[];
    resolverForParameterName: Map<string, ClassType>;
    /**
     * An arbitrary data container the user can use to store app specific settings/values.
     */
    data: Map<any, any>;
    constructor(name: string, httpMethods: string[], path: string, action: RouteClassControllerAction | RouteFunctionControllerAction, internal?: boolean);
    getReflectionFunction(): ReflectionFunction;
    getSchemaForResponse(statusCode: number): Type | undefined;
    getFullPath(): string;
}
export declare class ParsedRoute {
    routeConfig: RouteConfig;
    regex?: string;
    pathParameterNames: {
        [name: string]: number;
    };
    protected parameters: ParameterForRequestParser[];
    constructor(routeConfig: RouteConfig);
    addParameter(property: ReflectionParameter): ParameterForRequestParser;
    getParameters(): ParameterForRequestParser[];
    getParameter(name: string): ParameterForRequestParser;
}
export declare function parseRouteControllerAction(routeConfig: RouteConfig): ParsedRoute;
export declare function dotToUrlPath(dotPath: string): string;
export interface RouteParameterResolver {
    resolve(context: RouteParameterResolverContext): any | Promise<any>;
}
export interface RouteParameterResolverContext {
    token: ClassType | string | symbol | any;
    route: RouteConfig;
    request: HttpRequest;
    /**
     * The parameter name (variable name).
     */
    name: any;
    /**
     * The raw parameter value from the path, if the parameter is defined in the path (e.g. /user/:name).
     * If not in the path, you have to use `parameters.<name>` instead.
     */
    value: any;
    query: HttpRequestQuery;
    parameters: HttpRequestResolvedParameters;
    type: ReflectionParameter;
}
export interface HttpRouterFunctionOptions {
    path: string;
    name?: string;
    methods?: string[];
    description?: string;
    category?: string;
    groups?: string[];
    /**
     * An arbitrary data container the user can use to store app specific settings/values.
     */
    data?: Record<any, any>;
    baseUrl?: string;
    middlewares?: (() => HttpMiddlewareConfig)[];
    serializer?: Serializer;
    serializationOptions?: SerializationOptions;
    resolverForToken?: Map<any, ClassType>;
    resolverForParameterName?: Map<string, ClassType>;
    responses?: {
        statusCode: number;
        description: string;
        type?: Type;
    }[];
}
export declare abstract class HttpRouterRegistryFunctionRegistrar {
    protected defaultOptions: Partial<HttpRouterFunctionOptions>;
    abstract addRoute(routeConfig: RouteConfig): void;
    /**
     * Returns a new registrar object with default options that apply to each registered route through this registrar.
     *
     * ```typescript
     * const registry: HttpRouterRegistry = ...;
     *
     * const secretRegistry = registry.forOptions({groups: ['secret']});
     *
     * secretRegistry.get('/admin/groups', () => {
     * });
     *
     * secretRegistry.get('/admin/users', () => {
     * });
     * ```
     */
    forOptions(options: Partial<HttpRouterFunctionOptions>): HttpRouterRegistryFunctionRegistrar;
    any(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
    add(decorator: HttpDecorator, callback: (...args: any[]) => any): void;
    get(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
    post(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
    put(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
    patch(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
    delete(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
    options(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
    trace(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
    head(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
    redirectCallback(pathOrOptions: string | HttpRouterFunctionOptions, callback: (request: HttpRequest) => string, redirectCode?: number): void;
    private register;
}
export declare class HttpRouterRegistry extends HttpRouterRegistryFunctionRegistrar {
    protected routes: RouteConfig[];
    private buildId;
    getBuildId(): number;
    getRoutes(): RouteConfig[];
    addRouteForController(controller: ClassType, module: InjectorModule<any>): void;
    addRoute(routeConfig: RouteConfig): void;
}
export declare class HttpRouter {
    private logger;
    private config;
    private middlewareRegistry;
    private registry;
    protected fn?: (request: HttpRequest) => ResolvedController | undefined;
    protected buildId: number;
    protected resolveFn?: (name: string, parameters: {
        [name: string]: any;
    }) => string;
    constructor(controllers: HttpControllers, logger: LoggerInterface, config: HttpConfig, middlewareRegistry?: MiddlewareRegistry, registry?: HttpRouterRegistry);
    getRoutes(): RouteConfig[];
    static forControllers(controllers: (ClassType | {
        module: InjectorModule<any>;
        controller: ClassType;
    })[], middlewareRegistry?: MiddlewareRegistry, module?: InjectorModule<any>, config?: HttpConfig): HttpRouter;
    protected getRouteCode(compiler: CompilerContext, routeConfig: RouteConfig): string;
    protected getRouteUrlResolveCode(compiler: CompilerContext, routeConfig: RouteConfig): string;
    addRoute(routeConfig: RouteConfig): void;
    addRouteForController(controller: ClassType, module: InjectorModule<any>): void;
    protected build(): (request: HttpRequest) => ResolvedController | undefined;
    protected buildUrlResolver(): any;
    resolveUrl(routeName: string, parameters?: {
        [name: string]: any;
    }): string;
    resolveRequest(request: HttpRequest): ResolvedController | undefined;
    resolve(method: string, url: string): ResolvedController | undefined;
}
export {};
export declare type __ΩRouteParameterResolverForInjector = any[];
export declare type __ΩRouteFunctionControllerAction = any[];
export declare type __ΩRouteClassControllerAction = any[];
export declare type __ΩRouteParameterResolver = any[];
export declare type __ΩRouteParameterResolverContext = any[];
export declare type __ΩHttpRouterFunctionOptions = any[];