import { ParserInterface, Schema, InferSchema } from "@miqro/parser";
import { SerializeOptions as CookieSerializeOptions } from "cookie";
import { IncomingMessage, OutgoingHttpHeaders, ServerResponse } from "node:http";
import { Socket } from "node:net";
import { Duplex } from "node:stream";
import { Logger } from "./common.js";
/**
 * Types
 */
export interface LoggerErrorEventInit {
    bubbles?: boolean;
    cancelable?: boolean;
    composed?: boolean;
    error: any;
}
export declare class LoggerErrorEvent extends Event {
    error: any;
    constructor(event: string, init: LoggerErrorEventInit);
}
export type LogLevel = "error" | "warn" | "info" | "debug" | "trace" | "none";
export interface WriteArgs {
    level: LogLevel;
    message?: any;
    identifier: string;
    optionalParams: any[];
    meta: any[];
}
export interface LoggerTransportWriteArgs extends WriteArgs {
    out: string;
}
export interface LoggerTransport {
    level?: LogLevel;
    write(args: LoggerTransportWriteArgs): Promise<void> | void;
}
export type LoggerFormatter = (args: WriteArgs) => string;
export interface MinimalLogger {
    log(message?: any, ...optionalParams: any[]): void;
    info(message?: any, ...optionalParams: any[]): void;
    trace(message?: any, ...optionalParams: any[]): void;
    debug(message?: any, ...optionalParams: any[]): void;
    warn(message?: any, ...optionalParams: any[]): void;
    error(message?: any, ...optionalParams: any[]): void;
}
export type ConfigOutput = {
    [name: string]: string;
};
export interface LoadConfigOut {
    combined: ConfigOutput;
    outputs: ConfigOutput[];
}
export interface LoggerFactoryArgs {
    identifier: string;
    level: LogLevel;
    options?: {
        transports?: LoggerTransport[];
        formatter?: LoggerFormatter;
    };
}
export type LoggerFactory = (args: LoggerFactoryArgs) => Logger;
export declare const GroupPolicySchema: Schema<GroupPolicy>;
export interface SessionHandlerOptions {
    authService: {
        verify(args: {
            token?: string | null;
            req: Request;
            res: Response;
        }): Promise<Session | null>;
    };
    options?: SessionHandlerOptionsOptions;
}
export interface SessionHandlerOptionsOptions {
    tokenLocation: "header" | "query" | "cookie" | "free";
    tokenLocationName?: string | ((req: Request) => Promise<string>);
    setCookieOptions?: {
        httpOnly: boolean;
        secure: boolean;
        path: string | ((req: Request) => Promise<string>);
        sameSite: "lax" | "strict" | "none";
    };
}
export declare const SessionHandlerOptionsOptionsSchema: Schema<SessionHandlerOptionsOptions>;
export declare const SessionHandlerOptionsSchema: Schema<SessionHandlerOptions>;
type Dict<T = any> = {
    [key: string]: T;
};
export interface NoTokenSession extends Dict {
    account: string;
    username: string;
    groups: string[];
}
export interface Session extends NoTokenSession {
    token: string;
}
export type GroupPolicyType = "at_least_one" | "all";
export type GroupPolicyGroups = string | string[];
export interface GroupPolicy {
    groups: GroupPolicyGroups[];
    groupPolicy: GroupPolicyType;
}
export type Method = "get" | "post" | "put" | "delete" | "patch" | "options" | "head" | "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
export interface HandlerResponse {
    status?: number;
    headers?: OutgoingHttpHeaders;
    body?: any;
}
export type Handler<T = boolean | void | HandlerResponse> = ((req: Request, res: Response) => Promise<T>) | ((req: Request, res: Response) => T);
export type ErrorHandler<T = boolean | void | any> = ((e: unknown, req: Request, res: Response) => Promise<T>) | ((e: unknown, req: Request, res: Response) => T);
export type SchemaProperties = {
    [key: string]: Schema | string;
};
export type ParserMode = "remove_extra" | "add_extra" | "no_extra";
export declare const RouteOptionsSchema: Schema<RouteOptions>;
export interface RouteOptions<TBody extends SchemaProperties | string | boolean | undefined = undefined, TParams extends SchemaProperties | string | boolean | undefined = undefined, TQuery extends SchemaProperties | string | boolean | undefined = undefined> {
    name?: string;
    identifier?: string;
    apiName?: string;
    description?: string;
    policy?: GroupPolicy;
    request?: {
        body?: TBody;
        params?: TParams;
        query?: TQuery;
        bodyMode?: ParserMode;
        queryMode?: ParserMode;
        paramsMode?: ParserMode;
        headers?: string | SchemaProperties[] | SchemaProperties;
        headersMode?: ParserMode;
    };
    response?: {
        etag?: boolean | (() => Promise<string> | string);
        status?: number | number[];
        headers?: string | SchemaProperties | SchemaProperties[];
        headersMode?: ParserMode;
        body?: boolean | string | SchemaProperties | SchemaProperties[];
        bodyMode?: ParserMode;
        middleware?: Handler | Handler[];
    } | boolean;
}
export interface RouteJSONDoc extends RouteOptions {
    identifier: string;
}
export interface RouterJSONDoc {
    [path: string]: {
        [method: string]: RouteJSONDoc[];
    };
}
export declare const RouterHandlerOptionsSchema: Schema<RouterHandlerOptions>;
export interface RouterHandlerOptions<TBody extends SchemaProperties | string | boolean | undefined = undefined, TParams extends SchemaProperties | string | boolean | undefined = undefined, TQuery extends SchemaProperties | string | boolean | undefined = undefined> extends RouteOptions<TBody, TParams, TQuery> {
    parser?: ParserInterface;
    middleware?: Handler | Handler[];
    session?: SessionHandlerOptions | Handler;
}
/**
 * Infer the TypeScript type produced by a request-part schema (body / params / query).
 * - string shorthand  → `InferSchema<T>`
 * - plain properties object `{ name: "string", age: "integer" }` → object with inferred fields
 * - `boolean | undefined` → `any` (pass-through, no type enforcement)
 */
export type InferRequestPart<T> = [
    T
] extends [boolean | undefined | null] ? any : [
    T
] extends [string] ? InferSchema<T & string> : T extends SchemaProperties ? InferSchema<{
    type: "object";
    properties: T;
}> : any;
/**
 * A `Request` narrowed to the typed `body`, `params`, and `query` shapes inferred
 * from the schemas declared on a route's `request` option.
 */
export type TypedRequest<TBody = any, TParams = any, TQuery = any, BaseRequest extends Request = Request> = Omit<BaseRequest, "body" | "params" | "query"> & {
    body?: TBody;
    params: TParams;
    query: TQuery;
};
export declare const HandlerWithOptionsSchema: Schema<HandlerWithOptions>;
export interface HandlerWithOptions<TBody extends SchemaProperties | string | boolean | undefined = undefined, TParams extends SchemaProperties | string | boolean | undefined = undefined, TQuery extends SchemaProperties | string | boolean | undefined = undefined, BaseRequest extends Request = Request> extends RouterHandlerOptions<TBody, TParams, TQuery> {
    handler: ((req: TypedRequest<InferRequestPart<TBody>, InferRequestPart<TParams>, InferRequestPart<TQuery>, BaseRequest>, res: Response) => Promise<boolean | void | HandlerResponse>) | ((req: TypedRequest<InferRequestPart<TBody>, InferRequestPart<TParams>, InferRequestPart<TQuery>, BaseRequest>, res: Response) => boolean | void | HandlerResponse) | Array<Handler>;
}
export interface RouterOptions {
    loggerFactory?: (uuid: string, req: Request) => MinimalLogger;
    etag?: boolean | ((lastResult?: {
        headers?: any;
        body?: any;
        status?: any;
    }) => Promise<string | false | null | undefined> | string | false | null | undefined);
}
export interface MinimalRouter {
    run: (req: Request, res: Response, pathTokens?: PathPart[], prePathTokens?: PathPartToken[]) => Promise<boolean>;
    getJSONDoc: (doc?: RouterJSONDoc, prePath?: string) => RouterJSONDoc;
}
export declare const MinimalRouterSchema: Schema<MinimalRouter>;
export declare function isMinimalRouter(obj: any): boolean;
/**
 * # APIRoute
 *
 * src/api/comment/get.js
 * ```typescript
 *import { APIRouter } from "@miqro/core";
 *const route: APIRoute = {
 *  ...
 *};
 *export default route;
 * ```
 *
 * Use the type parameters to get typed `req.body`, `req.params`, and `req.query`
 * in the handler. Use `defineRoute()` for automatic schema inference.
 */
export interface APIRoute<BaseRequest extends Request = Request, TBody extends SchemaProperties | string | boolean | undefined = undefined, TParams extends SchemaProperties | string | boolean | undefined = undefined, TQuery extends SchemaProperties | string | boolean | undefined = undefined> extends Omit<RouterHandlerOptions, "request"> {
    postFolder?: boolean;
    basePath?: string;
    method?: Method[] | Method | "use" | "USE";
    path?: string[] | string | null;
    ignore?: boolean;
    request?: {
        body?: TBody;
        params?: TParams;
        query?: TQuery;
        bodyMode?: ParserMode;
        queryMode?: ParserMode;
        paramsMode?: ParserMode;
        headers?: string | SchemaProperties[] | SchemaProperties;
        headersMode?: ParserMode;
    };
    handler: ((req: TypedRequest<InferRequestPart<TBody>, InferRequestPart<TParams>, InferRequestPart<TQuery>, BaseRequest>, res: Response) => Promise<boolean | void | HandlerResponse>) | ((req: TypedRequest<InferRequestPart<TBody>, InferRequestPart<TParams>, InferRequestPart<TQuery>, BaseRequest>, res: Response) => boolean | void | HandlerResponse) | Array<Handler> | MinimalRouter;
    init?: (route: APIRoute) => Promise<void>;
}
/**
 * Type-safe factory for file-based API routes (`export default`).
 *
 * Wrap your route object so TypeScript automatically infers `req.body`,
 * `req.params`, and `req.query` from the schemas in `request`.
 *
 * @example
 * export default defineRoute({
 *   request: { body: { name: "string", age: "integer" } },
 *   handler: async (req) => {
 *     req.body.name; // string
 *     req.body.age;  // number
 *   }
 * });
 */
export declare function defineRoute<BaseRequest extends Request = Request, const TBody extends SchemaProperties | string | boolean | undefined = undefined, const TParams extends SchemaProperties | string | boolean | undefined = undefined, const TQuery extends SchemaProperties | string | boolean | undefined = undefined>(route: APIRoute<BaseRequest, TBody, TParams, TQuery>): APIRoute<BaseRequest, TBody, TParams, TQuery>;
export interface APIRouterOptions {
    dirname: string;
    apiName?: string;
    path?: string;
    ignore?: Array<string | RegExp>;
    loader?: (path: string) => Promise<any>;
    extensions?: string[];
}
export declare const APIRouterOptionsSchema: Schema<APIRouterOptions>;
export declare const APIRouteSchema: Schema<APIRoute>;
export interface Request extends IncomingMessage {
    startMS: number;
    logger: MinimalLogger;
    session?: Session;
    uuid: string;
    path: string;
    hash: string;
    cookies: {
        [name: string]: string;
    };
    params: {
        [name: string]: string | undefined;
    };
    buffer?: Buffer;
    query: {
        [name: string]: string | string[];
    };
    results: any[];
    body?: any;
}
export declare class Request extends IncomingMessage implements Request {
    startMS: number;
    body?: any;
    logger: MinimalLogger;
    uuid: string;
    path: string;
    hash: string;
    searchParams: URLSearchParams;
    cookies: {
        [name: string]: string;
    };
    params: {
        [name: string]: string | undefined;
    };
    buffer?: Buffer;
    query: {
        [name: string]: string | string[];
    };
    results: any[];
    constructor(socket: Socket);
}
export interface Response<Request extends IncomingMessage = IncomingMessage> extends ServerResponse<Request> {
    asyncClose(): Promise<void>;
    asyncEnd(args?: {
        body?: any;
        status?: number;
        headers?: OutgoingHttpHeaders;
    }): Promise<void>;
    asyncWrite(chunk: any): Promise<void>;
    json(body: any, headers?: OutgoingHttpHeaders, status?: number): Promise<void>;
    addVaryHeader(value: number | string | ReadonlyArray<string>): ServerResponse;
    setCookie(name: string, value: string, options?: CookieSerializeOptions): ServerResponse;
    html(html: string, headers?: OutgoingHttpHeaders, status?: number): Promise<void>;
    css(css: string, headers?: OutgoingHttpHeaders, status?: number): Promise<void>;
    js(js: string, headers?: OutgoingHttpHeaders, status?: number): Promise<void>;
    text(text: string, headers?: OutgoingHttpHeaders, status?: number): Promise<void>;
    redirect(url: string, headers?: OutgoingHttpHeaders, status?: number): Promise<void>;
}
export declare class Response<Request extends IncomingMessage = IncomingMessage> extends ServerResponse<Request> implements Response<Request> {
    static IGNORE_HEADER: string[];
    useETag: boolean | ((lastResult?: {
        headers?: any;
        body?: any;
        status?: any;
    }) => Promise<string | false | null | undefined> | string | false | null | undefined);
    constructor(req: Request);
    setETag(useETag: boolean | ((lastResult?: {
        headers?: any;
        body?: any;
        status?: any;
    }) => Promise<string | false | null | undefined> | string | false | null | undefined)): void;
}
export interface PathParams {
    [name: string]: string | undefined;
}
export interface PathPartToken extends PathPart {
    optional: boolean;
    wild?: string;
}
export interface PathPart {
    value: string;
    lower: string;
}
export declare const splitPath: (path?: string) => PathPart[];
export declare function tokenizePath(path?: string): PathPartToken[];
export declare function matchTokenizePath(checkAsRouter: boolean, pathTokens: PathPartToken[], requestParts: PathPart[]): {
    match: boolean;
    params?: {
        [name: string]: string | undefined;
    };
};
export declare function newURL(input: string): URL;
/**
 *
 * @param input a url.pathname
 * @returns the pathname ignoring start slashes for example if sended "///page/hi" will return /page/hi
 */
export declare function removeStartingBackSlashes(input: string): string;
/**
 *
 * @param input a url.pathname
 * @returns the first real slashindex for example if sended "///page/hi" will return 4
 */
export declare function getSlashIndex(input: string): number;
/**
 * checks the input as a string that starts with /
 * @param path input path
 * @returns the same path if it passed the checks
 */
export declare function normalizePath(path: string): string;
export declare function parseSearchParams(search: URLSearchParams): {
    [name: string]: string | string[];
};
export interface ConnectionUpgrader {
    onUpgrade: (req: Request, socket: Duplex, head: Buffer) => Promise<void> | void;
}
export interface WebSocketComplexValidateResult {
    uuid?: string;
    headers?: {
        name: string;
        value: string;
    }[];
}
export interface WebSocketServerOptions {
    maxConnections?: number;
    maxFrameSize?: number;
    validate?: (req: Request) => Promise<boolean | string | WebSocketComplexValidateResult> | boolean | string | WebSocketComplexValidateResult;
    onConnection?: (req: WebSocketClient) => void | Promise<void>;
    onMessage?: (req: WebSocketClient, data: string | undefined | null) => void | Promise<void>;
    onDisconnect?: (req: WebSocketClient) => void | Promise<void>;
    onError?: (req: WebSocketClient, error: Error) => void | Promise<void>;
}
export interface WebSocketClient {
    uuid: string;
    req: Request;
    socket: Duplex;
    head: Buffer;
}
export {};