import { HttpMessage, HttpRequest, HttpResponse } from "@http4t/core/contract";
import { Failure, Result } from "@http4t/result";
import { JsonPath, Problem } from "@http4t/result/JsonPathResult";
export declare const WRONG_ROUTE = "wrong-route";
export declare const ROUTE_FAILED = "route-failed";
/**
 * This was the wrong route- usually because either the url or method did not match.
 *
 * The Router should continue looking for a matching route
 */
export type WrongRoute = {
    readonly type: typeof WRONG_ROUTE;
    readonly problems: Problem[];
};
/**
 * This was the right route to handle the request, but the request is not valid for this route (e.g. the url and method
 * matched but the body is not valid json)
 *
 * The Router should not consider any more routes, and should return the provided response to the user
 */
export type RouteFailed = {
    readonly type: typeof ROUTE_FAILED;
    readonly problems: Problem[];
    readonly response: HttpResponse;
};
export type RoutingError = WrongRoute | RouteFailed;
export type RoutingResult<T = unknown> = Result<RoutingError, T>;
export declare function wrongRouteError(message: string, path?: (string | number)[]): WrongRoute;
export declare function wrongRoute(message: string, path: JsonPath): Failure<RoutingError>;
export declare function routeFailedError(message: string, path: JsonPath, response: HttpResponse): RouteFailed;
export declare function routeFailed(message: string, path: JsonPath, response?: HttpResponse): Failure<RoutingError>;
/**
 * A lens is something that, for example, knows:
 *
 * - How to both extract a named header from an http request, and how to add it
 *
 * - Or how to deserialize a request body into an object, and how to serialize
 *   the same type of object, and put it into a request body
 *
 * It's useful because the same lens can be used on the client side to
 * inject the header or body into the request, and on the server side to
 * read out the header, or deserialise the body.
 *
 * By using the same lenses to:
 *
 * - Create requests in the client and to parse them on the server
 * - Create responses on the server and parse them on the client
 *
 * ...we ensure that the server and client always understand one another
 */
export interface MessageLens<TMessage extends HttpMessage = HttpMessage, T = unknown> {
    get(from: TMessage): Promise<RoutingResult<T>>;
    set<SetInto extends TMessage>(into: SetInto, value: T): Promise<SetInto>;
}
export interface RequestLens<T = unknown> extends MessageLens<HttpRequest, T> {
}
export declare abstract class BaseRequestLens<T = unknown> implements RequestLens<T> {
    abstract get(from: HttpRequest): Promise<RoutingResult<T>>;
    set<SetInto extends HttpRequest>(into: SetInto, value: T): Promise<SetInto>;
    abstract setRequest(into: HttpRequest, value: T): Promise<HttpRequest>;
}
export interface ResponseLens<T = unknown> extends MessageLens<HttpResponse, T> {
}
export declare abstract class BaseResponseLens<T = unknown> implements ResponseLens<T> {
    abstract get(from: HttpResponse): Promise<RoutingResult<T>>;
    set<SetInto extends HttpResponse>(into: SetInto, value: T): Promise<SetInto>;
    abstract setResponse(into: HttpResponse, value: T): Promise<HttpResponse>;
}
//# sourceMappingURL=lenses.d.ts.map