@bool-ts/core 1.6.1 → 1.6.2

package/__test/controller.ts

@@ -33,7 +33,12 @@ const stringSchema = Zod.object({}).refine(async (val) => {
 
 @Controller("test")
 export class TestController {
-    constructor(@Inject(TestService) private readonly testService: IService) {}
+    constructor(
+        @Inject(Symbol.for("etst")) private readonly testInject: any,
+        @Inject(TestService) private readonly testService: IService
+    ) {
+        console.log("testInject", testInject);
+    }
 
     @Get("abc/:id")
     public get(@Param("id") id: string) {

package/__test/module.ts

@@ -9,7 +9,17 @@ import { TestRepository } from "./repository";
 import { TestService } from "./service";
 import { SecondGuard } from "./secondGuard";
 
-@Module({
+@Module<{
+    mongodb: string;
+}>({
+    config: {
+        mongodb: "123"
+    },
+    loaders: {
+        mongodb: ({ config }) => {
+            return [Symbol.for("etst"), { hehe: "435345" }];
+        }
+    },
     middlewares: [FirstMiddleware, SecondMiddleware],
     guards: [FirstGuard, SecondGuard],
     beforeDispatchers: [BeforeDispatcher],
@@ -18,5 +28,3 @@ import { SecondGuard } from "./secondGuard";
     dependencies: [TestService, TestRepository]
 })
 export class TestModule {}
-
-export default TestModule;

package/dist/decorators/arguments.d.ts

@@ -1,50 +1,39 @@
 import * as Zod from "zod";
-export declare enum EArgumentTypes {
-    requestHeaders = "REQUEST_HEADERS",
-    body = "BODY",
-    params = "PARAMS",
-    param = "PARAM",
-    query = "QUERY",
-    request = "REQUEST",
-    responseHeaders = "RESPONSE_HEADERS",
-    config = "CONFIG"
-}
+import { bodyArgsKey, contextArgsKey, paramArgsKey, paramsArgsKey, queryArgsKey, requestArgsKey, requestHeadersArgsKey, responseHeadersArgsKey } from "../keys";
 export type TArgumentsMetadata = {
     index: number;
-    type: EArgumentTypes.requestHeaders;
+    type: typeof requestHeadersArgsKey;
     zodSchema?: Zod.Schema;
 } | {
     index: number;
-    type: EArgumentTypes.body;
+    type: typeof bodyArgsKey;
     zodSchema?: Zod.Schema;
     parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text";
 } | {
     index: number;
-    type: EArgumentTypes.params;
+    type: typeof paramsArgsKey;
     zodSchema?: Zod.Schema;
 } | {
     index: number;
-    type: EArgumentTypes.param;
+    type: typeof paramArgsKey;
     key: string;
     zodSchema?: Zod.Schema;
 } | {
     index: number;
-    type: EArgumentTypes.query;
+    type: typeof queryArgsKey;
     zodSchema?: Zod.Schema;
 } | {
     index: number;
-    type: EArgumentTypes.request;
+    type: typeof requestArgsKey;
     zodSchema?: Zod.Schema;
 } | {
     index: number;
-    type: EArgumentTypes.responseHeaders;
+    type: typeof responseHeadersArgsKey;
     zodSchema?: Zod.Schema;
 } | {
     index: number;
-    type: EArgumentTypes.config;
-    zodSchema?: Zod.Schema;
+    type: typeof contextArgsKey;
 };
-export declare const argumentsKey: unique symbol;
 export declare const RequestHeaders: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
 export declare const Body: (zodSchema?: Zod.Schema, parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text") => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
 export declare const Params: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
@@ -52,4 +41,4 @@ export declare const Param: (key: string, zodSchema?: Zod.Schema) => (target: Ob
 export declare const Query: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
 export declare const Request: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
 export declare const ResponseHeaders: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
-export declare const Config: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const Context: () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;

package/dist/decorators/arguments.js

@@ -1,44 +1,29 @@
 import * as Zod from "zod";
-export var EArgumentTypes;
-(function (EArgumentTypes) {
-    EArgumentTypes["requestHeaders"] = "REQUEST_HEADERS";
-    EArgumentTypes["body"] = "BODY";
-    EArgumentTypes["params"] = "PARAMS";
-    EArgumentTypes["param"] = "PARAM";
-    EArgumentTypes["query"] = "QUERY";
-    EArgumentTypes["request"] = "REQUEST";
-    EArgumentTypes["responseHeaders"] = "RESPONSE_HEADERS";
-    EArgumentTypes["config"] = "CONFIG";
-})(EArgumentTypes || (EArgumentTypes = {}));
-export const argumentsKey = Symbol.for("__bool:arguments__");
-export const RequestHeaders = (zodSchema) => {
-    return (target, methodName, parameterIndex) => {
-        if (!methodName) {
-            return;
-        }
-        const headersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
-        headersMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.requestHeaders,
-            zodSchema: zodSchema
-        };
-        Reflect.defineMetadata(argumentsKey, headersMetadata, target.constructor, methodName);
+import { argumentsKey, bodyArgsKey, contextArgsKey, paramArgsKey, paramsArgsKey, queryArgsKey, requestArgsKey, requestHeadersArgsKey, responseHeadersArgsKey } from "../keys";
+export const RequestHeaders = (zodSchema) => (target, methodName, parameterIndex) => {
+    if (!methodName) {
+        return;
+    }
+    const requestHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+    requestHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
+        index: parameterIndex,
+        type: requestHeadersArgsKey,
+        zodSchema: zodSchema
     };
+    Reflect.defineMetadata(argumentsKey, requestHeadersMetadata, target.constructor, methodName);
 };
-export const Body = (zodSchema, parser) => {
-    return (target, methodName, parameterIndex) => {
-        if (!methodName) {
-            return;
-        }
-        const bodyMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
-        bodyMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.body,
-            zodSchema: zodSchema,
-            parser: parser
-        };
-        Reflect.defineMetadata(argumentsKey, bodyMetadata, target.constructor, methodName);
+export const Body = (zodSchema, parser) => (target, methodName, parameterIndex) => {
+    if (!methodName) {
+        return;
+    }
+    const bodyMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+    bodyMetadata[`argumentIndexes.${parameterIndex}`] = {
+        index: parameterIndex,
+        type: bodyArgsKey,
+        zodSchema: zodSchema,
+        parser: parser
     };
+    Reflect.defineMetadata(argumentsKey, bodyMetadata, target.constructor, methodName);
 };
 export const Params = (zodSchema) => (target, methodName, parameterIndex) => {
     if (!methodName) {
@@ -47,79 +32,68 @@ export const Params = (zodSchema) => (target, methodName, parameterIndex) => {
     const paramsMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
     paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
         index: parameterIndex,
-        type: EArgumentTypes.params,
+        type: paramsArgsKey,
         zodSchema: zodSchema
     };
     Reflect.defineMetadata(argumentsKey, paramsMetadata, target.constructor, methodName);
 };
-export const Param = (key, zodSchema) => {
-    return (target, methodName, parameterIndex) => {
-        if (!methodName) {
-            return;
-        }
-        const paramsMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
-        paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.param,
-            key: key,
-            zodSchema: zodSchema
-        };
-        Reflect.defineMetadata(argumentsKey, paramsMetadata, target.constructor, methodName);
+export const Param = (key, zodSchema) => (target, methodName, parameterIndex) => {
+    if (!methodName) {
+        return;
+    }
+    const paramMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+    paramMetadata[`argumentIndexes.${parameterIndex}`] = {
+        index: parameterIndex,
+        type: paramArgsKey,
+        key: key,
+        zodSchema: zodSchema
     };
+    Reflect.defineMetadata(argumentsKey, paramMetadata, target.constructor, methodName);
 };
-export const Query = (zodSchema) => {
-    return (target, methodName, parameterIndex) => {
-        if (!methodName) {
-            return;
-        }
-        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
-        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.query,
-            zodSchema: zodSchema
-        };
-        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+export const Query = (zodSchema) => (target, methodName, parameterIndex) => {
+    if (!methodName) {
+        return;
+    }
+    const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+    queryMetadata[`argumentIndexes.${parameterIndex}`] = {
+        index: parameterIndex,
+        type: queryArgsKey,
+        zodSchema: zodSchema
     };
+    Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
 };
-export const Request = (zodSchema) => {
-    return (target, methodName, parameterIndex) => {
-        if (!methodName) {
-            return;
-        }
-        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
-        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.request,
-            zodSchema: zodSchema
-        };
-        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+export const Request = (zodSchema) => (target, methodName, parameterIndex) => {
+    if (!methodName) {
+        return;
+    }
+    const requestMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+    requestMetadata[`argumentIndexes.${parameterIndex}`] = {
+        index: parameterIndex,
+        type: requestArgsKey,
+        zodSchema: zodSchema
     };
+    Reflect.defineMetadata(argumentsKey, requestMetadata, target.constructor, methodName);
 };
-export const ResponseHeaders = (zodSchema) => {
-    return (target, methodName, parameterIndex) => {
-        if (!methodName) {
-            return;
-        }
-        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
-        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.responseHeaders,
-            zodSchema: zodSchema
-        };
-        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+export const ResponseHeaders = (zodSchema) => (target, methodName, parameterIndex) => {
+    if (!methodName) {
+        return;
+    }
+    const responseHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+    responseHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
+        index: parameterIndex,
+        type: responseHeadersArgsKey,
+        zodSchema: zodSchema
     };
+    Reflect.defineMetadata(argumentsKey, responseHeadersMetadata, target.constructor, methodName);
 };
-export const Config = (zodSchema) => {
-    return (target, methodName, parameterIndex) => {
-        if (!methodName) {
-            return;
-        }
-        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
-        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.config,
-            zodSchema: zodSchema
-        };
-        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+export const Context = () => (target, methodName, parameterIndex) => {
+    if (!methodName) {
+        return;
+    }
+    const responseHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+    responseHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
+        index: parameterIndex,
+        type: contextArgsKey
     };
+    Reflect.defineMetadata(argumentsKey, responseHeadersMetadata, target.constructor, methodName);
 };

package/dist/decorators/controller.d.ts

@@ -4,7 +4,6 @@ export type TControllerMetadata = Required<{
     prefix: string;
     httpMetadata: THttpMetadata;
 }>;
-export declare const controllerKey: unique symbol;
 export declare const Controller: (prefix: string) => <T extends {
     new (...args: any[]): IController;
 }>(target: T) => void;

package/dist/decorators/controller.js

@@ -1,5 +1,5 @@
-import { controllerHttpKey } from "./http";
-export const controllerKey = Symbol.for("__bool:controller__");
+import { controllerHttpKey, controllerKey } from "../keys";
+import {} from "./http";
 export const Controller = (prefix) => (target) => {
     const metadata = {
         prefix: !prefix.startsWith("/") ? `/${prefix}` : prefix,

package/dist/decorators/dispatcher.d.ts

@@ -1,6 +1,5 @@
 import type { IDispatcher } from "../interfaces/dispatcher";
 export type TDispatcherMetadata = undefined;
-export declare const dispatcherKey: unique symbol;
 export declare const Dispatcher: () => <T extends {
     new (...args: any[]): IDispatcher;
 }>(target: T) => void;

package/dist/decorators/dispatcher.js

@@ -1,4 +1,4 @@
-export const dispatcherKey = Symbol.for("__bool:dispatcher__");
+import { dispatcherKey } from "../keys";
 export const Dispatcher = () => (target) => {
     if (!("execute" in target.prototype) || typeof target.prototype.execute !== "function") {
         return;

package/dist/decorators/guard.d.ts

@@ -1,6 +1,5 @@
 import type { IGuard } from "../interfaces";
 export type TGuardMetadata = undefined;
-export declare const guardKey: unique symbol;
 export declare const Guard: () => <T extends {
     new (...args: any[]): IGuard;
 }>(target: T) => void;

package/dist/decorators/guard.js

@@ -1,4 +1,4 @@
-export const guardKey = Symbol.for("__bool:guard__");
+import { guardKey } from "../keys";
 export const Guard = () => (target) => {
     if (!("enforce" in target.prototype) || typeof target.prototype.enforce !== "function") {
         return;

package/dist/decorators/http.d.ts

@@ -5,7 +5,6 @@ export type TRoute = {
     descriptor: PropertyDescriptor;
 };
 export type THttpMetadata = Array<TRoute>;
-export declare const controllerHttpKey: unique symbol;
 /**
  *
  * @param path

package/dist/decorators/http.js

@@ -1,4 +1,4 @@
-export const controllerHttpKey = Symbol.for("__bool:controller.http__");
+import { controllerHttpKey } from "../keys";
 const defaultDecorator = (path, method) => (target, methodName, descriptor) => {
     if (!(descriptor.value instanceof Function)) {
         throw Error(`${method} decorator only use for class method.`);

package/dist/decorators/index.d.ts

@@ -1,13 +1,13 @@
-export { Body, Config, Params, Param, Query, Request, RequestHeaders, ResponseHeaders, EArgumentTypes, argumentsKey } from "./arguments";
-export { Controller, controllerKey } from "./controller";
-export { Guard, guardKey } from "./guard";
-export { Inject, injectKey } from "./inject";
-export { Injectable, injectableKey } from "./injectable";
-export { Middleware, middlewareKey } from "./middleware";
-export { Module, moduleKey } from "./module";
-export { Get, Post, Put, Patch, Delete, Options, controllerHttpKey } from "./http";
-export { ZodSchema, controllerRouteZodSchemaKey } from "./zodSchema";
-export { Dispatcher, dispatcherKey } from "./dispatcher";
+export { Body, Params, Param, Query, Request, RequestHeaders, ResponseHeaders } from "./arguments";
+export { Controller } from "./controller";
+export { Guard } from "./guard";
+export { Inject } from "./inject";
+export { Injectable } from "./injectable";
+export { Middleware } from "./middleware";
+export { Module } from "./module";
+export { Get, Post, Put, Patch, Delete, Options } from "./http";
+export { ZodSchema } from "./zodSchema";
+export { Dispatcher } from "./dispatcher";
 export type { TControllerMetadata } from "./controller";
 export type { TModuleMetadata, TModuleOptions } from "./module";
 export type { THttpMetadata } from "./http";

package/dist/decorators/index.js

@@ -1,10 +1,10 @@
-export { Body, Config, Params, Param, Query, Request, RequestHeaders, ResponseHeaders, EArgumentTypes, argumentsKey } from "./arguments";
-export { Controller, controllerKey } from "./controller";
-export { Guard, guardKey } from "./guard";
-export { Inject, injectKey } from "./inject";
-export { Injectable, injectableKey } from "./injectable";
-export { Middleware, middlewareKey } from "./middleware";
-export { Module, moduleKey } from "./module";
-export { Get, Post, Put, Patch, Delete, Options, controllerHttpKey } from "./http";
-export { ZodSchema, controllerRouteZodSchemaKey } from "./zodSchema";
-export { Dispatcher, dispatcherKey } from "./dispatcher";
+export { Body, Params, Param, Query, Request, RequestHeaders, ResponseHeaders } from "./arguments";
+export { Controller } from "./controller";
+export { Guard } from "./guard";
+export { Inject } from "./inject";
+export { Injectable } from "./injectable";
+export { Middleware } from "./middleware";
+export { Module } from "./module";
+export { Get, Post, Put, Patch, Delete, Options } from "./http";
+export { ZodSchema } from "./zodSchema";
+export { Dispatcher } from "./dispatcher";

package/dist/decorators/inject.d.ts

@@ -1,5 +1,4 @@
-export declare const injectKey = "design:paramtypes";
-export declare const Inject: <T extends Object>(classDefinition: {
+export declare const Inject: <T extends Object>(definition: {
     new (...args: any[]): T;
-}) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
+} | string | symbol) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
 export default Inject;

package/dist/decorators/inject.js

@@ -1,8 +1,8 @@
-export const injectKey = "design:paramtypes";
-export const Inject = (classDefinition) => {
+import { injectKey } from "../keys";
+export const Inject = (definition) => {
     return (target, methodName, parameterIndex) => {
         const designParameterTypes = Reflect.getMetadata(injectKey, target) || [];
-        designParameterTypes[parameterIndex] = classDefinition;
+        designParameterTypes[parameterIndex] = definition;
         Reflect.defineMetadata(injectKey, designParameterTypes, target);
     };
 };

package/dist/decorators/injectable.d.ts

@@ -1,3 +1,2 @@
-export declare const injectableKey: unique symbol;
 export declare const Injectable: () => <T extends Object>(target: T) => void;
 export default Injectable;

package/dist/decorators/injectable.js

@@ -1,3 +1,3 @@
-export const injectableKey = Symbol.for("__bool:injectable__");
+import { injectableKey } from "../keys";
 export const Injectable = () => (target) => Reflect.defineMetadata(injectableKey, undefined, target);
 export default Injectable;

package/dist/decorators/middleware.d.ts

@@ -1,6 +1,5 @@
 import type { IMiddleware } from "../interfaces";
 export type TMiddlewareMetadata = undefined;
-export declare const middlewareKey: unique symbol;
 export declare const Middleware: () => <T extends {
     new (...args: any[]): IMiddleware;
 }>(target: T) => void;

package/dist/decorators/middleware.js

@@ -1,4 +1,4 @@
-export const middlewareKey = Symbol.for("__bool:middleware__");
+import { middlewareKey } from "../keys";
 export const Middleware = () => (target) => {
     if (!("enforce" in target.prototype) || typeof target.prototype.enforce !== "function") {
         return;

package/dist/decorators/module.d.ts

@@ -1,27 +1,31 @@
 import type { IModule } from "../interfaces/module";
 type TInstances = Array<new (...args: any[]) => any>;
-export type TModuleOptions = Partial<{
-    config: Record<string | symbol, any> | (() => Record<string | symbol, any> | Promise<Record<string | symbol, any>>);
+type TLoaders<TConfig extends {} = {}> = Record<string | symbol, (args: {
+    config: TConfig;
+}) => [string | symbol, any] | Promise<[string | symbol, any]>>;
+export type TModuleOptions<TConfig extends {} = {}> = Partial<{
+    config: TConfig | (() => TConfig | Promise<TConfig>);
     prefix: string;
     dependencies: TInstances;
-    controllers: TInstances;
+    loaders: TLoaders<TConfig>;
     middlewares: TInstances;
     guards: TInstances;
     beforeDispatchers: TInstances;
+    controllers: TInstances;
     afterDispatchers: TInstances;
 }> | undefined;
-export type TModuleMetadata = Partial<{
-    config: Record<string | symbol, any> | (() => Record<string | symbol, any> | Promise<Record<string | symbol, any>>);
+export type TModuleMetadata<TConfig extends {} = {}> = Partial<{
+    config: TConfig | ((...args: any[]) => TConfig | Promise<TConfig>);
     prefix: string;
-    controllers: TInstances;
     dependencies: TInstances;
+    loaders: TLoaders<TConfig>;
     middlewares: TInstances;
     guards: TInstances;
     beforeDispatchers: TInstances;
+    controllers: TInstances;
     afterDispatchers: TInstances;
 }> | undefined;
-export declare const moduleKey: unique symbol;
-export declare const Module: (args?: TModuleOptions) => <T extends {
+export declare const Module: <TConfig extends {} = {}>(args?: TModuleOptions<TConfig>) => <T extends {
     new (...args: any[]): IModule;
 }>(target: T) => void;
 export default Module;

package/dist/decorators/module.js

@@ -1,9 +1,4 @@
-import { controllerKey } from "./controller";
-import { dispatcherKey } from "./dispatcher";
-import { guardKey } from "./guard";
-import { injectableKey } from "./injectable";
-import { middlewareKey } from "./middleware";
-export const moduleKey = Symbol.for("__bool:module__");
+import { controllerKey, dispatcherKey, guardKey, injectableKey, middlewareKey, moduleKey } from "../keys";
 export const Module = (args) => (target) => {
     const { middlewares, guards, beforeDispatchers, controllers, afterDispatchers, dependencies } = args || {};
     if (middlewares) {

package/dist/decorators/zodSchema.d.ts

@@ -1,3 +1,2 @@
 import * as Zod from "zod";
-export declare const controllerRouteZodSchemaKey: unique symbol;
 export declare const ZodSchema: (schema: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;

package/dist/decorators/zodSchema.js

@@ -1,5 +1,5 @@
 import * as Zod from "zod";
-export const controllerRouteZodSchemaKey = Symbol.for("__bool:controller.route.zodSchema__");
+import { controllerRouteZodSchemaKey } from "../keys";
 export const ZodSchema = (schema) => {
     return (target, methodName, parameterIndex) => {
         if (!methodName) {

package/dist/hooks/factory.d.ts

@@ -15,6 +15,6 @@ export type TBoolFactoryOptions = Required<{
     queryParser: Parameters<typeof Qs.parse>[1];
 }>;
 export declare const controllerCreator: (controllerConstructor: new (...args: any[]) => unknown, group: RouterGroup, prefix?: string) => RouterGroup;
-export declare const argumentsResolution: (data: unknown, zodSchema: Zod.Schema, argumentIndex: number, funcName: string | symbol) => Promise<any>;
+export declare const argumentsResolution: (data: unknown, zodSchema: Zod.Schema, argumentIndex: number, funcName: string | symbol) => Promise<unknown>;
 export declare const BoolFactory: (target: new (...args: any[]) => unknown, options: TBoolFactoryOptions) => Promise<import("bun").Server | undefined>;
 export default BoolFactory;