import { MakeOptions, Maker, ValidationError } from './make';
export type { RedirectStatus } from './redirect';
export interface Response<Status extends number, ContentType, Value, Headers extends Record<string, any>> {
    status: Status;
    value: {
        contentType: ContentType;
        value: Value;
    };
    headers: Headers;
}
export interface RequestBody<A> {
    contentType: string;
    value: A;
}
export type Params = object;
export type Headers = object;
export type Query = object;
export type RequestContext = any;
export interface EndpointArg<H extends Headers | void, P extends Params | void, Q extends Query | void, Body extends RequestBody<any> | void> {
    path: string;
    method: Methods;
    servers: string[];
    op?: string;
    headers: H;
    params: P;
    query: Q;
    body: Body;
    signal?: AbortSignal;
}
export type ServerEndpointArg<H extends Headers | void, P extends Params | void, Q extends Query | void, Body extends RequestBody<any> | void, RC extends RequestContext> = EndpointArg<H, P, Q, Body> & {
    readonly requestContext: RC;
    readonly signal?: AbortSignal;
};
export type Endpoint<H extends Headers | void, P extends Params | void, Q extends Query | void, Body extends RequestBody<any> | void, R extends Response<number, any, any, Record<string, any>>, RC extends RequestContext> = (ctx: ServerEndpointArg<H, P, Q, Body, RC>) => Promise<R>;
export type SafeEndpoint = Endpoint<Headers | undefined, Params | undefined, Query | undefined, RequestBody<any> | undefined, Response<number, any, any, Record<string, any>>, RequestContext>;
export interface MethodHandlers {
    get?: SafeEndpoint;
    post?: SafeEndpoint;
    put?: SafeEndpoint;
    delete?: SafeEndpoint;
    patch?: SafeEndpoint;
    options?: SafeEndpoint;
    head?: SafeEndpoint;
}
export interface Endpoints {
    [opOrUrl: string]: MethodHandlers;
}
export declare class RequestValidationError extends Error {
    tag: string;
    errors: ValidationError[];
    readonly name = "RequestValidationError";
    constructor(tag: string, errors: ValidationError[]);
}
export declare class ResponseValidationError extends Error {
    tag: string;
    originalResponse: any;
    errors: ValidationError[];
    readonly name = "ResponseValidationError";
    constructor(tag: string, originalResponse: any, errors: ValidationError[]);
}
export declare function safe<H extends Headers, P extends Params, Q extends Query, Body extends RequestBody<any>, R extends Response<any, any, any, Record<string, any>>, RC extends RequestContext>(headers: Maker<any, H>, params: Maker<any, P>, query: Maker<any, Q>, body: Maker<any, Body>, response: Maker<any, R>, endpoint: Endpoint<H, P, Q, Body, R, RC>, { validationOptions, mode }?: HandlerOptions & InternalHandlerOptions): Endpoint<Headers, Params, Query, RequestBody<any>, Response<number, any, any, Record<string, any>>, RequestContext>;
export type Methods = keyof MethodHandlers;
export declare const supportedMethods: Methods[];
type AnyMaker = Maker<any, any>;
export interface Handler {
    op?: string;
    path: string;
    servers: string[];
    method: Methods;
    headers: AnyMaker;
    query: AnyMaker;
    body: AnyMaker;
    params: AnyMaker;
    response: AnyMaker;
}
export type HandlerFactory<Spec> = (adapter: ServerAdapter) => (spec: Spec) => void;
export declare function assertMethod(method: string): Methods;
export type ServerAdapter = (path: string, op: string, method: Methods, handler: SafeEndpoint, servers: string[]) => void;
type Mode = 'client' | 'server';
export interface InternalHandlerOptions {
    /** whether we are calling this on client side or in server side.
     * This may have effect on eg network <-> ts property mapping.
     * This value is set automatically by oats.
     * */
    mode: Mode;
}
export interface HandlerOptions {
    /**
     * Options for request schema validation.
     */
    validationOptions?: {
        query?: MakeOptions;
        params?: MakeOptions;
        body?: MakeOptions;
    };
}
export declare function createHandlerFactory<Spec extends Record<string, any>>(handlers: Handler[], opts?: HandlerOptions): HandlerFactory<Spec>;