clear-router 2.5.4 → 2.5.6

package/dist/koa/index.d.mts

@@ -1,4 +1,4 @@
-import { d as ApiResourceMiddleware, f as ControllerAction, m as HttpMethod, n as ClearRequest, p as ControllerHandler, r as Route, t as CoreRouter } from "../router-_w2VzMQF.mjs";
+import { _ as ApiResourceMiddleware, b as HttpMethod, c as Request, l as Route, t as CoreRouter, v as ControllerAction, x as Response, y as ControllerHandler } from "../router-DCMtQ_Xi.mjs";
 import Koa from "koa";
 import Router$1 from "@koa/router";
 
@@ -9,10 +9,12 @@ interface RequestWithGetBody extends Koa.Request {
 }
 interface HttpContext extends Koa.Context {
   request: RequestWithGetBody;
+  clearRequest: Request;
+  clearResponse: Response;
   params: Record<string, any>;
   query: Record<string, any>;
 }
-type RouteHandler = (ctx: HttpContext, req: ClearRequest) => any | Promise<any>;
+type RouteHandler = (ctx: HttpContext, req: Request) => any | Promise<any>;
 type Handler = RouteHandler | ControllerHandler;
 type Middleware = Koa.Middleware<any, any>;
 type KoaRouterApp = Router$1<any, any>;

package/dist/koa/index.mjs

@@ -1,5 +1,6 @@
-import { t as CoreRouter } from "../router-BReOXz-F.mjs";
-import { n as resolveResponseMeta, t as isFetchResponse } from "../responses-CJaD0ugv.mjs";
+import "../bindings-DIanvIVd.mjs";
+import { t as CoreRouter } from "../router-B3QjblRX.mjs";
+import { n as resolveResponseMeta, t as isFetchResponse } from "../responses-_II3dOJ5.mjs";
 
 //#region src/koa/router.ts
 /**
@@ -43,6 +44,9 @@ var Router = class Router extends CoreRouter {
 		});
 		if (!meta) return void 0;
 		ctx.status = meta.status;
+		meta.headers?.forEach((headerValue, key) => {
+			ctx.set(key, headerValue);
+		});
 		if (isFetchResponse(meta.body)) {
 			meta.body.headers.forEach((headerValue, key) => {
 				ctx.set(key, headerValue);
@@ -179,10 +183,18 @@ var Router = class Router extends CoreRouter {
 		for (const route of this.routes) {
 			let handlerFunction = null;
 			let instance = null;
+			let bindingTarget;
+			let bindingMethod;
+			let bindingHandler;
+			let bindingMetadata;
 			try {
 				const resolved = this.resolveHandler(route);
 				handlerFunction = resolved.handlerFunction;
 				instance = resolved.instance;
+				bindingTarget = resolved.bindingTarget;
+				bindingMethod = resolved.bindingMethod;
+				bindingHandler = resolved.bindingHandler;
+				bindingMetadata = resolved.bindingMetadata;
 			} catch (error) {
 				console.error(`[ROUTES] Error setting up route ${route.path}:`, error.message);
 				throw error;
@@ -209,11 +221,13 @@ var Router = class Router extends CoreRouter {
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {}
+						params: ctx.params ?? {},
+						method
 					});
-					const result = handlerFunction(ctx, inst.clearRequest);
+					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
 					const resolved = await Promise.resolve(result);
-					return Router.sendReturnValue(ctx, resolved, method, route.path);
+					const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
+					return Router.sendReturnValue(ctx, outgoing, method, route.path);
 				});
 				if ([
 					"put",
@@ -227,11 +241,13 @@ var Router = class Router extends CoreRouter {
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {}
+						params: ctx.params ?? {},
+						method
 					});
-					const result = handlerFunction(ctx, inst.clearRequest);
+					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
 					const resolved = await Promise.resolve(result);
-					return Router.sendReturnValue(ctx, resolved, method, route.path);
+					const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
+					return Router.sendReturnValue(ctx, outgoing, method, route.path);
 				});
 			}
 		}

package/dist/{responses-B-UirWFf.cjs → responses-JzXstGU5.cjs}

@@ -1,12 +1,17 @@
+const require_bindings = require('./bindings-DvV2DXWi.cjs');
 
 //#region src/core/responses.ts
 function isFetchResponse(value) {
-	return typeof Response !== "undefined" && value instanceof Response;
+	return typeof globalThis.Response !== "undefined" && value instanceof globalThis.Response;
+}
+function isCoreResponse(value) {
+	return value instanceof require_bindings.Response;
 }
 function isH3Response(value) {
 	return Boolean(value && typeof value === "object" && value.constructor?.name === "HTTPResponse");
 }
 function responseWasSent(target) {
+	if (isCoreResponse(target)) return false;
 	return Boolean(target?.headersSent || target?.sent || target?.raw?.headersSent);
 }
 function getHeader(headers, name) {
@@ -23,6 +28,17 @@ function isApiRequest(headers, path) {
 }
 function resolveResponseMeta(value, options = {}) {
 	if (typeof value === "undefined") return void 0;
+	if (isCoreResponse(value)) {
+		const contentType = value.headers.get("content-type") || void 0;
+		return {
+			body: value.body,
+			status: value.statusCode,
+			contentType,
+			headers: value.headers,
+			isEmpty: value.body === null || typeof value.body === "undefined",
+			isNativeResponse: false
+		};
+	}
 	if (isFetchResponse(value) || isH3Response(value)) return {
 		body: value,
 		status: getStatus(value, options.method, options.status),
@@ -59,6 +75,7 @@ function resolveResponseMeta(value, options = {}) {
 	};
 }
 function getStatus(value, method, explicitStatus) {
+	if (typeof value?.statusCode === "number" && value.statusCode >= 100 && value.statusCode <= 999) return value.statusCode;
 	if (typeof value?.status === "number" && value.status >= 100 && value.status <= 999) return value.status;
 	if (typeof explicitStatus === "number" && explicitStatus >= 100 && explicitStatus <= 999) return explicitStatus;
 	return String(method || "").toLowerCase() === "post" ? 201 : 200;

package/dist/{responses-CJaD0ugv.mjs → responses-_II3dOJ5.mjs}

@@ -1,11 +1,17 @@
+import { o as Response } from "./bindings-DIanvIVd.mjs";
+
 //#region src/core/responses.ts
 function isFetchResponse(value) {
-	return typeof Response !== "undefined" && value instanceof Response;
+	return typeof globalThis.Response !== "undefined" && value instanceof globalThis.Response;
+}
+function isCoreResponse(value) {
+	return value instanceof Response;
 }
 function isH3Response(value) {
 	return Boolean(value && typeof value === "object" && value.constructor?.name === "HTTPResponse");
 }
 function responseWasSent(target) {
+	if (isCoreResponse(target)) return false;
 	return Boolean(target?.headersSent || target?.sent || target?.raw?.headersSent);
 }
 function getHeader(headers, name) {
@@ -22,6 +28,17 @@ function isApiRequest(headers, path) {
 }
 function resolveResponseMeta(value, options = {}) {
 	if (typeof value === "undefined") return void 0;
+	if (isCoreResponse(value)) {
+		const contentType = value.headers.get("content-type") || void 0;
+		return {
+			body: value.body,
+			status: value.statusCode,
+			contentType,
+			headers: value.headers,
+			isEmpty: value.body === null || typeof value.body === "undefined",
+			isNativeResponse: false
+		};
+	}
 	if (isFetchResponse(value) || isH3Response(value)) return {
 		body: value,
 		status: getStatus(value, options.method, options.status),
@@ -58,6 +75,7 @@ function resolveResponseMeta(value, options = {}) {
 	};
 }
 function getStatus(value, method, explicitStatus) {
+	if (typeof value?.statusCode === "number" && value.statusCode >= 100 && value.statusCode <= 999) return value.statusCode;
 	if (typeof value?.status === "number" && value.status >= 100 && value.status <= 999) return value.status;
 	if (typeof explicitStatus === "number" && explicitStatus >= 100 && explicitStatus <= 999) return explicitStatus;
 	return String(method || "").toLowerCase() === "post" ? 201 : 200;

package/dist/{router-BReOXz-F.mjs → router-B3QjblRX.mjs}

@@ -1,26 +1,6 @@
+import { a as getStandardMetadata, i as getDesignParamTypes, n as Container, o as Response, r as getBindingMetadataFromTargets, s as Request } from "./bindings-DIanvIVd.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 
-//#region src/ClearRequest.ts
-var ClearRequest = class {
-	/**
-	* @param body - Parsed request body
-	*/
-	body;
-	/**
-	* @param query - Parsed query parameters
-	*/
-	query;
-	/**
-	* @param params - Parsed route parameters
-	*/
-	params;
-	route;
-	constructor(init) {
-		Object.assign(this, init);
-	}
-};
-
-//#endregion
 //#region src/Route.ts
 var Route = class {
 	ctx;
@@ -60,6 +40,41 @@ var CoreRouter = class {
 	static routerStateNamespace = "clear-router:core";
 	static stateStoreKey = Symbol.for("clear-router:router-state");
 	static stateBoundKey = Symbol.for("clear-router:router-state-bound");
+	static defaultConfigKey = Symbol.for("clear-router:default-config");
+	static pluginStoreKey = Symbol.for("clear-router:plugins");
+	static createBaseConfig() {
+		return {
+			methodOverride: {
+				enabled: true,
+				bodyKeys: ["_method"],
+				headerKeys: ["x-http-method"]
+			},
+			container: {
+				enabled: false,
+				autoDiscover: false
+			}
+		};
+	}
+	static mergeConfig(target, source) {
+		if (!source) return target;
+		if (source.methodOverride) target.methodOverride = {
+			...target.methodOverride || {},
+			...source.methodOverride
+		};
+		if (source.container) target.container = {
+			...target.container || {},
+			...source.container
+		};
+		return target;
+	}
+	static getDefaultConfig() {
+		const g = globalThis;
+		if (!g[this.defaultConfigKey]) g[this.defaultConfigKey] = this.createBaseConfig();
+		return {
+			methodOverride: { ...g[this.defaultConfigKey].methodOverride },
+			container: { ...g[this.defaultConfigKey].container }
+		};
+	}
 	static resolveStateNamespace() {
 		return String(this.routerStateNamespace || this.name || "clear-router:core");
 	}
@@ -68,13 +83,14 @@ var CoreRouter = class {
 		if (!g[this.stateStoreKey]) g[this.stateStoreKey] = Object.create(null);
 		return g[this.stateStoreKey];
 	}
+	static getPluginStore() {
+		const g = globalThis;
+		if (!g[this.pluginStoreKey]) g[this.pluginStoreKey] = /* @__PURE__ */ new Set();
+		return g[this.pluginStoreKey];
+	}
 	static createDefaultState() {
 		return {
-			config: { methodOverride: {
-				enabled: true,
-				bodyKeys: ["_method"],
-				headerKeys: ["x-http-method"]
-			} },
+			config: this.getDefaultConfig(),
 			groupContext: new AsyncLocalStorage(),
 			routes: [],
 			routesByPathMethod: {},
@@ -151,11 +167,47 @@ var CoreRouter = class {
 			}
 		};
 	}
-	static config = { methodOverride: {
-		enabled: true,
-		bodyKeys: ["_method"],
-		headerKeys: ["x-http-method"]
-	} };
+	static config = {
+		methodOverride: {
+			enabled: true,
+			bodyKeys: ["_method"],
+			headerKeys: ["x-http-method"]
+		},
+		container: {
+			enabled: false,
+			autoDiscover: false
+		}
+	};
+	static configureDefaults(options) {
+		const g = globalThis;
+		const defaults = this.mergeConfig(g[this.defaultConfigKey] || this.createBaseConfig(), options);
+		g[this.defaultConfigKey] = defaults;
+		const store = this.getStateStore();
+		for (const state of Object.values(store)) state.config = this.mergeConfig(state.config || this.createBaseConfig(), options);
+	}
+	/**
+	* Use a registered plugin
+	* 
+	* @param this 
+	* @param plugin 
+	* @param options 
+	* @returns 
+	*/
+	static use(plugin, options) {
+		const name = typeof plugin === "function" ? plugin.name : plugin.name;
+		const store = this.getPluginStore();
+		if (name && store.has(name)) return;
+		const ctx = {
+			container: Container,
+			bind: Container.bind.bind(Container),
+			configure: this.configure.bind(this),
+			configureDefaults: this.configureDefaults.bind(this),
+			options
+		};
+		if (typeof plugin === "function") plugin(ctx);
+		else plugin.setup(ctx);
+		if (name) store.add(name);
+	}
 	static groupContext = new AsyncLocalStorage();
 	static routes = [];
 	static routesByPathMethod = {};
@@ -197,11 +249,12 @@ var CoreRouter = class {
 	*/
 	static configure(options) {
 		this.ensureState();
-		if (!this.config.methodOverride) this.config.methodOverride = {
-			enabled: true,
-			bodyKeys: ["_method"],
-			headerKeys: ["x-http-method"]
-		};
+		this.config = this.mergeConfig(this.getDefaultConfig(), this.config);
+		const container = options?.container;
+		if (container) {
+			if (typeof container.enabled === "boolean") this.config.container.enabled = container.enabled;
+			if (typeof container.autoDiscover === "boolean") this.config.container.autoDiscover = container.autoDiscover;
+		}
 		const override = options?.methodOverride;
 		if (!override) return;
 		if (typeof override.enabled === "boolean") this.config.methodOverride.enabled = override.enabled;
@@ -438,36 +491,94 @@ var CoreRouter = class {
 	static resolveHandler(route) {
 		let handlerFunction;
 		let instance = null;
-		if (typeof route.handler === "function") handlerFunction = route.handler.bind(route);
-		else if (Array.isArray(route.handler) && route.handler.length === 2) {
+		let bindingTarget;
+		let bindingMethod;
+		let bindingHandler;
+		let bindingMetadata;
+		if (typeof route.handler === "function") {
+			handlerFunction = route.handler.bind(route);
+			bindingTarget = route.handler;
+			bindingHandler = route.handler;
+		} else if (Array.isArray(route.handler) && route.handler.length === 2) {
 			const [ControllerType, method] = route.handler;
 			if (["function", "object"].includes(typeof ControllerType) && typeof ControllerType[method] === "function") {
 				instance = ControllerType;
 				handlerFunction = ControllerType[method].bind(ControllerType);
+				bindingTarget = ControllerType;
+				bindingMethod = method;
+				bindingHandler = ControllerType[method];
+				bindingMetadata = ControllerType[Symbol.metadata];
 			} else if (typeof ControllerType === "function") {
 				instance = new ControllerType();
-				if (typeof instance[method] === "function") handlerFunction = instance[method].bind(instance);
-				else throw new Error(`Method "${method}" not found in controller instance "${ControllerType.name}"`);
+				if (typeof instance[method] === "function") {
+					handlerFunction = instance[method].bind(instance);
+					bindingTarget = ControllerType.prototype;
+					bindingMethod = method;
+					bindingHandler = instance[method];
+					bindingMetadata = ControllerType[Symbol.metadata];
+				} else throw new Error(`Method "${method}" not found in controller instance "${ControllerType.name}"`);
 			} else throw new Error(`Invalid controller type for route: ${route.path}`);
 		} else throw new Error(`Invalid handler format for route: ${route.path}`);
 		return {
 			handlerFunction,
-			instance
+			instance,
+			bindingTarget,
+			bindingMethod,
+			bindingHandler,
+			bindingMetadata
 		};
 	}
+	static async callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata) {
+		if (!this.config.container?.enabled) return handlerFunction(ctx, ctx.clearRequest);
+		const metadata = getBindingMetadataFromTargets([
+			{
+				target: bindingTarget,
+				propertyKey: bindingMethod
+			},
+			{ target: bindingHandler },
+			{
+				target: bindingTarget,
+				propertyKey: "__class__"
+			}
+		]) ?? getStandardMetadata(bindingMetadata, bindingMethod) ?? getStandardMetadata(bindingMetadata, "__class__");
+		if (!metadata) return handlerFunction(ctx, ctx.clearRequest);
+		const designTokens = [...bindingTarget ? getDesignParamTypes(bindingTarget, bindingMethod) : [], ...bindingHandler ? getDesignParamTypes(bindingHandler) : []];
+		const tokens = metadata.tokens?.length ? metadata.tokens : designTokens;
+		if (!tokens.length) return handlerFunction(ctx, ctx.clearRequest);
+		const args = [];
+		for (const token of tokens) {
+			const resolved = await Container.resolve(token, ctx, Boolean(this.config.container?.autoDiscover));
+			if (typeof resolved === "undefined") return handlerFunction(ctx, ctx.clearRequest);
+			args.push(resolved);
+		}
+		return handlerFunction(...args);
+	}
 	static bindRequestToInstance(ctx, instance, route, payload) {
+		const clearRequest = ctx.clearRequest instanceof Request ? ctx.clearRequest : new Request({
+			ctx,
+			route,
+			body: payload.body,
+			query: payload.query,
+			params: payload.params,
+			method: String(payload.method || ctx.req?.method || ctx.method || "GET").toUpperCase(),
+			path: String(ctx.path || ctx.req?.path || ctx.req?.url || route.path),
+			url: String(ctx.url || ctx.req?.url || ctx.req?.originalUrl || route.path),
+			headers: ctx.req?.headers || ctx.headers || {},
+			original: ctx.req || ctx.request || ctx
+		});
+		clearRequest.ctx = ctx;
+		clearRequest.route = route;
+		clearRequest.body = payload.body;
+		clearRequest.query = payload.query;
+		clearRequest.params = payload.params;
+		ctx.clearRequest = clearRequest;
+		if (!(ctx.clearResponse instanceof Response)) ctx.clearResponse = new Response();
 		if (!instance) return;
 		instance.ctx = ctx;
 		instance.body = payload.body;
 		instance.query = payload.query;
 		instance.params = payload.params;
-		instance.clearRequest = new ClearRequest({
-			ctx,
-			route,
-			body: instance.body,
-			query: instance.query,
-			params: instance.params
-		});
+		instance.clearRequest = clearRequest;
 	}
 };
 

package/dist/{router-CS_2XQ7I.d.cts → router-BYZmNzrZ.d.cts}

@@ -1,7 +1,28 @@
-import { AsyncLocalStorage } from "node:async_hooks";
+import { a as BindValue, i as BindToken, o as Container } from "./bindings-NV0CdqGl.cjs";
 import { NextFunction, Request, Response as Response$1 } from "express";
 import { EventHandlerRequest, H3, H3Event, Middleware, TypedServerRequest } from "h3";
+import { AsyncLocalStorage } from "node:async_hooks";
 
+//#region src/core/Response.d.ts
+declare class Response$2 {
+  body: any;
+  headers: Headers;
+  sent: boolean;
+  statusCode: number;
+  constructor(init?: Partial<Response$2>);
+  status(code: number): this;
+  code(code: number): this;
+  setHeader(name: string, value: string): this;
+  header(name: string, value: string): this;
+  set(name: string, value: string): this;
+  type(contentType: string): this;
+  send(body?: any): this;
+  json(body: any): this;
+  html(body: string): this;
+  text(body: string): this;
+  noContent(): this;
+}
+//#endregion
 //#region types/basic.d.ts
 /**
  * Controller method reference
@@ -30,6 +51,13 @@ interface RouterConfig {
     bodyKeys?: string[] | string; /** Keys in the request headers to check for method override */
     headerKeys?: string[] | string;
   };
+  /**
+   * Optional method binding / container resolution support. Disabled by default.
+   */
+  container?: {
+    /** Whether decorated handler parameter binding is enabled */enabled?: boolean; /** Whether unknown constructor tokens should be instantiated automatically */
+    autoDiscover?: boolean;
+  };
 }
 //#endregion
 //#region types/express.d.ts
@@ -43,6 +71,8 @@ interface HttpContext$1 {
   req: RequestWithGetBody;
   res: Response$1;
   next: NextFunction;
+  clearRequest: Request$1;
+  clearResponse: Response$2;
 }
 /**
  * Route handler function type
@@ -57,7 +87,7 @@ ctx: HttpContext$1,
  * ClearRequest instance
  */
 
-req: ClearRequest) => any | Promise<any>;
+req: Request$1) => any | Promise<any>;
 /**
  * Handler can be either a function or controller reference
  */
@@ -80,6 +110,8 @@ type RequestlessH3Event = Omit<H3Event, 'req'>;
  */
 interface HttpContext extends RequestlessH3Event {
   req: HttpRequest;
+  clearRequest: Request$1;
+  clearResponse: Response$2;
 }
 /**
  * Route handler function type
@@ -94,7 +126,7 @@ ctx: HttpContext,
  * ClearRequest instance
  */
 
-req: ClearRequest) => any | Promise<any>;
+req: Request$1) => any | Promise<any>;
 /**
  * Handler can be either a function or controller reference
  */
@@ -137,6 +169,43 @@ declare class ClearRequest<X = any, M = Middleware | Middleware$1> {
   constructor(init?: Partial<ClearRequest>);
 }
 //#endregion
+//#region src/core/Request.d.ts
+declare class Request$1<X = any, M = any> extends ClearRequest<X, M> {
+  original?: any;
+  method: string;
+  path: string;
+  url: string;
+  headers: Headers | Record<string, any>;
+  constructor(init?: Partial<Request$1<X, M>> & {
+    body?: RequestData;
+    query?: RequestData;
+    params?: RequestData;
+    route?: Route<X, M>;
+  });
+  getBody(): RequestData;
+  header(name: string): string;
+  param(name: string): any;
+  input(name: string): any;
+  is(method: HttpMethod | string): boolean;
+}
+//#endregion
+//#region src/core/plugins.d.ts
+type PluginSetupResult = void;
+type PluginBind = <T>(token: BindToken<T>, value: BindValue<T>) => void;
+interface ClearRouterPluginContext<Options = any> {
+  container: typeof Container;
+  bind: PluginBind;
+  configure: (options: RouterConfig) => void;
+  configureDefaults: (options: RouterConfig) => void;
+  options: Options;
+}
+interface ClearRouterPlugin<Options = any> {
+  name?: string;
+  setup: (ctx: ClearRouterPluginContext<Options>) => PluginSetupResult;
+}
+type ClearRouterPluginInput<Options = any> = ClearRouterPlugin<Options> | ((ctx: ClearRouterPluginContext<Options>) => PluginSetupResult);
+declare function definePlugin<Options = any>(plugin: ClearRouterPlugin<Options>): ClearRouterPlugin<Options>;
+//#endregion
 //#region src/Controller.d.ts
 declare abstract class Controller<X = any> {
   [x: string]: any;
@@ -158,16 +227,16 @@ declare abstract class CoreRouter {
   protected static routerStateNamespace: string;
   private static readonly stateStoreKey;
   private static readonly stateBoundKey;
+  private static readonly defaultConfigKey;
+  private static readonly pluginStoreKey;
+  protected static createBaseConfig(): RouterConfig;
+  protected static mergeConfig(target: RouterConfig, source?: RouterConfig): RouterConfig;
+  protected static getDefaultConfig(): RouterConfig;
   protected static resolveStateNamespace(this: any): string;
   protected static getStateStore(): Record<string, any>;
+  protected static getPluginStore(): Set<string>;
   protected static createDefaultState(): {
-    config: {
-      methodOverride: {
-        enabled: boolean;
-        bodyKeys: string[];
-        headerKeys: string[];
-      };
-    };
+    config: RouterConfig;
     groupContext: AsyncLocalStorage<{
       prefix: string;
       groupMiddlewares: any[];
@@ -182,6 +251,16 @@ declare abstract class CoreRouter {
   protected static bindStateAccessors(this: any): void;
   protected static createDefaultOptionsHandler(): any;
   static config: RouterConfig;
+  static configureDefaults(this: any, options?: RouterConfig): void;
+  /**
+   * Use a registered plugin
+   *
+   * @param this
+   * @param plugin
+   * @param options
+   * @returns
+   */
+  static use<Options = any>(this: any, plugin: ClearRouterPluginInput<Options>, options?: Options): void;
   protected static groupContext: AsyncLocalStorage<{
     prefix: string;
     groupMiddlewares: any[];
@@ -331,14 +410,20 @@ declare abstract class CoreRouter {
    */
   static allRoutes(this: any, type: 'method'): { [method in Uppercase<HttpMethod>]?: Array<Route<any, any, any>> };
   protected static resolveHandler(route: Route<any, any, any>): {
-    handlerFunction: ((ctx: any, req: ClearRequest) => any | Promise<any>) | null;
+    handlerFunction: ((ctx: any, req: Request$1) => any | Promise<any>) | null;
     instance: Controller<any> | null;
+    bindingTarget?: object;
+    bindingMethod?: PropertyKey;
+    bindingHandler?: object;
+    bindingMetadata?: object;
   };
+  protected static callHandler(this: any, handlerFunction: (ctx: any, req: Request$1) => any | Promise<any>, ctx: any, bindingTarget?: object, bindingMethod?: PropertyKey, bindingHandler?: object, bindingMetadata?: object): Promise<any>;
   protected static bindRequestToInstance(ctx: any, instance: Controller<any> | Route<any, any, any> | null, route: Route<any, any, any>, payload: {
     body: Record<string, any>;
     query: Record<string, any>;
     params: Record<string, any>;
+    method?: HttpMethod | string;
   }): void;
 }
 //#endregion
-export { Handler as a, Handler$1 as c, ApiResourceMiddleware as d, ControllerAction as f, H3App as i, HttpContext$1 as l, HttpMethod as m, ClearRequest as n, HttpContext as o, ControllerHandler as p, Route as r, Middleware as s, CoreRouter as t, Middleware$1 as u };
+export { ApiResourceMiddleware as _, PluginBind as a, HttpMethod as b, Request$1 as c, Handler as d, HttpContext as f, Middleware$1 as g, HttpContext$1 as h, ClearRouterPluginInput as i, Route as l, Handler$1 as m, ClearRouterPlugin as n, PluginSetupResult as o, Middleware as p, ClearRouterPluginContext as r, definePlugin as s, CoreRouter as t, H3App as u, ControllerAction as v, Response$2 as x, ControllerHandler as y };