/// <reference types="node" />
/// <reference types="node" />
import { AsyncLocalStorage } from 'node:async_hooks';
import { Server } from 'node:http';
import { IHttpContext } from './context.js';
import { HttpRouter } from './index.js';
import { IViewEngine } from './view.js';
export declare class HttpApp {
    protected opts: IHttpAppOpts;
    protected asyncLocalStorage?: AsyncLocalStorage<any>;
    protected middlewares: HttpAppMiddleware[];
    protected composedMiddleware: any;
    protected _router: HttpRouter;
    protected viewProvider: IViewEngine | null;
    protected correlationIdCount: number;
    protected correlationIdGenerator: HttpCorrelationIdGenerator;
    protected errorListeners: never[];
    constructor(opts: IHttpAppOpts);
    getAsyncLocalStorage(): AsyncLocalStorage<any>;
    /**
     * application middleware
     * @param fn
     */
    use(fn: HttpAppMiddleware): void;
    /**
     * set view engine
     * @param provider
     */
    viewEngine(provider: IViewEngine): void;
    getRouter(): HttpRouter<import("./router/contracts.js").RouteHandlerCallback>;
    router(router: HttpRouter): void;
    router(prefix: string, router: HttpRouter): void;
    correlationIdProvider(provider: HttpCorrelationIdGenerator): void;
    handler(): (ctx: IHttpContext, next: any) => Promise<void>;
    listen(cb?: Function): Server;
    port(): string;
    host(): string;
    address(): string;
}
export interface IHttpAppOptUse {
    handler(fn: any): void;
    use(...args: any): any;
    listen(...args: any): Server;
}
export interface IHttpAppOptConf {
    get<T = any>(key: any): T | null;
    var(key: any): string | undefined;
    set<T = any>(key: any, value: T): T;
}
export interface IHttpAppOpts {
    use: IHttpAppOptUse;
    conf: IHttpAppOptConf;
    asyncLocalStorage?: boolean | AsyncLocalStorage<any>;
    host?: string;
    port?: number;
    defaultErrorMessage?: string;
    /**
     * set true, when you want to handle exception with framework instead of http app
     */
    dontHandleException?: boolean;
}
export interface IHttpMiddleware {
    handle(ctx: IHttpContext, next: any): Promise<any>;
}
export type HttpMiddlewareCallback = (ctx: IHttpContext, next: any) => Promise<any>;
export type HttpAppMiddleware = HttpMiddlewareCallback | IHttpMiddleware;
export type HttpCorrelationIdGenerator = () => {
    toString(): string;
};