import http, { IncomingMessage, ServerResponse } from 'node:http';
import { FastifyCorsOptions } from '@fastify/cors';
import { CorsOptions } from 'cors';
import TestAgent from 'supertest/lib/agent';
import { Pipe, PipeOutput } from 'valleyed';
import { EventBus } from './events/index.js';
import { A as AuthUser } from './overrides-6Hxg764S.js';
import { d as RouteDef, j as RouterConfig, i as RouteConfig, l as RouteDefHandler, k as MergeRouteDefs, e as Route, R as Request, a as Response, M as MethodsEnum } from './requestError-BmOhSuFb.js';
import { IncomingHttpHeaders } from 'node:http2';
import { Server as Server$1 } from 'socket.io';
import { E as Entity } from './core-tNlIMH9Y.js';

declare abstract class BaseRequestAuthMethod<T extends {
    id: string;
}> {
    abstract parse(headers: IncomingHttpHeaders): Promise<T>;
    abstract routeSecuritySchemeName(): string | null;
    static process<T extends {
        id: string;
    }>(methods: BaseRequestAuthMethod<T>[], headers: IncomingHttpHeaders): Promise<T | null>;
}

declare class Router<T extends RouteDef> {
    #private;
    constructor(config?: RouterConfig<T>);
    head: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
    get: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
    post: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
    put: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
    patch: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
    delete: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
    options: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
    nest(...routers: Router<any>[]): void;
    get routes(): Route<any>[];
}

type OnJoinFn = (data: {
    channel: string;
    user: AuthUser | null;
}, params: Record<string, any>, query: Record<string, any>) => Promise<string | null>;
type SocketCallbacks = {
    onConnect: (userId: string, socketId: string) => Promise<void>;
    onDisconnect: (userId: string, socketId: string) => Promise<void>;
};
declare class SocketEmitter {
    #private;
    private config;
    readonly socketInstance: Server$1;
    constructor(socket: Server$1, config: ServerConfig);
    created<T extends Entity>(channels: string[], data: T, to: string | string[] | null): Promise<void>;
    updated<T extends Entity>(channels: string[], { after, before }: {
        after: T;
        before: T;
    }, to: string | string[] | null): Promise<void>;
    deleted<T extends Entity>(channels: string[], data: T, to: string | string[] | null): Promise<void>;
    set connectionCallbacks(callbacks: SocketCallbacks);
    register(channel: string, onJoin: OnJoinFn): this;
}

declare const serverConfigPipe: () => Pipe<{
    port: number;
    cors: {
        origin: true | string[] | undefined;
        methods: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | undefined;
        credentials: boolean | undefined;
    } | undefined;
    eventBus: EventBus | undefined;
    publicPath: string | undefined;
    healthPath: string | undefined;
    openapi: {
        docsVersion: string | undefined;
        docsBaseUrl: string[] | undefined;
        docsPath: string | undefined;
    } | undefined;
    requests: {
        log: boolean | undefined;
        rateLimit: {
            enabled: boolean | undefined;
            periodInMs: number | undefined;
            limit: number | undefined;
        } | undefined;
        slowdown: {
            enabled: boolean | undefined;
            periodInMs: number | undefined;
            delayAfter: number | undefined;
            delayInMs: number | undefined;
        } | undefined;
    } | undefined;
    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[] | undefined;
}, {
    port: number;
    cors: {
        origin: true | string[] | undefined;
        methods: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | undefined;
        credentials: boolean | undefined;
    } | undefined;
    eventBus: EventBus | undefined;
    publicPath: string | undefined;
    healthPath: string | undefined;
    openapi: {
        docsVersion: string;
        docsBaseUrl: string[];
        docsPath: string;
    };
    requests: {
        log: boolean;
        rateLimit: {
            enabled: boolean;
            periodInMs: number;
            limit: number;
        };
        slowdown: {
            enabled: boolean;
            periodInMs: number;
            delayAfter: number;
            delayInMs: number;
        };
    };
    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[];
}>;
type ServerConfig = PipeOutput<ReturnType<typeof serverConfigPipe>>;
declare const rawResponseHandledSymbol: unique symbol;
type RawResponseHandled = {
    readonly [rawResponseHandledSymbol]: true;
};
type RawResponseHandler = (request: IncomingMessage, response: ServerResponse) => unknown | Promise<unknown>;
type RawResponder = (handler: RawResponseHandler) => Promise<RawResponseHandled>;
type ServerBeforeListenContext = {
    httpServer: http.Server;
    port: number;
};
type ServerBeforeListenHandler = (context: ServerBeforeListenContext) => void | Promise<void>;
type ServerNotFoundContext = {
    request: Request<any>;
    respondWithRaw: RawResponder;
};
type ServerNotFoundHandler = (context: ServerNotFoundContext) => Response<any> | RawResponseHandled | Promise<Response<any> | RawResponseHandled>;
declare abstract class Server {
    #private;
    socket: SocketEmitter;
    cors: CorsOptions & FastifyCorsOptions;
    protected abstract parseRequest(req: any): Promise<Request<any>>;
    protected abstract handleResponse(res: any, response: Response<any>): Promise<void>;
    protected abstract createRawResponder(req: any, res: any): RawResponder;
    protected abstract registerRoute(method: MethodsEnum, path: string, cb: (req: any, res: any) => Promise<void>): void;
    protected abstract registerErrorHandler(cb: (error: Error, req: any, res: any) => Promise<void>): void;
    protected abstract registerNotFoundHandler(cb: (req: any, res: any) => Promise<void>): void;
    protected abstract startServer(port: number): Promise<boolean>;
    protected setup(httpServer: http.Server, config: ServerConfig): void;
    addRouter(...routers: Router<any>[]): void;
    addRoute<T extends RouteDef>(...routes: Route<T>[]): void;
    setNotFoundHandler(handler: ServerNotFoundHandler): this;
    onBeforeListen(handler: ServerBeforeListenHandler): this;
    test(): TestAgent;
    start(): Promise<boolean>;
    protected createNodeRawResponder(input: {
        request: IncomingMessage;
        response: ServerResponse;
        beforeHandle?: () => void;
    }): RawResponder;
}

export { BaseRequestAuthMethod as B, type OnJoinFn as O, type RawResponder as R, Server as S, type ServerConfig as a, type RawResponseHandled as b, type RawResponseHandler as c, type ServerBeforeListenContext as d, type ServerBeforeListenHandler as e, type ServerNotFoundContext as f, type ServerNotFoundHandler as g, Router as h, type SocketCallbacks as i, SocketEmitter as j, serverConfigPipe as s };