import { Pipe, Prettify, PipeOutput, IsInTypeList, PipeInput, DistributiveOmit } from 'valleyed';
import { Enum } from './types/index.js';
import { IncomingHttpHeaders } from 'node:http2';
import { Readable } from 'node:stream';
import { SerializeOptions } from '@fastify/cookie';
import { A as AuthUser } from './overrides-6Hxg764S.js';

declare class EquippedError extends Error {
    readonly message: string;
    readonly context: Record<string, unknown>;
    readonly cause?: unknown | undefined;
    constructor(message: string, context: Record<string, unknown>, cause?: unknown | undefined);
}

declare const Methods: {
    readonly head: "head";
    readonly get: "get";
    readonly post: "post";
    readonly put: "put";
    readonly patch: "patch";
    readonly delete: "delete";
    readonly options: "options";
};
declare const StatusCodes: {
    readonly Ok: 200;
    readonly Found: 302;
    readonly BadRequest: 400;
    readonly NotAuthenticated: 401;
    readonly NotAuthorized: 403;
    readonly NotFound: 404;
    readonly ValidationError: 422;
    readonly TooManyRequests: 429;
    readonly TokenExpired: 461;
};
type MethodsEnum = Enum<typeof Methods>;
type StatusCodesEnum = Enum<typeof StatusCodes>;
type DefaultHeaders = Record<string, ArrayOrValue<string>>;
type DefaultCookies = Record<string, string | undefined>;
type ArrayOrValue<T> = T | T[] | undefined;
type IncomingFile = {
    name: string;
    type: string;
    size: number;
    isTruncated: boolean;
    data: Buffer;
    duration: number;
};
type RouteDef = {
    params?: Pipe<Record<string, ArrayOrValue<string>>, Record<string, ArrayOrValue<string>>>;
    query?: Pipe<Record<string, ArrayOrValue<unknown>>, Record<string, ArrayOrValue<unknown>>>;
    headers?: Pipe<DefaultHeaders, DefaultHeaders>;
    cookies?: Pipe<DefaultCookies, DefaultCookies>;
    body?: Pipe<Record<string, unknown>, Record<string, unknown>>;
    response?: Pipe<unknown, unknown>;
    responseHeaders?: Pipe<DefaultHeaders, DefaultHeaders>;
    responseCookies?: Pipe<DefaultCookies, DefaultCookies>;
    defaultStatusCode?: StatusCodesEnum;
    defaultContentType?: string;
};
type RouteGroup = {
    name: string;
    description?: string;
};
type HandlerSetup<T extends RouteDef> = (route: Route<T>) => void;
type RouteConfig<T extends RouteDef> = {
    middlewares?: ReturnType<typeof makeMiddleware<RouteDef>>[];
    responseMiddlewares?: ReturnType<typeof makeResponseMiddleware<RouteDef>>[];
    onError?: ReturnType<typeof makeErrorMiddleware<RouteDef>>;
    groups?: (RouteGroup | RouteGroup['name'])[];
    title?: string;
    descriptions?: string[];
    security?: Record<string, string[]>[];
    schema?: T;
    hide?: boolean;
};
type RouterConfig<T extends RouteDef> = RouteConfig<T> & {
    path: string;
};
type Route<T extends RouteDef> = RouteConfig<T> & {
    path: string;
    method: MethodsEnum;
    handler: RouteDefHandler<T>;
};
type GetApiPart<T extends RouteDef, K extends keyof RouteDef> = NonNullable<IsInTypeList<T[K], [unknown]> extends true ? RouteDef[K] : T[K]>;
type ArePipes<A, B> = A extends Pipe<any, any> ? (B extends Pipe<any, any> ? true : false) : false;
type Compare<K extends keyof RouteDef, A, B> = IsInTypeList<B, [unknown]> extends true ? A : IsInTypeList<A, [unknown]> extends true ? B : K extends `default${string}` | 'context' ? B : ArePipes<A, B> extends true ? Pipe<PipeInput<A> & PipeInput<B>, PipeOutput<A> & PipeOutput<B>> : B;
type MergeRouteDefs<A extends RouteDef, B extends RouteDef> = {
    [K in keyof RouteDef]: Compare<K, A[K], B[K]>;
};
type RouteDefToReqRes<T extends RouteDef> = Prettify<{
    body: PipeOutput<GetApiPart<T, 'body'>>;
    params: PipeOutput<GetApiPart<T, 'params'>>;
    requestHeaders: PipeOutput<GetApiPart<T, 'headers'>>;
    requestCookies: PipeOutput<GetApiPart<T, 'cookies'>>;
    query: PipeOutput<GetApiPart<T, 'query'>>;
    response: PipeOutput<GetApiPart<T, 'response'>>;
    responseHeaders: PipeOutput<GetApiPart<T, 'responseHeaders'>>;
    responseCookies: PipeOutput<GetApiPart<T, 'responseCookies'>>;
    statusCode: GetApiPart<T, 'defaultStatusCode'>;
    contentType: GetApiPart<T, 'defaultContentType'>;
}>;
type Awaitable<T> = Promise<T> | T;
type Res<T extends RouteDefToReqRes<any>> = Awaitable<IsInTypeList<T['statusCode'], [StatusCodesEnum, 200]> extends true ? IsInTypeList<T['responseHeaders'], [DefaultHeaders]> extends true ? IsInTypeList<T['responseCookies'], [DefaultCookies]> extends true ? Response<T> | T['response'] : Response<T> : Response<T> : Response<T>>;
type RouteDefHandler<Def extends RouteDef> = (req: Request<RouteDefToReqRes<Def>>) => Res<RouteDefToReqRes<Def>>;
type RouteMiddlewareHandler<_Def extends RouteDef> = (req: Request<RouteDefToReqRes<RouteDef>>) => Awaitable<void>;
type RouteResponseMiddlewareHandler<_Def extends RouteDef> = (req: Request<RouteDefToReqRes<RouteDef>>, res: Response<RouteDefToReqRes<RouteDef>>) => Awaitable<void>;
type ErrorHandler<Def extends RouteDef> = (req: Request<RouteDefToReqRes<Def>>, err: Error) => Res<Omit<RouteDefToReqRes<Def>, 'response' | 'statusCode' | 'responseHeaders' | 'responseCookies'> & {
    response: RequestError['serializedErrors'];
    statusCode: RequestError['statusCode'];
    responseHeaders: DefaultHeaders;
    responseCookies: DefaultCookies;
}>;
declare function makeMiddlewareHandler<Cb extends Function, T extends RouteDef>(cb: Cb, onSetup?: HandlerSetup<T>): {
    cb: Cb;
    onSetup: HandlerSetup<T> | undefined;
};
declare const makeMiddleware: <Def extends RouteDef>(...args: Parameters<typeof makeMiddlewareHandler<RouteMiddlewareHandler<Def>, Def>>) => {
    cb: RouteMiddlewareHandler<Def>;
    onSetup: HandlerSetup<Def> | undefined;
};
declare const makeResponseMiddleware: <Def extends RouteDef>(...args: Parameters<typeof makeMiddlewareHandler<RouteResponseMiddlewareHandler<Def>, Def>>) => {
    cb: RouteResponseMiddlewareHandler<Def>;
    onSetup: HandlerSetup<Def> | undefined;
};
declare const makeErrorMiddleware: <Def extends RouteDef>(...args: Parameters<typeof makeMiddlewareHandler<ErrorHandler<Def>, Def>>) => {
    cb: ErrorHandler<Def>;
    onSetup: HandlerSetup<Def> | undefined;
};

type CookieVal<C extends DefaultCookies> = {
    [K in keyof C]: SerializeOptions & {
        value: C[K];
    };
};
declare class Request<Def extends RouteDefToReqRes<any>> {
    readonly ip: string | undefined;
    readonly method: MethodsEnum;
    readonly path: string;
    body: Def['body'];
    params: Def['params'];
    query: Def['query'];
    headers: IncomingHttpHeaders & Def['requestHeaders'];
    cookies: Record<string, string | undefined> & Def['requestCookies'];
    authUser: AuthUser | null;
    constructor({ ip, body, cookies, params, query, method, path, headers, files, }: {
        ip: string | undefined;
        body: Def['body'];
        params: Def['params'];
        query: Def['query'];
        cookies: Record<string, string | undefined> & Def['requestCookies'];
        headers: IncomingHttpHeaders;
        files: Record<string, IncomingFile[]>;
        method: MethodsEnum;
        path: string;
    });
    pipe(stream: Readable, opts?: {
        headers?: Def['responseHeaders'];
        cookies?: Def['responseCookies'];
        status?: Def['statusCode'];
    }): Response<Omit<Def, "response"> & {
        response: Readable;
    }>;
    res(params: DistributiveOmit<RequestParams<Def>, 'piped'>): Response<Def>;
    error<T extends Omit<Def, 'response' | 'statusCode' | 'responseHeaders' | 'responseCookies' | 'contentType'> & {
        response: RequestError['serializedErrors'];
        statusCode: RequestError['statusCode'];
        responseHeaders: DefaultHeaders;
        responseCookies: DefaultCookies;
        contentType: 'application/json';
    }>(params: DistributiveOmit<RequestParams<T>, 'piped'>): Response<T>;
}
type RequestParams<Def extends RouteDefToReqRes<any>, T = Def['response']> = {
    body: T;
    piped?: boolean;
} & (IsInTypeList<Def['statusCode'], [
    NonNullable<RouteDef['defaultStatusCode']>,
    200
]> extends true ? {
    status?: Def['statusCode'];
} : {
    status: Def['statusCode'];
}) & (IsInTypeList<Def['contentType'], [NonNullable<RouteDef['defaultContentType']>, 'application/json']> extends true ? {
    contentType?: Def['contentType'];
} : {
    contentType: Def['contentType'];
}) & (IsInTypeList<Def['responseHeaders'], [DefaultHeaders]> extends true ? {
    headers?: Def['responseHeaders'];
} : {
    headers: Def['responseHeaders'];
}) & (IsInTypeList<Def['responseCookies'], [DefaultCookies]> extends true ? {
    cookies?: CookieVal<Def['responseCookies']>;
} : {
    cookies: CookieVal<Def['responseCookies']>;
});
declare class Response<Def extends RouteDefToReqRes<any>> {
    body: Def['response'] | undefined;
    headers: Def['responseHeaders'];
    cookies: CookieVal<Def['responseCookies']>;
    readonly status: Def['statusCode'];
    readonly contentType: Def['contentType'];
    readonly piped: boolean;
    constructor({ body, status, headers, cookies, piped, contentType, }: RequestParams<Def>);
    get cookieValues(): DefaultCookies;
    set cookieValues(values: DefaultCookies);
}

declare abstract class RequestError extends EquippedError {
    readonly message: string;
    readonly serializedErrors: {
        message: string;
        field?: string;
    }[];
    abstract readonly statusCode: StatusCodesEnum;
    protected constructor(message: string, serializedErrors: {
        message: string;
        field?: string;
    }[], cause?: unknown);
}

export { type CookieVal as C, type DefaultHeaders as D, EquippedError as E, type IncomingFile as I, Methods as M, RequestError as R, StatusCodes as S, Request as a, Response as b, type RouteDefToReqRes as c, type RouteDef as d, type Route as e, type MethodsEnum as f, type StatusCodesEnum as g, type DefaultCookies as h, type RouteConfig as i, type RouterConfig as j, type MergeRouteDefs as k, type RouteDefHandler as l, makeMiddleware as m, makeResponseMiddleware as n, makeErrorMiddleware as o };