@bool-ts/core 1.9.0 → 1.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bool-ts/core",
-    "version": "1.9.0",
+    "version": "1.9.2",
     "description": "",
     "main": "dist/index.js",
     "scripts": {
@@ -21,12 +21,12 @@
         "@bool-ts/date-time": "^1.0.0",
         "qs": "^6.14.0",
         "reflect-metadata": "^0.2.2",
-        "zod": "^3.24.1"
+        "zod": "^3.24.2"
     },
     "devDependencies": {
         "@types/bun": "latest",
         "@types/qs": "^6.9.18",
-        "typescript": "^5.7.3"
+        "typescript": "^5.8.2"
     },
     "private": "false"
 }

package/src/decorators/arguments.ts

@@ -2,6 +2,7 @@ import * as Zod from "zod";
 import {
     argumentsKey,
     contextArgsKey,
+    httpServerArgsKey,
     paramArgsKey,
     paramsArgsKey,
     queryArgsKey,
@@ -64,17 +65,25 @@ export type TArgumentsMetadata =
     | {
           index: number;
           type: typeof routeModelArgsKey;
+      }
+    | {
+          index: number;
+          type: typeof httpServerArgsKey;
       };
 
+export type TArgumentsMetadataCollection = Record<`argumentIndexes.${number}`, TArgumentsMetadata>;
+
 export const RequestHeaders =
-    (schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const requestHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        requestHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: requestHeadersArgsKey,
             zodSchema: schema
@@ -85,18 +94,20 @@ export const RequestHeaders =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, requestHeadersMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const RequestHeader =
-    (key: string, schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (key: string, schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const requestHeaderMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        requestHeaderMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: requestHeaderArgsKey,
             key: key,
@@ -108,7 +119,7 @@ export const RequestHeader =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, requestHeaderMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const RequestBody =
@@ -118,9 +129,10 @@ export const RequestBody =
             return;
         }
 
-        const bodyMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        bodyMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: requestBodyArgsKey,
             zodSchema: schema,
@@ -132,18 +144,20 @@ export const RequestBody =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, bodyMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const Params =
-    (schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const paramsMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: paramsArgsKey,
             zodSchema: schema
@@ -154,18 +168,20 @@ export const Params =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, paramsMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const Param =
-    (key: string, schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (key: string, schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const paramMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        paramMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: paramArgsKey,
             key: key,
@@ -177,18 +193,20 @@ export const Param =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, paramMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const Query =
-    (schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: queryArgsKey,
             zodSchema: schema
@@ -199,18 +217,20 @@ export const Query =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const Request =
-    (schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const requestMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        requestMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: requestArgsKey,
             zodSchema: schema
@@ -221,66 +241,95 @@ export const Request =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, requestMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
-export const ResponseHeaders = () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-    if (!methodName) {
-        return;
-    }
+export const ResponseHeaders =
+    () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-    const responseHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        metadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: responseHeadersArgsKey
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: typeof responseHeadersArgsKey;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
+    };
 
-    responseHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
-        index: parameterIndex,
-        type: responseHeadersArgsKey
-    } satisfies Extract<
-        TArgumentsMetadata,
-        {
-            type: typeof responseHeadersArgsKey;
+export const Context =
+    (key?: symbol) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
         }
-    >;
-
-    Reflect.defineMetadata(argumentsKey, responseHeadersMetadata, target.constructor, methodName);
-};
-
-export const Context = (key?: symbol) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-    if (!methodName) {
-        return;
-    }
-
-    const responseHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
-
-    responseHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
-        index: parameterIndex,
-        type: contextArgsKey,
-        key: key
-    } satisfies Extract<
-        TArgumentsMetadata,
-        {
-            type: typeof contextArgsKey;
+
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
+        metadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: contextArgsKey,
+            key: key
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: typeof contextArgsKey;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
+    };
+
+export const RouteModel =
+    () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
         }
-    >;
 
-    Reflect.defineMetadata(argumentsKey, responseHeadersMetadata, target.constructor, methodName);
-};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-export const RouteModel = () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-    if (!methodName) {
-        return;
-    }
+        metadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: routeModelArgsKey
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: typeof routeModelArgsKey;
+            }
+        >;
 
-    const responseHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
+    };
 
-    responseHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
-        index: parameterIndex,
-        type: routeModelArgsKey
-    } satisfies Extract<
-        TArgumentsMetadata,
-        {
-            type: typeof routeModelArgsKey;
+export const HttpServer =
+    () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
         }
-    >;
 
-    Reflect.defineMetadata(argumentsKey, responseHeadersMetadata, target.constructor, methodName);
-};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
+        metadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: httpServerArgsKey
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: typeof httpServerArgsKey;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
+    };

package/src/decorators/container.ts

@@ -0,0 +1,94 @@
+import type { IModule } from "../interfaces";
+
+import { containerKey, guardKey, injectableKey, middlewareKey, moduleKey } from "../keys";
+
+type TInstances = Array<new (...args: any[]) => any>;
+type TLoaders<TConfig extends {} = {}> = Record<
+    string | symbol,
+    (args: { config: TConfig }) => [string | symbol, any] | Promise<[string | symbol, any]>
+>;
+export type TContainerConfig<TConfig> =
+    | TConfig
+    | (() => TConfig | Promise<TConfig>)
+    | Readonly<{
+          key: symbol;
+          value: TConfig | (() => TConfig | Promise<TConfig>);
+      }>;
+
+export type TContainerOptions<TConfig extends {} = {}> =
+    | Partial<{
+          config: TContainerConfig<TConfig>;
+          modules: TInstances;
+          dependencies: TInstances;
+          loaders: TLoaders<TConfig>;
+          middlewares: TInstances;
+          guards: TInstances;
+      }>
+    | undefined;
+
+export type TContainerMetadata<TConfig extends {} = {}> =
+    | Partial<{
+          modules: TInstances;
+          config: TContainerConfig<TConfig>;
+          dependencies: TInstances;
+          loaders: TLoaders<TConfig>;
+          middlewares: TInstances;
+          guards: TInstances;
+      }>
+    | undefined;
+
+export const Container =
+    <TConfig extends {} = {}>(args?: TContainerOptions<TConfig>) =>
+    <T extends { new (...args: any[]): IModule }>(target: T) => {
+        const { modules, middlewares, guards, dependencies } = args || {};
+
+        if (Reflect.hasOwnMetadata(moduleKey, target)) {
+            throw new Error(
+                `Conflict detected! ${target.name} class cannot be both a Module and a Container.`
+            );
+        }
+
+        if (modules) {
+            for (let i = 0; i < modules.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(modules[i]).includes(moduleKey)) {
+                    throw Error(`${modules[i].name} is not a module.`);
+                }
+            }
+        }
+
+        if (middlewares) {
+            for (let i = 0; i < middlewares.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(middlewares[i]).includes(middlewareKey)) {
+                    throw Error(`${middlewares[i].name} is not a middleware.`);
+                }
+            }
+        }
+
+        if (middlewares) {
+            for (let i = 0; i < middlewares.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(middlewares[i]).includes(middlewareKey)) {
+                    throw Error(`${middlewares[i].name} is not a middleware.`);
+                }
+            }
+        }
+
+        if (guards) {
+            for (let i = 0; i < guards.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(guards[i]).includes(guardKey)) {
+                    throw Error(`${guards[i].name} is not a guard.`);
+                }
+            }
+        }
+
+        if (dependencies) {
+            for (let i = 0; i < dependencies.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(dependencies[i]).includes(injectableKey)) {
+                    throw Error(`${dependencies[i].name} is not an injectable.`);
+                }
+            }
+        }
+
+        Reflect.defineMetadata(containerKey, args, target);
+    };
+
+export default Container;

package/src/decorators/controller.ts

@@ -13,7 +13,7 @@ export const Controller =
     <T extends { new (...args: any[]): IController }>(target: T) => {
         const metadata: TControllerMetadata = {
             prefix: !prefix?.startsWith("/") ? `/${prefix || ""}` : prefix,
-            httpMetadata: [...(Reflect.getOwnMetadata(controllerHttpKey, target.constructor) || [])]
+            httpMetadata: [...(Reflect.getOwnMetadata(controllerHttpKey, target) || [])]
         };
 
         Reflect.defineMetadata(controllerKey, metadata, target);

package/src/decorators/http.ts

@@ -1,10 +1,13 @@
-import { controllerHttpKey } from "../keys";
+import type { TArgumentsMetadataCollection } from "./arguments";
+
+import { argumentsKey, controllerHttpKey } from "../keys";
 
 export type TRoute = {
     path: string;
     httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
     methodName: string;
     descriptor: TypedPropertyDescriptor<any>;
+    argumentsMetadata: TArgumentsMetadataCollection;
 };
 
 export type THttpMetadata = Array<TRoute>;
@@ -16,13 +19,17 @@ const defaultDecorator =
             throw Error(`${method} decorator only use for class method.`);
         }
 
+        const argumentsMetadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
         const metadata: THttpMetadata = [
             ...(Reflect.getOwnMetadata(controllerHttpKey, target.constructor) || []),
             {
                 path: !path.startsWith("/") ? `/${path}` : path,
                 httpMethod: method.toUpperCase(),
                 methodName: methodName,
-                descriptor: descriptor
+                descriptor: descriptor,
+                argumentsMetadata: argumentsMetadata
             }
         ];
 

package/src/decorators/index.ts

@@ -1,5 +1,6 @@
 export {
     Context,
+    HttpServer,
     Param,
     Params,
     Query,
@@ -10,6 +11,7 @@ export {
     ResponseHeaders,
     RouteModel
 } from "./arguments";
+export { Container } from "./container";
 export { Controller } from "./controller";
 export { Dispatcher } from "./dispatcher";
 export { Guard } from "./guard";
@@ -29,11 +31,12 @@ export { WebSocketEvent } from "./webSocketEvent";
 export { ZodSchema } from "./zodSchema";
 
 export type { TArgumentsMetadata } from "./arguments";
+export type { TContainerConfig, TContainerMetadata, TContainerOptions } from "./container";
 export type { TControllerMetadata } from "./controller";
 export type { TDispatcherMetadata } from "./dispatcher";
 export type { TGuardMetadata } from "./guard";
 export type { THttpMetadata } from "./http";
 export type { TMiddlewareMetadata } from "./middleware";
-export type { TModuleMetadata, TModuleOptions } from "./module";
+export type { TModuleConfig, TModuleMetadata, TModuleOptions } from "./module";
 export type { TWebSocketMetadata } from "./webSocket";
 export type { TWebSocketEventHandlerMetadata, TWebSocketEventMetadata } from "./webSocketEvent";

package/src/decorators/module.ts

@@ -1,16 +1,32 @@
 import type { IModule } from "../interfaces";
 
-import { controllerKey, dispatcherKey, guardKey, injectableKey, middlewareKey, moduleKey, webSocketKey } from "../keys";
+import {
+    containerKey,
+    controllerKey,
+    dispatcherKey,
+    guardKey,
+    injectableKey,
+    middlewareKey,
+    moduleKey,
+    webSocketKey
+} from "../keys";
 
 type TInstances = Array<new (...args: any[]) => any>;
 type TLoaders<TConfig extends {} = {}> = Record<
     string | symbol,
     (args: { config: TConfig }) => [string | symbol, any] | Promise<[string | symbol, any]>
 >;
+export type TModuleConfig<TConfig> =
+    | TConfig
+    | (() => TConfig | Promise<TConfig>)
+    | Readonly<{
+          key: symbol;
+          value: TConfig | (() => TConfig | Promise<TConfig>);
+      }>;
 
 export type TModuleOptions<TConfig extends {} = {}> =
     | Partial<{
-          config: TConfig | (() => TConfig | Promise<TConfig>);
+          config: TModuleConfig<TConfig>;
           prefix: string;
           dependencies: TInstances;
           loaders: TLoaders<TConfig>;
@@ -24,7 +40,7 @@ export type TModuleOptions<TConfig extends {} = {}> =
 
 export type TModuleMetadata<TConfig extends {} = {}> =
     | Partial<{
-          config: TConfig | ((...args: any[]) => TConfig | Promise<TConfig>);
+          config: TModuleConfig<TConfig>;
           prefix: string;
           dependencies: TInstances;
           loaders: TLoaders<TConfig>;
@@ -39,7 +55,14 @@ export type TModuleMetadata<TConfig extends {} = {}> =
 export const Module =
     <TConfig extends {} = {}>(args?: TModuleOptions<TConfig>) =>
     <T extends { new (...args: any[]): IModule }>(target: T) => {
-        const { middlewares, guards, dispatchers, controllers, dependencies, webSockets } = args || {};
+        if (Reflect.hasOwnMetadata(containerKey, target)) {
+            throw new Error(
+                `Conflict detected! ${target.name} class cannot be both a Module and a Container.`
+            );
+        }
+
+        const { middlewares, guards, dispatchers, controllers, dependencies, webSockets } =
+            args || {};
 
         if (middlewares) {
             for (let i = 0; i < middlewares.length; i++) {

package/src/decorators/webSocket.ts

@@ -1,5 +1,6 @@
 import type { Server } from "bun";
 import type { IWebSocket } from "../interfaces";
+import type { TArgumentsMetadataCollection } from "./arguments";
 import type { TWebSocketEventMetadata } from "./webSocketEvent";
 
 import { webSocketEventKey, webSocketKey } from "../keys";
@@ -9,6 +10,7 @@ export type TWebSocketHttpRouteMetadata = {
     httpMethod: "GET" | "POST";
     methodName: symbol;
     descriptor: PropertyDescriptor;
+    argumentsMetadata: TArgumentsMetadataCollection;
 };
 
 export type TWebSocketUpgradeData = {
@@ -59,13 +61,15 @@ export const WebSocket =
                       path: "/",
                       httpMethod: "GET",
                       methodName: upgradeHandlerSymbol,
-                      descriptor: descriptor
+                      descriptor: descriptor,
+                      argumentsMetadata: {}
                   },
                   {
                       path: "/",
                       httpMethod: "POST",
                       methodName: upgradeHandlerSymbol,
-                      descriptor: descriptor
+                      descriptor: descriptor,
+                      argumentsMetadata: {}
                   }
               ];
 

package/src/entities/httpRoute.ts

@@ -1,11 +1,13 @@
 "use strict";
 
+import type { TArgumentsMetadataCollection } from "../decorators/arguments";
 import type { THttpMethods } from "../http";
 
 export type THttpRouteModel<T = unknown> = Readonly<{
     class: new (...args: Array<any>) => T;
     funcName: string | symbol;
     func: (...args: Array<any>) => unknown;
+    argumentsMetadata: TArgumentsMetadataCollection;
 }>;
 
 export class HttpRoute {

package/src/index.ts

@@ -3,7 +3,7 @@ import "reflect-metadata";
 export type { THttpRouteModel } from "./entities";
 
 export * from "./decorators";
-export * from "./hooks";
 export * from "./http";
 export * from "./interfaces";
 export * as Keys from "./keys";
+export * from "./producers";

package/src/interfaces/context.ts

@@ -1,4 +1,11 @@
+export type TContextOptions = Partial<{
+    isStatic: boolean;
+    isPassthrough: boolean;
+}>;
+
 export interface IContext {
-    get: (key: symbol) => any;
-    set: (key: symbol, value: any) => void;
+    get: <T = unknown>(key: symbol, options?: TContextOptions) => T;
+    has: (key: symbol, options?: TContextOptions) => boolean;
+    set: <T = unknown>(key: symbol, value: T, options?: TContextOptions) => ThisType<IContext>;
+    setOptions: (options: TContextOptions) => ThisType<IContext>;
 }

package/src/interfaces/index.ts

@@ -1,4 +1,4 @@
-export type { IContext } from "./context";
+export type { IContext, TContextOptions } from "./context";
 export type { IController } from "./controller";
 export type { IDispatcher } from "./dispatcher";
 export type { IGuard } from "./guard";