equipped 5.2.3 → 5.2.5

package/dist/types/index.d.ts

@@ -1,16 +1,15 @@
 export { Instance } from './instance/index.js';
 import 'pino';
 import 'valleyed';
-import './requestError-MGJ-ojtC.js';
+import './requestError-C2PNWUrt.js';
 import './types/index.js';
 import './overrides-6Hxg764S.js';
-import './base-CfeyC14V.js';
 import 'node:http2';
 import 'node:stream';
 import '@fastify/cookie';
-import './kafka-DCpqW_YM.js';
+import './kafka-Cf-TUJgv.js';
 import './events/index.js';
-import './fastify-BizyaCY_.js';
+import './fastify-Cv1D0iUh.js';
 import 'express';
 import 'fastify';
 import 'supertest/lib/agent';
@@ -19,10 +18,10 @@ import '@fastify/cors';
 import 'cors';
 import 'supertest';
 import 'socket.io';
-import './core-BWUHISEy.js';
+import './core-BrkNSwvc.js';
 import 'mongodb';
 import './cache/index.js';
 import 'ioredis';
-import './db-vKGTnGlO.js';
-import './db-DEiImw1Z.js';
+import './db-Dj1SGto0.js';
+import './db-C8YY1yTO.js';
 import './jobs/index.js';

package/dist/types/instance/index.d.ts

@@ -1,14 +1,13 @@
 import { Logger } from 'pino';
 import * as valleyed from 'valleyed';
 import { PipeOutput, ConditionalObjectKeys, PipeInput, Pipe } from 'valleyed';
-import { B as BaseRequestAuthMethod, E as EquippedError } from '../requestError-MGJ-ojtC.js';
-import { E as EventBus } from '../base-CfeyC14V.js';
-import { K as KafkaEventBus } from '../kafka-DCpqW_YM.js';
+import { E as EquippedError } from '../requestError-C2PNWUrt.js';
+import { K as KafkaEventBus, E as EventBus } from '../kafka-Cf-TUJgv.js';
 import { RabbitMQEventBus } from '../events/index.js';
 import { A as AuthUser } from '../overrides-6Hxg764S.js';
-import { E as ExpressServer, F as FastifyServer } from '../fastify-BizyaCY_.js';
+import { E as ExpressServer, F as FastifyServer, B as BaseRequestAuthMethod } from '../fastify-Cv1D0iUh.js';
 import { InMemoryCache, RedisCache } from '../cache/index.js';
-import { M as MongoDb } from '../db-vKGTnGlO.js';
+import { M as MongoDb } from '../db-Dj1SGto0.js';
 import { RedisJob } from '../jobs/index.js';
 import '../types/index.js';
 import 'node:http2';
@@ -22,10 +21,10 @@ import '@fastify/cors';
 import 'cors';
 import 'supertest';
 import 'socket.io';
-import '../core-BWUHISEy.js';
+import '../core-BrkNSwvc.js';
 import 'mongodb';
 import 'ioredis';
-import '../db-DEiImw1Z.js';
+import '../db-C8YY1yTO.js';
 
 type HookEvent = 'setup' | 'start' | 'close';
 type HookCb = Promise<unknown | void> | (() => void | unknown | Promise<void | unknown>);

package/dist/types/{kafka-DCpqW_YM.d.ts → kafka-Cf-TUJgv.d.ts}

@@ -1,8 +1,18 @@
 import { E as Events } from './overrides-6Hxg764S.js';
-import { E as EventBus, S as StreamOptions } from './base-CfeyC14V.js';
 import * as valleyed from 'valleyed';
 import { PipeOutput } from 'valleyed';
 
+type StreamOptions = {
+    skipScope?: boolean;
+    fanout: boolean;
+};
+declare abstract class EventBus {
+    abstract createStream<Event extends Events[keyof Events]>(topic: Event['topic'], options?: Partial<StreamOptions>): {
+        publish: (data: Event['data']) => Promise<boolean>;
+        subscribe: (onMessage: (data: Event['data']) => Promise<void>) => void;
+    };
+}
+
 declare const rabbitmqConfigPipe: () => valleyed.Pipe<{
     uri: string;
     eventColumnName: string;
@@ -41,4 +51,4 @@ declare class KafkaEventBus extends EventBus {
     };
 }
 
-export { KafkaEventBus as K, type RabbitMQConfig as R, type KafkaConfig as a, kafkaConfigPipe as k, rabbitmqConfigPipe as r };
+export { EventBus as E, KafkaEventBus as K, type RabbitMQConfig as R, type StreamOptions as S, type KafkaConfig as a, kafkaConfigPipe as k, rabbitmqConfigPipe as r };

package/dist/types/{requestError-MGJ-ojtC.d.ts → requestError-C2PNWUrt.d.ts}

@@ -1,11 +1,9 @@
-import * as valleyed from 'valleyed';
-import { PipeOutput, Pipe, Prettify, IsInTypeList, PipeInput, DistributiveOmit } from 'valleyed';
+import { Pipe, Prettify, PipeOutput, IsInTypeList, PipeInput, DistributiveOmit } from 'valleyed';
 import { Enum } from './types/index.js';
-import { E as EventBus } from './base-CfeyC14V.js';
-import { A as AuthUser } from './overrides-6Hxg764S.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;
@@ -14,147 +12,6 @@ declare class EquippedError extends Error {
     constructor(message: string, context: Record<string, unknown>, cause?: unknown | undefined);
 }
 
-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 const Methods: {
     readonly head: "head";
     readonly get: "get";
@@ -207,6 +64,7 @@ type RouteGroup = {
 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;
@@ -243,9 +101,10 @@ type RouteDefToReqRes<T extends RouteDef> = Prettify<{
 }>;
 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>>, config: ServerConfig) => Res<RouteDefToReqRes<Def>>;
-type RouteMiddlewareHandler<_Def extends RouteDef> = (req: Request<RouteDefToReqRes<RouteDef>>, config: ServerConfig) => Awaitable<void>;
-type ErrorHandler<Def extends RouteDef> = (req: Request<RouteDefToReqRes<Def>>, config: ServerConfig, err: Error) => Res<Omit<RouteDefToReqRes<Def>, 'response' | 'statusCode' | 'responseHeaders' | 'responseCookies'> & {
+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;
@@ -259,6 +118,10 @@ declare const makeMiddleware: <Def extends RouteDef>(...args: Parameters<typeof
     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;
@@ -354,4 +217,4 @@ declare abstract class RequestError extends EquippedError {
     }[], cause?: unknown);
 }
 
-export { BaseRequestAuthMethod as B, type CookieVal as C, type DefaultHeaders as D, EquippedError as E, type IncomingFile as I, Methods as M, RequestError as R, type ServerConfig as S, Request as a, Response as b, type RouteDefToReqRes as c, type RouteDef as d, type Route as e, StatusCodes as f, type MethodsEnum as g, type StatusCodesEnum as h, type DefaultCookies as i, type RouteConfig as j, type RouterConfig as k, type MergeRouteDefs as l, type RouteDefHandler as m, makeMiddleware as n, makeErrorMiddleware as o, serverConfigPipe as s };
+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 };

package/dist/types/server/impls/base.js

@@ -48,25 +48,27 @@ class Server {
   addRoute(...routes) {
     routes.forEach((route) => {
       this.#queue.push(async () => {
-        const { method, path, schema = {}, onError, middlewares = [] } = route;
+        const { method, path, schema = {}, onError, middlewares = [], responseMiddlewares = [] } = route;
         const key = `(${method.toUpperCase()}) ${this.#openapi.cleanPath(path)}`;
         if (this.#routesByKey.get(key))
           throw new EquippedError(`Route key ${key} already registered. All route keys must be unique`, { route, key });
         middlewares.forEach((m) => m.onSetup?.(route));
         onError?.onSetup?.(route);
+        responseMiddlewares.forEach((m) => m.onSetup?.(route));
         const { validateRequest, validateResponse, jsonSchema } = this.#resolveSchema(method, schema);
         this.#routesByKey.set(key, true);
         await this.#openapi.register(route, jsonSchema);
         this.implementations.registerRoute(method, this.#openapi.cleanPath(path), async (req, res) => {
           const request = await validateRequest(await this.implementations.parseRequest(req));
           try {
-            for (const middleware of middlewares) await middleware.cb(request, this.config);
-            const rawRes = await route.handler(request, this.config);
+            for (const middleware of middlewares) await middleware.cb(request);
+            const rawRes = await route.handler(request);
             const response = rawRes instanceof Response ? rawRes : new Response({ body: rawRes, status: StatusCodes.Ok, headers: {}, piped: false });
+            for (const middleware of responseMiddlewares) await middleware.cb(request, response);
             return await this.implementations.handleResponse(res, await validateResponse(response));
           } catch (error) {
             if (onError?.cb) {
-              const rawResponse = await onError.cb(request, this.config, error);
+              const rawResponse = await onError.cb(request, error);
               const response = rawResponse instanceof Response ? rawResponse : new Response({ body: rawResponse, status: StatusCodes.BadRequest, headers: {} });
               return await this.implementations.handleResponse(res, await validateResponse(response));
             }
@@ -188,6 +190,9 @@ class Server {
       const response = error instanceof RequestError ? new Response({
         body: error.serializedErrors,
         status: error.statusCode
+      }) : error instanceof EquippedError ? new Response({
+        body: [{ message: error.message }],
+        status: StatusCodes.BadRequest
       }) : new Response({
         body: [{ message: "Something went wrong", data: error.message }],
         status: StatusCodes.BadRequest

package/dist/types/server/index.d.ts

@@ -1,21 +1,21 @@
-export { E as ExpressServer, F as FastifyServer, O as OnJoinFn, R as Router, S as Server, a as SocketCallbacks, b as SocketEmitter } from '../fastify-BizyaCY_.js';
-import { B as BaseRequestAuthMethod, a as Request, c as RouteDefToReqRes, d as RouteDef, S as ServerConfig, e as Route } from '../requestError-MGJ-ojtC.js';
-export { C as CookieVal, i as DefaultCookies, D as DefaultHeaders, I as IncomingFile, l as MergeRouteDefs, M as Methods, g as MethodsEnum, b as Response, j as RouteConfig, m as RouteDefHandler, k as RouterConfig, f as StatusCodes, h as StatusCodesEnum, o as makeErrorMiddleware, n as makeMiddleware, s as serverConfigPipe } from '../requestError-MGJ-ojtC.js';
+import { B as BaseRequestAuthMethod } from '../fastify-Cv1D0iUh.js';
+export { E as ExpressServer, F as FastifyServer, O as OnJoinFn, R as Router, S as Server, a as ServerConfig, b as SocketCallbacks, c as SocketEmitter, s as serverConfigPipe } from '../fastify-Cv1D0iUh.js';
 import { A as AuthUser } from '../overrides-6Hxg764S.js';
+import { a as Request, c as RouteDefToReqRes, d as RouteDef, e as Route } from '../requestError-C2PNWUrt.js';
+export { C as CookieVal, h as DefaultCookies, D as DefaultHeaders, I as IncomingFile, k as MergeRouteDefs, M as Methods, f as MethodsEnum, b as Response, i as RouteConfig, l as RouteDefHandler, j as RouterConfig, S as StatusCodes, g as StatusCodesEnum, o as makeErrorMiddleware, m as makeMiddleware, n as makeResponseMiddleware } from '../requestError-C2PNWUrt.js';
 import { IncomingHttpHeaders } from 'node:http2';
 import 'express';
 import 'fastify';
+import 'valleyed';
+import '../kafka-Cf-TUJgv.js';
 import 'supertest/lib/agent';
 import 'node:http';
 import '@fastify/cors';
 import 'cors';
 import 'supertest';
 import 'socket.io';
-import '../core-BWUHISEy.js';
+import '../core-BrkNSwvc.js';
 import 'mongodb';
-import 'valleyed';
-import '../kafka-DCpqW_YM.js';
-import '../base-CfeyC14V.js';
 import '../types/index.js';
 import 'node:stream';
 import '@fastify/cookie';
@@ -75,8 +75,8 @@ declare abstract class BaseJwtCookieRequestAuthMethod<T extends {
 }
 
 declare const requireAuthUser: (methods: BaseRequestAuthMethod<AuthUser>[]) => {
-    cb: (req: Request<RouteDefToReqRes<RouteDef>>, config: ServerConfig) => void | Promise<void>;
+    cb: (req: Request<RouteDefToReqRes<RouteDef>>) => void | Promise<void>;
     onSetup: ((route: Route<RouteDef>) => void) | undefined;
 };
 
-export { BaseApiKeyRequestAuthMethod, BaseJwtCookieRequestAuthMethod, BaseJwtHeaderRequestAuthMethod, BaseJwtRequestAuthMethod, type BaseJwtRequestAuthMethodOptions, BaseRequestAuthMethod, Request, Route, RouteDef, RouteDefToReqRes, ServerConfig, requireAuthUser };
+export { BaseApiKeyRequestAuthMethod, BaseJwtCookieRequestAuthMethod, BaseJwtHeaderRequestAuthMethod, BaseJwtRequestAuthMethod, type BaseJwtRequestAuthMethodOptions, BaseRequestAuthMethod, Request, Route, RouteDef, RouteDefToReqRes, requireAuthUser };

package/dist/types/server/routes.js

@@ -36,6 +36,7 @@ const groupRoutes = (config, routes) => routes.map((route) => ({
   path: `${config.path}/${route.path}`,
   groups: [...config.groups ?? [], ...route.groups ?? []],
   middlewares: [...config.middlewares ?? [], ...route.middlewares ?? []],
+  responseMiddlewares: [...config.responseMiddlewares ?? [], ...route.responseMiddlewares ?? []],
   schema: mergeSchemas(config.schema ?? {}, route.schema ?? {}),
   security: [...config.security ?? [], ...route.security ?? []]
 }));

package/dist/types/server/types.js

@@ -22,10 +22,12 @@ function makeMiddlewareHandler(cb, onSetup) {
   return { cb, onSetup };
 }
 const makeMiddleware = (...args) => makeMiddlewareHandler(...args);
+const makeResponseMiddleware = (...args) => makeMiddlewareHandler(...args);
 const makeErrorMiddleware = (...args) => makeMiddlewareHandler(...args);
 export {
   Methods,
   StatusCodes,
   makeErrorMiddleware,
-  makeMiddleware
+  makeMiddleware,
+  makeResponseMiddleware
 };

package/dist/types/{validationError-BbiTIoAh.d.ts → validationError-Bw8OYv5s.d.ts}

@@ -1,4 +1,4 @@
-import { R as RequestError } from './requestError-MGJ-ojtC.js';
+import { R as RequestError } from './requestError-C2PNWUrt.js';
 
 type ValidError = {
     messages: string[];

package/dist/types/validations/index.d.ts

@@ -1,11 +1,10 @@
 import { Pipe, PipeInput, PipeOutput, PipeError } from 'valleyed';
 export * from 'valleyed';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { I as IncomingFile, a as Request, b as Response, c as RouteDefToReqRes, d as RouteDef } from '../requestError-MGJ-ojtC.js';
-import { V as ValidationError } from '../validationError-BbiTIoAh.js';
+import { I as IncomingFile, a as Request, b as Response, c as RouteDefToReqRes, d as RouteDef } from '../requestError-C2PNWUrt.js';
+import { V as ValidationError } from '../validationError-Bw8OYv5s.js';
 import '../types/index.js';
 import '../overrides-6Hxg764S.js';
-import '../base-CfeyC14V.js';
 import 'node:http2';
 import 'node:stream';
 import '@fastify/cookie';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "equipped",
-	"version": "5.2.3",
+	"version": "5.2.5",
 	"private": false,
 	"description": "",
 	"type": "module",

package/dist/types/base-CfeyC14V.d.ts

@@ -1,14 +0,0 @@
-import { E as Events } from './overrides-6Hxg764S.js';
-
-type StreamOptions = {
-    skipScope?: boolean;
-    fanout: boolean;
-};
-declare abstract class EventBus {
-    abstract createStream<Event extends Events[keyof Events]>(topic: Event['topic'], options?: Partial<StreamOptions>): {
-        publish: (data: Event['data']) => Promise<boolean>;
-        subscribe: (onMessage: (data: Event['data']) => Promise<void>) => void;
-    };
-}
-
-export { EventBus as E, type StreamOptions as S };

package/dist/types/fastify-BizyaCY_.d.ts

@@ -1,80 +0,0 @@
-import express from 'express';
-import { d as RouteDef, k as RouterConfig, j as RouteConfig, m as RouteDefHandler, l as MergeRouteDefs, e as Route, S as ServerConfig, a as Request, b as Response, g as MethodsEnum } from './requestError-MGJ-ojtC.js';
-import { FastifyRequest, FastifyReply } from 'fastify';
-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 { Server as Server$1 } from 'socket.io';
-import { E as Entity } from './core-BWUHISEy.js';
-import { A as AuthUser } from './overrides-6Hxg764S.js';
-
-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> {
-    #private;
-    constructor(config: ServerConfig);
-}
-
-declare class FastifyServer extends Server<FastifyRequest, FastifyReply> {
-    constructor(config: ServerConfig);
-}
-
-export { ExpressServer as E, FastifyServer as F, type OnJoinFn as O, Router as R, Server as S, type SocketCallbacks as a, SocketEmitter as b };