import http from "node:http";
import { getMimeType } from "@d3vtool/utils";
import { DerivedRouters, DynamicRouteInfo, HttpMethods, Router } from "./kaze-router";
import { KazeValidationError } from "./kaze-errors";
import { Cookie, CookieOptions, parseCookies } from "./kaze-cookies";
import { fileUpload, FileUploadOptions, KazeFile } from "./kaze-fileupload";
import { parseBody } from "./kaze-body";
import { TConstructor } from "./kaze-route-decorators";
interface KazeRequest<Query, Params, Body> extends http.IncomingMessage {
    secure: boolean;
    cookies?: Cookie;
    query?: Partial<Query>;
    params?: Partial<Params>;
    body?: Body;
    files?: KazeFile[];
}
interface KazeResponse extends Omit<http.ServerResponse, "statusCode" | "setHeader"> {
    send: (data: string) => void;
    statusCode: (code: number) => void;
    html: (htmlSource: string) => void;
    json: (jsonObj: Record<any, any>) => void;
    sendFile: (path: string) => Promise<void>;
    render: (file: string, data?: Record<string, any>) => Promise<void>;
    setHeader: http.ServerResponse["setHeader"];
    addHeader: (key: keyof http.IncomingHttpHeaders, value: string | string[]) => void;
    setCookie: (key: string, value: string, options: CookieOptions) => void;
}
export interface KazeContext<KazeDependencies = any, Query = any, Params = any, Body = any> {
    req: KazeRequest<Query, Params, Body>;
    res: KazeResponse;
    dependencies?: KazeDependencies;
}
export type KazeHttpMethod = "GET" | "POST" | "PUT" | "HEAD" | "PATCH" | "DELETE" | "TRACE" | "OPTIONS" | "CONNECT" | "LINK" | "UNLINK";
export type KazeRoute = string;
export type KazeNextFunction = () => void;
export type KazeRouteHandler = (ctx: KazeContext<any>, next: KazeNextFunction) => void | Promise<void>;
export type RouteMap = Map<KazeRoute, KazeRouteHandler[]>;
export type DynamicSegmentLength = number;
export type DynamicRouteMap = Map<DynamicSegmentLength, DynamicRouteInfo>;
export type RequestHandle = (request: http.IncomingMessage, response: http.ServerResponse) => void;
export type ErrorHandlerFn = (ctx: KazeContext<any>, error: unknown) => void | Promise<void>;
export type ValidationFailedFn = (ctx: KazeContext<any>, error: KazeValidationError) => void | Promise<void>;
export declare const AcceptedMethods: Set<KazeHttpMethod>;
export type StaticFile = {
    data: Buffer;
    mimeType: ReturnType<typeof getMimeType>;
};
export type KazeOptions<KazeDependencies> = {
    router?: DerivedRouters;
    class?: boolean;
    dependencies?: KazeDependencies;
};
export type ListenCallback = (err?: NodeJS.ErrnoException | null, address?: string | {
    address: string;
    family: string;
    port: number;
}) => void;
type HTMLSource = string;
export type KazeRendererContext = {
    filepath: string;
    renderEngineDirPath: string;
};
export type KazeRenderEngine = (rctx: KazeRendererContext, template: string, data?: Record<string, any>) => HTMLSource | Promise<HTMLSource>;
export type KazeRenderEngineOptions = {
    fileExtension: string;
};
export declare class Kaze<KazeDependencies> implements HttpMethods {
    #private;
    static routerClass: DerivedRouters;
    constructor(options?: KazeOptions<KazeDependencies>);
    static Router(router?: DerivedRouters): Router;
    static parseCookie(): typeof parseCookies;
    static parseBody(): ReturnType<typeof parseBody>;
    static fileUpload(options?: FileUploadOptions): ReturnType<typeof fileUpload>;
    static(directoryPath: string): void;
    renderEngine(engine: KazeRenderEngine, directoryPath: string, options: KazeRenderEngineOptions): void;
    addGlobalMiddleware(middleware: KazeRouteHandler | KazeRouteHandler[]): void;
    globalErrorHandler(fn: ErrorHandlerFn): void;
    globalVErrorHandler(fn: ValidationFailedFn): void;
    get(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    post(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    put(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    delete(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    patch(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    head(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    options(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    trace(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    connect(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    link(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    unlink(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    all(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    routeGrp(parentRoute: KazeRoute, router: Router): void;
    controller(controller: TConstructor): void;
    getHandle(isHttps: boolean): RequestHandle;
    port(): number;
    close(): void;
    listen(port: number, listeningListener?: ListenCallback): void;
}
export {};