import express from 'express';
import { FastifyRequest, FastifyReply } from 'fastify';
import * as valleyed from 'valleyed';
import { PipeOutput } from 'valleyed';
import { E as EventBus } from './kafka-Cf-TUJgv.js';
import { A as AuthUser } from './overrides-6Hxg764S.js';
import { IncomingHttpHeaders } from 'node:http2';
import * as supertest_lib_agent from 'supertest/lib/agent';
import http from 'node:http';
import { FastifyCorsOptions } from '@fastify/cors';
import { CorsOptions } from 'cors';
import supertest from 'supertest';
import { d as RouteDef, j as RouterConfig, i as RouteConfig, l as RouteDefHandler, k as MergeRouteDefs, e as Route, a as Request, b as Response, f as MethodsEnum } from './requestError-C2PNWUrt.js';
import { Server as Server$1 } from 'socket.io';
import { E as Entity } from './core-BrkNSwvc.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 const serverConfigPipe: () => valleyed.Pipe<({
    port: number;
    cors: {
        origin: true | string[] | undefined;
        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | 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;
} & {
    type: "fastify";
}) | ({
    port: number;
    cors: {
        origin: true | string[] | undefined;
        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | 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;
} & {
    type: "express";
}), ({
    port: number;
    cors: {
        origin: true | string[] | undefined;
        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | 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: "fastify";
}) | ({
    port: number;
    cors: {
        origin: true | string[] | undefined;
        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | 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: "express";
})>;
type ServerConfig = PipeOutput<ReturnType<typeof serverConfigPipe>>;

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 abstract class Server<Req = any, Res = any> {
    #private;
    private config;
    private implementations;
    socket: SocketEmitter;
    protected server: http.Server;
    protected get cors(): CorsOptions & FastifyCorsOptions;
    constructor(server: http.Server, config: ServerConfig, implementations: {
        parseRequest: (req: Req) => Promise<Request<any>>;
        handleResponse: (res: Res, response: Response<any>) => Promise<void>;
        registerRoute: (method: MethodsEnum, path: string, cb: (req: Req, res: Res) => Promise<void>) => void;
        registerErrorHandler: (cb: (error: Error, req: Req, res: Res) => Promise<void>) => void;
        registerNotFoundHandler: (cb: (req: Req, res: Res) => Promise<void>) => void;
        start: (port: number) => Promise<boolean>;
    });
    addRouter(...routers: Router<any>[]): void;
    addRoute<T extends RouteDef>(...routes: Route<T>[]): void;
    test(): supertest_lib_agent<supertest.SuperTestStatic.Test>;
    start(): Promise<boolean>;
}

declare class ExpressServer extends Server<express.Request, express.Response> {
    constructor(config: ServerConfig);
}

declare class FastifyServer extends Server<FastifyRequest, FastifyReply> {
    constructor(config: ServerConfig);
}

export { BaseRequestAuthMethod as B, ExpressServer as E, FastifyServer as F, type OnJoinFn as O, Router as R, Server as S, type ServerConfig as a, type SocketCallbacks as b, SocketEmitter as c, serverConfigPipe as s };