import { ClassType, CustomError } from '@deepkit/core';
import { OutgoingHttpHeaders, ServerResponse } from 'http';
import { BaseEvent } from '@deepkit/event';
import { HttpRequest, HttpRequestPositionedParameters, HttpResponse } from './model.js';
import { Injector, InjectorContext, Setter } from '@deepkit/injector';
import { LoggerInterface } from '@deepkit/logger';
import { HttpRouter, RouteConfig, RouteParameterResolverForInjector } from './router.js';
import { WorkflowEvent } from '@deepkit/workflow';
import type { ElementStruct } from '@deepkit/template';
import { Stopwatch } from '@deepkit/stopwatch';
import { Type } from '@deepkit/type';
import stream from 'stream';
export declare function isElementStruct(v: any): v is ElementStruct;
export declare class Redirect {
    statusCode: number;
    routeName?: string;
    routeParameters?: {
        [name: string]: any;
    };
    url?: string;
    constructor(statusCode?: number);
    static toRoute(routeName: string, parameters?: {
        [name: string]: any;
    }, statusCode?: number): Redirect;
    static toUrl(url: string, statusCode?: number): Redirect;
}
export declare class HttpError<T extends number> extends CustomError {
    message: string;
    httpCode: T;
    constructor(message: string, httpCode: T);
}
export declare function createHttpError<T extends number>(code: T, defaultMessage?: string): ClassType<HttpError<T>>;
declare const HttpBadRequestError_base: ClassType<HttpError<400>>;
export declare class HttpBadRequestError extends HttpBadRequestError_base {
}
declare const HttpUnauthorizedError_base: ClassType<HttpError<401>>;
export declare class HttpUnauthorizedError extends HttpUnauthorizedError_base {
}
declare const HttpAccessDeniedError_base: ClassType<HttpError<403>>;
export declare class HttpAccessDeniedError extends HttpAccessDeniedError_base {
}
declare const HttpNotFoundError_base: ClassType<HttpError<404>>;
export declare class HttpNotFoundError extends HttpNotFoundError_base {
}
declare const HttpMethodNotAllowedError_base: ClassType<HttpError<405>>;
export declare class HttpMethodNotAllowedError extends HttpMethodNotAllowedError_base {
}
declare const HttpNotAcceptableError_base: ClassType<HttpError<406>>;
export declare class HttpNotAcceptableError extends HttpNotAcceptableError_base {
}
declare const HttpTimeoutError_base: ClassType<HttpError<408>>;
export declare class HttpTimeoutError extends HttpTimeoutError_base {
}
declare const HttpConflictError_base: ClassType<HttpError<409>>;
export declare class HttpConflictError extends HttpConflictError_base {
}
declare const HttpGoneError_base: ClassType<HttpError<410>>;
export declare class HttpGoneError extends HttpGoneError_base {
}
declare const HttpTooManyRequestsError_base: ClassType<HttpError<429>>;
export declare class HttpTooManyRequestsError extends HttpTooManyRequestsError_base {
}
declare const HttpInternalServerError_base: ClassType<HttpError<500>>;
export declare class HttpInternalServerError extends HttpInternalServerError_base {
}
declare const HttpNotImplementedError_base: ClassType<HttpError<501>>;
export declare class HttpNotImplementedError extends HttpNotImplementedError_base {
}
export declare class HttpWorkflowEvent extends BaseEvent {
    injectorContext: InjectorContext;
    request: HttpRequest;
    response: HttpResponse;
    nextState?: any;
    nextStateEvent?: any;
    clearNext(): void;
    /**
     * @see WorkflowNextEvent.next
     */
    next(nextState: string, event?: any): void;
    /**
     * Whether already a next workflow state has been scheduled.
     */
    hasNext(): boolean;
    constructor(injectorContext: InjectorContext, request: HttpRequest, response: HttpResponse);
    get url(): string;
    /**
     * Whether a response has already been sent.
     */
    get sent(): boolean;
    send(response: any): void;
}
export declare const HttpRequestEvent: typeof HttpWorkflowEvent;
export declare const HttpRouteNotFoundEvent: typeof HttpWorkflowEvent;
export declare class HttpWorkflowEventWithRoute extends HttpWorkflowEvent {
    injectorContext: InjectorContext;
    request: HttpRequest;
    response: HttpResponse;
    route: RouteConfig;
    constructor(injectorContext: InjectorContext, request: HttpRequest, response: HttpResponse, route: RouteConfig);
    send(response: any): void;
    accessDenied(error?: Error): void;
}
export declare class HttpRouteEvent extends HttpWorkflowEvent {
    injectorContext: InjectorContext;
    request: HttpRequest;
    response: HttpResponse;
    parameterResolver?: RouteParameterResolverForInjector | undefined;
    route?: RouteConfig | undefined;
    constructor(injectorContext: InjectorContext, request: HttpRequest, response: HttpResponse, parameterResolver?: RouteParameterResolverForInjector | undefined, route?: RouteConfig | undefined);
    routeFound(route: RouteConfig, parameterResolver: RouteParameterResolverForInjector): void;
    routeFoundCallback<T extends any[]>(callback: (...args: T) => void, args: T): void;
    notFound(): void;
}
export declare class HttpAuthEvent extends HttpWorkflowEventWithRoute {
    injectorContext: InjectorContext;
    request: HttpRequest;
    response: HttpResponse;
    route: RouteConfig;
    parameterResolver: RouteParameterResolverForInjector;
    constructor(injectorContext: InjectorContext, request: HttpRequest, response: HttpResponse, route: RouteConfig, parameterResolver: RouteParameterResolverForInjector);
    success(): void;
}
export declare class HttpAccessDeniedEvent extends HttpWorkflowEvent {
    injectorContext: InjectorContext;
    request: HttpRequest;
    response: HttpResponse;
    route: RouteConfig;
    error?: Error | undefined;
    constructor(injectorContext: InjectorContext, request: HttpRequest, response: HttpResponse, route: RouteConfig, error?: Error | undefined);
}
export declare class HttpResolveParametersEvent extends HttpWorkflowEventWithRoute {
    injectorContext: InjectorContext;
    request: HttpRequest;
    response: HttpResponse;
    parameterResolver: RouteParameterResolverForInjector;
    route: RouteConfig;
    parameters: HttpRequestPositionedParameters;
    constructor(injectorContext: InjectorContext, request: HttpRequest, response: HttpResponse, parameterResolver: RouteParameterResolverForInjector, route: RouteConfig);
    accessDenied(): void;
}
export declare class HttpControllerEvent extends HttpWorkflowEventWithRoute {
    injectorContext: InjectorContext;
    request: HttpRequest;
    response: HttpResponse;
    parameters: HttpRequestPositionedParameters;
    route: RouteConfig;
    constructor(injectorContext: InjectorContext, request: HttpRequest, response: HttpResponse, parameters: HttpRequestPositionedParameters | undefined, route: RouteConfig);
}
export declare class HttpResponseEvent extends WorkflowEvent {
    injectorContext: InjectorContext;
    request: HttpRequest;
    response: HttpResponse;
    result: any;
    route?: RouteConfig | undefined;
    /**
     * The time it took to call the controller action in milliseconds.
     */
    controllerActionTime: number;
    constructor(injectorContext: InjectorContext, request: HttpRequest, response: HttpResponse, result: any, route?: RouteConfig | undefined);
}
export declare class HttpControllerErrorEvent extends HttpWorkflowEventWithRoute {
    injectorContext: InjectorContext;
    request: HttpRequest;
    response: HttpResponse;
    route: RouteConfig;
    error: Error;
    /**
     * The time it took to call the controller action in milliseconds.
     */
    controllerActionTime: number;
    constructor(injectorContext: InjectorContext, request: HttpRequest, response: HttpResponse, route: RouteConfig, error: Error);
}
export declare const httpWorkflow: import("@deepkit/workflow").WorkflowDefinition<{
    start: typeof WorkflowEvent;
    request: typeof HttpWorkflowEvent;
    route: typeof HttpRouteEvent;
    routeNotFound: typeof HttpWorkflowEvent;
    auth: typeof HttpAuthEvent;
    resolveParameters: typeof HttpResolveParametersEvent;
    accessDenied: typeof HttpAccessDeniedEvent;
    controller: typeof HttpControllerEvent;
    controllerError: typeof HttpControllerErrorEvent;
    parametersFailed: typeof HttpControllerErrorEvent;
    response: typeof HttpResponseEvent;
}> & import("@deepkit/workflow").WorkflowDefinitionEvents<{
    start: typeof WorkflowEvent;
    request: typeof HttpWorkflowEvent;
    route: typeof HttpRouteEvent;
    routeNotFound: typeof HttpWorkflowEvent;
    auth: typeof HttpAuthEvent;
    resolveParameters: typeof HttpResolveParametersEvent;
    accessDenied: typeof HttpAccessDeniedEvent;
    controller: typeof HttpControllerEvent;
    controllerError: typeof HttpControllerErrorEvent;
    parametersFailed: typeof HttpControllerErrorEvent;
    response: typeof HttpResponseEvent;
}>;
export declare class BaseResponse {
    _statusCode?: number | undefined;
    _headers: OutgoingHttpHeaders;
    autoSerializing: boolean;
    constructor(_statusCode?: number | undefined, _headers?: OutgoingHttpHeaders);
    status(code: number): this;
    /**
     * Per default a JSONResponse is serialized using the return type specified at the route.
     * This disables that behaviour so that JSON.stringify is run on the result directly.
     */
    disableAutoSerializing(): this;
    header(name: string, value: string | number): this;
    headers(headers: OutgoingHttpHeaders): this;
    contentType(type: string): this;
}
export declare class Response extends BaseResponse {
    content: string | Uint8Array;
    constructor(content: string | Uint8Array, contentType: string, statusCode?: number);
}
export declare class HtmlResponse extends BaseResponse {
    html: string;
    constructor(html: string, statusCode?: number);
}
export declare class JSONResponse extends BaseResponse {
    json: any;
    constructor(json: any, statusCode?: number);
}
export type SupportedHttpResult = undefined | null | number | string | Response | JSONResponse | HtmlResponse | HttpResponse | ServerResponse | stream.Readable | Redirect | Uint8Array | Error;
export interface HttpResultFormatterContext {
    request: HttpRequest;
    response: HttpResponse;
    route?: RouteConfig;
}
export declare class HttpResultFormatter {
    protected router: HttpRouter;
    protected jsonContentType: string;
    protected htmlContentType: string;
    constructor(router: HttpRouter);
    protected setContentTypeIfNotSetAlready(response: HttpResponse, contentType: string): void;
    handleError(error: Error, context: HttpResultFormatterContext): void;
    handleUndefined(result: undefined | null, context: HttpResultFormatterContext): void;
    handleRedirect(result: Redirect, context: HttpResultFormatterContext): void;
    handleUnknown(result: any, context: HttpResultFormatterContext): void;
    handleHtmlResponse(result: HtmlResponse, context: HttpResultFormatterContext): void;
    handleGenericResponse(result: Response, context: HttpResultFormatterContext): void;
    handleJSONResponse(result: JSONResponse, context: HttpResultFormatterContext): void;
    handleTypeEntity<T>(classType: ClassType<T>, instance: T, context: HttpResultFormatterContext, route?: RouteConfig): void;
    handleType<T>(type: Type, instance: T, context: HttpResultFormatterContext, route?: RouteConfig): void;
    handleStream(stream: stream.Readable, context: HttpResultFormatterContext): void;
    handleBinary(result: Uint8Array, context: HttpResultFormatterContext): void;
    handleResponse(context: HttpResultFormatterContext): void;
    handle(result: SupportedHttpResult, context: HttpResultFormatterContext): void;
}
export declare class HttpListener {
    protected router: HttpRouter;
    protected logger: LoggerInterface;
    protected resultFormatter: HttpResultFormatter;
    protected injector: Injector;
    protected stopwatch: Stopwatch;
    protected setRouteConfig: Setter<RouteConfig>;
    constructor(router: HttpRouter, logger: LoggerInterface, resultFormatter: HttpResultFormatter, injector: Injector, stopwatch: Stopwatch);
    onRequest(event: typeof httpWorkflow.onRequest.event): void;
    onRoute(event: typeof httpWorkflow.onRoute.event): Promise<void>;
    onRouteForward(event: typeof httpWorkflow.onRoute.event): void;
    routeNotFound(event: typeof httpWorkflow.onRouteNotFound.event): Promise<void>;
    onAuth(event: typeof httpWorkflow.onAuth.event): void;
    onResolveParameters(event: typeof httpWorkflow.onResolveParameters.event): Promise<void>;
    onAccessDenied(event: typeof httpWorkflow.onAccessDenied.event): void;
    onController(event: typeof httpWorkflow.onController.event): Promise<void>;
    onParametersFailed(event: typeof httpWorkflow.onParametersFailed.event): void;
    onControllerError(event: typeof httpWorkflow.onControllerError.event): void;
    /**
     * This happens before the result is sent.
     */
    onResultSerialization(event: typeof httpWorkflow.onResponse.event): Promise<void>;
    onResponse(event: typeof httpWorkflow.onResponse.event): Promise<void>;
}
export {};
export declare type __ΩSupportedHttpResult = any[];
export declare type __ΩHttpResultFormatterContext = any[];