equipped 5.0.6 → 5.0.8

package/dist/types/dbs.d.ts

@@ -0,0 +1,16 @@
+import { M as Model, E as Entity, D as DbChange, a as MongoDbConfig, b as DbChangeConfig, c as DbChangeCallbacks } from './index-U2VdDArL.js';
+export { B as BulkWriteOperation, k as Conditions, h as Config, C as CreateInput, e as Db, i as DbConfig, g as EntityInput, I as IdType, j as MongoDb, O as Options, Q as QueryKeys, m as QueryParams, n as QueryParamsInput, s as QueryResults, p as QueryWhere, r as QueryWhereBlock, o as QueryWhereClause, f as Table, d as TableOptions, T as TopicPrefix, U as UpdateInput, t as mongoDbConfigPipe, q as queryParamsPipe, l as queryResultsPipe, w as wrapQueryParams } from './index-U2VdDArL.js';
+import { MongoClient } from 'mongodb';
+export { Filter } from 'mongodb';
+import 'valleyed';
+import './kafka-CW925i4B.js';
+import './overrides-6Hxg764S.js';
+
+declare class MongoDbChange<Model extends Model<{
+    _id: string;
+}>, Entity extends Entity> extends DbChange<Model, Entity> {
+    #private;
+    constructor(config: MongoDbConfig, change: DbChangeConfig, client: MongoClient, dbName: string, colName: string, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model) => Entity);
+}
+
+export { DbChange, DbChangeCallbacks, DbChangeConfig, Entity, Model, MongoDbChange, MongoDbConfig };

package/dist/types/dbs.js

@@ -0,0 +1,26 @@
+import {
+  Conditions,
+  Db,
+  DbChange,
+  MongoDb,
+  MongoDbChange,
+  QueryKeys,
+  TopicPrefix,
+  mongoDbConfigPipe,
+  queryParamsPipe,
+  queryResultsPipe,
+  wrapQueryParams
+} from "./chunk-XNSFFTXR.js";
+export {
+  Conditions,
+  Db,
+  DbChange,
+  MongoDb,
+  MongoDbChange,
+  QueryKeys,
+  TopicPrefix,
+  mongoDbConfigPipe,
+  queryParamsPipe,
+  queryResultsPipe,
+  wrapQueryParams
+};

package/dist/types/errors.d.ts

@@ -0,0 +1,39 @@
+import { R as RequestError } from './requests-BlJQeR64.js';
+export { E as EquippedError } from './requests-BlJQeR64.js';
+export { V as ValidationError } from './validationError-XbHmdYeK.js';
+import 'stream';
+import 'valleyed';
+import './overrides-6Hxg764S.js';
+import './types.js';
+
+declare class AuthorizationExpired extends RequestError {
+    statusCode: 461;
+    constructor(message?: string, cause?: unknown);
+}
+
+declare class BadRequestError extends RequestError {
+    statusCode: 400;
+    constructor(message: string, cause?: unknown);
+}
+
+declare class NotAuthenticatedError extends RequestError {
+    statusCode: 401;
+    constructor(message?: string, cause?: unknown);
+}
+
+declare class NotAuthorizedError extends RequestError {
+    statusCode: 403;
+    constructor(message?: string, cause?: unknown);
+}
+
+declare class NotFoundError extends RequestError {
+    statusCode: 404;
+    constructor(message?: string, cause?: unknown);
+}
+
+declare class RefreshTokenMisusedError extends RequestError {
+    statusCode: 401;
+    constructor(message?: string, cause?: unknown);
+}
+
+export { AuthorizationExpired, BadRequestError, NotAuthenticatedError, NotAuthorizedError, NotFoundError, RefreshTokenMisusedError, RequestError };

package/dist/types/errors.js

@@ -0,0 +1,22 @@
+import {
+  AuthorizationExpired,
+  BadRequestError,
+  EquippedError,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  RefreshTokenMisusedError,
+  RequestError,
+  ValidationError
+} from "./chunk-XNSFFTXR.js";
+export {
+  AuthorizationExpired,
+  BadRequestError,
+  EquippedError,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  RefreshTokenMisusedError,
+  RequestError,
+  ValidationError
+};

package/dist/types/events.d.ts

@@ -0,0 +1,13 @@
+import { E as EventBus, R as RabbitMQConfig, P as PublishOptions, S as SubscribeOptions } from './kafka-CW925i4B.js';
+export { D as DefaultSubscribeOptions, K as KafkaConfig, a as KafkaEventBus, k as kafkaConfigPipe, r as rabbitmqConfigPipe } from './kafka-CW925i4B.js';
+import { E as Events } from './overrides-6Hxg764S.js';
+import 'valleyed';
+
+declare class RabbitMQEventBus extends EventBus {
+    #private;
+    constructor(config: RabbitMQConfig);
+    createPublisher<Event extends Events[keyof Events]>(topicName: Event['topic'], options?: Partial<PublishOptions>): (data: Event["data"]) => Promise<boolean>;
+    createSubscriber<Event extends Events[keyof Events]>(topicName: Event['topic'], onMessage: (data: Event['data']) => Promise<void>, options?: Partial<SubscribeOptions>): void;
+}
+
+export { EventBus, PublishOptions, RabbitMQConfig, RabbitMQEventBus, SubscribeOptions };

package/dist/types/events.js

@@ -0,0 +1,16 @@
+import {
+  DefaultSubscribeOptions,
+  EventBus,
+  KafkaEventBus,
+  RabbitMQEventBus,
+  kafkaConfigPipe,
+  rabbitmqConfigPipe
+} from "./chunk-XNSFFTXR.js";
+export {
+  DefaultSubscribeOptions,
+  EventBus,
+  KafkaEventBus,
+  RabbitMQEventBus,
+  kafkaConfigPipe,
+  rabbitmqConfigPipe
+};

package/dist/types/index-D-NoC-on.d.ts

@@ -0,0 +1,562 @@
+import * as valleyed from 'valleyed';
+import { PipeOutput, ConditionalObjectKeys, PipeInput, IsInTypeList, DataClass, Pipe } from 'valleyed';
+import { Logger } from 'pino';
+import { C as Cache } from './base-k4t2NepI.js';
+import { E as EventBus } from './kafka-CW925i4B.js';
+import { E as Entity, j as MongoDb } from './index-U2VdDArL.js';
+import { RedisJob } from './jobs.js';
+import * as supertest_lib_agent from 'supertest/lib/agent';
+import http from 'http';
+import supertest from 'supertest';
+import { A as AuthUser, a as RefreshUser } from './overrides-6Hxg764S.js';
+import { d as RouteDef, i as RouterConfig, h as RouteConfig, k as RouteDefHandler, j as MergeRouteDefs, e as Route, a as Request, b as Response, f as MethodsEnum, E as EquippedError } from './requests-BlJQeR64.js';
+import io from 'socket.io';
+
+type HookEvent = 'setup' | 'start' | 'close';
+type HookCb = Promise<unknown | void> | (() => void | unknown | Promise<void | unknown>);
+
+declare abstract class BaseApiKeysUtility {
+    abstract verifyApiKey(apiKey: string): Promise<AuthUser>;
+}
+
+declare abstract class BaseTokensUtility {
+    abstract createAccessToken(payload: AuthUser): Promise<string>;
+    abstract createRefreshToken(payload: RefreshUser): Promise<string>;
+    abstract verifyAccessToken(token: string): Promise<AuthUser>;
+    abstract verifyRefreshToken(token: string): Promise<RefreshUser>;
+    abstract retrieveAccessTokenFor(userId: string): Promise<string | null>;
+    abstract retrieveRefreshTokenFor(userId: string): Promise<string | null>;
+    abstract deleteAccessTokenFor(userId: string): Promise<void>;
+    abstract deleteRefreshTokenFor(userId: string): Promise<void>;
+    extractAccessTokenValue(headerValue: string): string;
+    exchangeTokens(tokens: {
+        accessToken: string;
+        refreshToken: string;
+    }, getPayload: (id: string) => Promise<{
+        access: AuthUser;
+        refresh: RefreshUser;
+    }>): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>;
+}
+type CacheTokensUtilityOptions = {
+    accessTokenKey: string;
+    refreshTokenKey: string;
+    accessTokenTTL: number;
+    refreshTokenTTL: number;
+    accessTokenPrefix: string;
+    refreshTokenPrefix: string;
+};
+declare class CacheTokensUtility extends BaseTokensUtility {
+    #private;
+    private options;
+    constructor(options?: Partial<CacheTokensUtilityOptions>);
+    createAccessToken(payload: AuthUser): Promise<string>;
+    createRefreshToken(payload: RefreshUser): Promise<string>;
+    verifyAccessToken(authHeader: string): Promise<AuthUser>;
+    verifyRefreshToken(token: string): Promise<RefreshUser>;
+    retrieveAccessTokenFor(userId: string): Promise<string | null>;
+    retrieveRefreshTokenFor(userId: string): Promise<string | null>;
+    deleteAccessTokenFor(userId: string): Promise<void>;
+    deleteRefreshTokenFor(userId: string): Promise<void>;
+}
+
+declare const serverPipe: valleyed.Pipe<{
+    type: "fastify" | "express";
+    port: number;
+    publicPath: string | undefined;
+    healthPath: string | undefined;
+    openapi: {
+        docsVersion: string | undefined;
+        docsBaseUrl: string[] | undefined;
+        docsPath: string | undefined;
+    } | undefined;
+    requests: {
+        log: boolean | undefined;
+        paginationDefaultLimit: number | undefined;
+        maxFileUploadSizeInMb: number | 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;
+    requestsAuth: {
+        tokens: BaseTokensUtility | undefined;
+        apiKey: BaseApiKeysUtility | undefined;
+    } | undefined;
+}, {
+    type: "fastify" | "express";
+    port: number;
+    publicPath: string | undefined;
+    healthPath: string | undefined;
+    openapi: {
+        docsVersion: string;
+        docsBaseUrl: string[];
+        docsPath: string;
+    };
+    requests: {
+        log: boolean;
+        paginationDefaultLimit: number;
+        maxFileUploadSizeInMb: number;
+        rateLimit: {
+            enabled: boolean;
+            periodInMs: number;
+            limit: number;
+        };
+        slowdown: {
+            enabled: boolean;
+            periodInMs: number;
+            delayAfter: number;
+            delayInMs: number;
+        };
+    };
+    requestsAuth: {
+        tokens: BaseTokensUtility | undefined;
+        apiKey: BaseApiKeysUtility | undefined;
+    };
+}, any>;
+type ServerConfig = {
+    config: PipeOutput<typeof serverPipe>;
+    app: {
+        id: string;
+        name: string;
+    };
+    log: Instance<any, any>['log'];
+    eventBus?: EventBus;
+};
+
+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;
+    readonly socketInstance: io.Server;
+    constructor(socket: io.Server, eventBus?: EventBus);
+    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;
+    protected 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>;
+    };
+    socket: SocketEmitter;
+    protected server: http.Server;
+    protected cors: {
+        origin: string;
+        methods: string[];
+    };
+    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 const instanceSettingsPipe: () => valleyed.Pipe<{
+    app: {
+        id: string;
+        name: string;
+    };
+    log: {
+        level: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "silent" | undefined;
+    } | undefined;
+    dbs: {
+        types: Record<string, {
+            uri: string;
+        } & {
+            type: "mongo";
+        }>;
+        changes: {
+            debeziumUrl: string;
+            kafkaConfig: {
+                brokers: string[];
+                ssl: boolean | undefined;
+                sasl: {
+                    mechanism: "plain";
+                    username: string;
+                    password: string;
+                } | undefined;
+                confluent: boolean | undefined;
+                clientId: string | undefined;
+            };
+        } | undefined;
+    } | undefined;
+    eventBus: ({
+        brokers: string[];
+        ssl: boolean | undefined;
+        sasl: {
+            mechanism: "plain";
+            username: string;
+            password: string;
+        } | undefined;
+        confluent: boolean | undefined;
+        clientId: string | undefined;
+    } & {
+        type: "kafka";
+    }) | ({
+        uri: string;
+        eventColumnName: string;
+    } & {
+        type: "rabbitmq";
+    }) | undefined;
+    cache: {
+        host: string;
+        port: number | undefined;
+        password: string | undefined;
+        username: string | undefined;
+        tls: boolean | undefined;
+        cluster: boolean | undefined;
+    } & {
+        type: "redis";
+    };
+    jobs: ({
+        redisConfig: {
+            host: string;
+            port: number | undefined;
+            password: string | undefined;
+            username: string | undefined;
+            tls: boolean | undefined;
+            cluster: boolean | undefined;
+        };
+        queueName: string;
+    } & {
+        type: "redis";
+    }) | undefined;
+    server: {
+        type: "fastify" | "express";
+        port: number;
+        publicPath: string | undefined;
+        healthPath: string | undefined;
+        openapi: {
+            docsVersion: string | undefined;
+            docsBaseUrl: string[] | undefined;
+            docsPath: string | undefined;
+        } | undefined;
+        requests: {
+            log: boolean | undefined;
+            paginationDefaultLimit: number | undefined;
+            maxFileUploadSizeInMb: number | 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;
+        requestsAuth: {
+            tokens: BaseTokensUtility | undefined;
+            apiKey: BaseApiKeysUtility | undefined;
+        } | undefined;
+    } | undefined;
+    utils: {
+        hashSaltRounds: number | undefined;
+    } | undefined;
+}, {
+    app: {
+        id: string;
+        name: string;
+    };
+    log: {
+        level: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "silent";
+    };
+    dbs: {
+        types: Record<string, {
+            uri: string;
+        } & {
+            type: "mongo";
+        }>;
+        changes: {
+            debeziumUrl: string;
+            kafkaConfig: {
+                brokers: string[];
+                ssl: boolean | undefined;
+                sasl: {
+                    mechanism: "plain";
+                    username: string;
+                    password: string;
+                } | undefined;
+                confluent: boolean | undefined;
+                clientId: string | undefined;
+            };
+        } | undefined;
+    } | undefined;
+    eventBus: ({
+        brokers: string[];
+        ssl: boolean | undefined;
+        sasl: {
+            mechanism: "plain";
+            username: string;
+            password: string;
+        } | undefined;
+        confluent: boolean | undefined;
+        clientId: string | undefined;
+    } & {
+        type: "kafka";
+    }) | ({
+        uri: string;
+        eventColumnName: string;
+    } & {
+        type: "rabbitmq";
+    }) | undefined;
+    cache: {
+        host: string;
+        port: number | undefined;
+        password: string | undefined;
+        username: string | undefined;
+        tls: boolean | undefined;
+        cluster: boolean | undefined;
+    } & {
+        type: "redis";
+    };
+    jobs: ({
+        redisConfig: {
+            host: string;
+            port: number | undefined;
+            password: string | undefined;
+            username: string | undefined;
+            tls: boolean | undefined;
+            cluster: boolean | undefined;
+        };
+        queueName: string;
+    } & {
+        type: "redis";
+    }) | undefined;
+    server: {
+        type: "fastify" | "express";
+        port: number;
+        publicPath: string | undefined;
+        healthPath: string | undefined;
+        openapi: {
+            docsVersion: string;
+            docsBaseUrl: string[];
+            docsPath: string;
+        };
+        requests: {
+            log: boolean;
+            paginationDefaultLimit: number;
+            maxFileUploadSizeInMb: number;
+            rateLimit: {
+                enabled: boolean;
+                periodInMs: number;
+                limit: number;
+            };
+            slowdown: {
+                enabled: boolean;
+                periodInMs: number;
+                delayAfter: number;
+                delayInMs: number;
+            };
+        };
+        requestsAuth: {
+            tokens: BaseTokensUtility | undefined;
+            apiKey: BaseApiKeysUtility | undefined;
+        };
+    } | undefined;
+    utils: {
+        hashSaltRounds: number;
+    };
+}, any>;
+type Settings = PipeOutput<ReturnType<typeof instanceSettingsPipe>>;
+type SettingsInput = ConditionalObjectKeys<PipeInput<ReturnType<typeof instanceSettingsPipe>>>;
+type DbTypesMap = {
+    mongo: MongoDb;
+};
+type ReshapeDbs<T extends SettingsInput> = IsInTypeList<NonNullable<T['dbs']>['types'], [unknown]> extends true ? {} : {
+    [K in keyof NonNullable<T['dbs']>['types']]: NonNullable<T['dbs']>['types'][K] extends {
+        type: keyof DbTypesMap;
+    } ? DbTypesMap[NonNullable<T['dbs']>['types'][K]['type']] : never;
+};
+type AddUndefined<T, C> = IsInTypeList<C, [undefined, unknown]> extends true ? undefined : T;
+type MapSettingsToInstance<T extends SettingsInput> = {
+    app: T['app'];
+    log: Logger<any, boolean>;
+    eventBus: AddUndefined<EventBus, T['eventBus']>;
+    cache: AddUndefined<Cache, T['cache']>;
+    jobs: AddUndefined<RedisJob, T['jobs']>;
+    server: AddUndefined<Server, T['server']>;
+    dbs: ReshapeDbs<T>;
+    utils: T['utils'];
+};
+
+declare class Instance<E extends object, S extends SettingsInput> extends DataClass<MapSettingsToInstance<S>> {
+    #private;
+    readonly envs: Readonly<E>;
+    readonly settings: Readonly<Settings>;
+    private constructor();
+    getScopedName(name: string, key?: string): string;
+    start(): Promise<void>;
+    static create<E extends object, S extends SettingsInput>(envsPipe: Pipe<unknown, E, any>, settings: (envs: E) => S): Instance<E, S>;
+    static get(): Instance<object, {
+        app: {
+            id: string;
+            name: string;
+        };
+        cache: {
+            host: string;
+            type: "redis";
+            port?: number | undefined;
+            password?: string | undefined;
+            username?: string | undefined;
+            tls?: boolean | undefined;
+            cluster?: boolean | undefined;
+        };
+        log?: {
+            level?: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "silent" | undefined;
+        } | undefined;
+        dbs?: {
+            types: {
+                [x: string]: {
+                    uri: string;
+                    type: "mongo";
+                };
+            };
+            changes?: {
+                debeziumUrl: string;
+                kafkaConfig: {
+                    brokers: string[];
+                    ssl?: boolean | undefined;
+                    sasl?: {
+                        mechanism: "plain";
+                        username: string;
+                        password: string;
+                    } | undefined;
+                    confluent?: boolean | undefined;
+                    clientId?: string | undefined;
+                };
+            } | undefined;
+        } | undefined;
+        eventBus?: {
+            brokers: string[];
+            type: "kafka";
+            ssl?: boolean | undefined;
+            sasl?: {
+                mechanism: "plain";
+                username: string;
+                password: string;
+            } | undefined;
+            confluent?: boolean | undefined;
+            clientId?: string | undefined;
+        } | {
+            uri: string;
+            eventColumnName: string;
+            type: "rabbitmq";
+        } | undefined;
+        jobs?: {
+            redisConfig: {
+                host: string;
+                port?: number | undefined;
+                password?: string | undefined;
+                username?: string | undefined;
+                tls?: boolean | undefined;
+                cluster?: boolean | undefined;
+            };
+            queueName: string;
+            type: "redis";
+        } | undefined;
+        server?: {
+            type: "fastify" | "express";
+            port: number;
+            publicPath?: string | undefined;
+            healthPath?: string | undefined;
+            openapi?: {
+                docsVersion?: string | undefined;
+                docsBaseUrl?: string[] | undefined;
+                docsPath?: string | undefined;
+            } | undefined;
+            requests?: {
+                log?: boolean | undefined;
+                paginationDefaultLimit?: number | undefined;
+                maxFileUploadSizeInMb?: number | 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;
+            requestsAuth?: {
+                tokens?: {
+                    createAccessToken: {};
+                    createRefreshToken: {};
+                    verifyAccessToken: {};
+                    verifyRefreshToken: {};
+                    retrieveAccessTokenFor: {};
+                    retrieveRefreshTokenFor: {};
+                    deleteAccessTokenFor: {};
+                    deleteRefreshTokenFor: {};
+                    extractAccessTokenValue: {};
+                    exchangeTokens: {};
+                } | undefined;
+                apiKey?: {
+                    verifyApiKey: {};
+                } | undefined;
+            } | undefined;
+        } | undefined;
+        utils?: {
+            hashSaltRounds?: number | undefined;
+        } | undefined;
+    }>;
+    static on(event: HookEvent, cb: HookCb, order: number): void;
+    static resolveBeforeCrash<T>(cb: () => Promise<T>): Promise<T>;
+    static crash(error: EquippedError): never;
+}
+
+export { BaseApiKeysUtility as B, CacheTokensUtility as C, Instance as I, type OnJoinFn as O, Router as R, Server as S, type ServerConfig as a, BaseTokensUtility as b, type SocketCallbacks as c, SocketEmitter as d, serverPipe as s };