/// <reference types="node" />
import type { HttpConnection } from './HttpConnection';
import type { HttpResponseCompleted } from './HttpResponse';
import type { HttpMethod } from './utils';
import type { Has } from '@principia/base/Has';
import type { FIO, IO } from '@principia/base/IO';
import type { URL } from 'url';
import * as Ev from '@principia/base/Eval';
import * as FR from '@principia/base/FiberRef';
import * as FL from '@principia/base/FreeList';
import { HttpException } from './HttpException';
export declare type RouteFn<R, E> = (conn: HttpConnection, next: FIO<E, HttpResponseCompleted>) => IO<R, E, HttpResponseCompleted>;
export declare class Empty<R, E> {
    readonly R: (_: R) => void;
    readonly E: () => E;
    readonly _tag = "Empty";
}
export declare class Route<R, E> {
    readonly method: HttpMethod;
    readonly path: string;
    readonly route: RouteFn<R, any>;
    readonly middlewares: FL.FreeList<Middleware<any, any>>;
    readonly _tag = "Route";
    readonly R: (_: R) => void;
    readonly E: () => E;
    readonly match: (method: HttpMethod, url: URL) => boolean;
    constructor(method: HttpMethod, path: string, route: RouteFn<R, any>, middlewares?: FL.FreeList<Middleware<any, any>>);
    middleware<R1 extends R = R, E1 extends E = E>(): ReadonlyArray<Middleware<R1, E1>>;
}
export declare class Combine<R, E> {
    readonly left: Routes<R, E>;
    readonly right: Routes<R, E>;
    readonly _tag = "Combine";
    constructor(left: Routes<R, E>, right: Routes<R, E>);
}
export declare type Routes<R, E> = Route<R, E> | Combine<R, E> | Empty<R, E>;
export declare type MiddlewareFn<R, E> = (cont: RouteFn<R, E>) => (conn: HttpConnection, next: FIO<E, HttpResponseCompleted>) => IO<R, E, any>;
export declare class Middleware<R, E> {
    readonly apply: MiddlewareFn<R, E>;
    constructor(apply: MiddlewareFn<R, E>);
}
export declare const empty: Routes<unknown, never>;
export declare function _route<R, E, R1, E1>(method: HttpMethod, path: string, handler: (conn: HttpConnection, n: IO<R, E, HttpResponseCompleted>) => IO<Has<HttpConnection> & R1, E1, HttpResponseCompleted>): (routes: Routes<R, E>) => Routes<R1, E1>;
export declare function route<R, E>(method: HttpMethod, path: string, handler: (conn: HttpConnection) => IO<Has<HttpConnection> & R, E, HttpResponseCompleted>): <R0, E0>(routes: Routes<R0, E0>) => Routes<R & R0, E | E0>;
export declare function middlewareSafe<R, E, R1, E1>(routes: Routes<R, E>, middle: (cont: RouteFn<R, E>) => (conn: HttpConnection, next: FIO<E, HttpResponseCompleted>) => IO<R1, E1, any>): Ev.Eval<Routes<R1, E1>>;
export declare function middleware_<R, E, R1, E1>(routes: Routes<R, E>, middle: (cont: RouteFn<R, E>) => (conn: HttpConnection, next: FIO<E, HttpResponseCompleted>) => IO<R1, E1, any>): Routes<R1, E1>;
export declare function HttpExceptionHandler<R, E>(routes: Routes<R, E>): Routes<R, Exclude<E, HttpException>>;
export declare const isRouterDraining: FR.Runtime<boolean>;
export declare function drain<R>(rs: Routes<R, never>): IO<Has<import("./HttpServer").HttpServer> & R, never, never>;
//# sourceMappingURL=Route.d.ts.map