clear-router 2.7.5 → 2.7.7

package/dist/koa/router.d.mts

@@ -0,0 +1,135 @@
+import { ApiResourceMiddleware, ControllerAction, HttpMethod } from "../types/basic.mjs";
+import { Handler, HttpContext, KoaRouterApp, Middleware } from "../types/koa.mjs";
+import { Route } from "../Route.mjs";
+import { CoreRouter } from "../core/router.mjs";
+
+//#region src/koa/router.d.ts
+/**
+ * @class clear-router Koa Router
+ * @description Laravel-style routing system for Koa using @koa/router and shared clear-router core
+ * @author 3m1n3nc3
+ * @repository https://github.com/arkstack-tmp/clear-router
+ */
+declare class Router extends CoreRouter {
+  protected static routerStateNamespace: string;
+  private static readonly bodyCache;
+  private static readBodyCached;
+  private static readBody;
+  private static sendReturnValue;
+  /**
+   * Adds a new route to the router.
+   *
+   * @param methods
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static add(methods: HttpMethod | HttpMethod[], path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Define a resourceful API controller with standard CRUD routes
+   *
+   * @param basePath
+   * @param controller
+   * @param options
+   */
+  static apiResource(basePath: string, controller: any, options?: {
+    only?: ControllerAction[];
+    except?: ControllerAction[];
+    middlewares?: ApiResourceMiddleware<Middleware>;
+  }): void;
+  /**
+   * Define a GET route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static get(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Define a POST route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static post(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Define a PUT route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static put(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Define a DELETE route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static delete(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Define a PATCH route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static patch(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Define an OPTIONS route
+   *
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static options(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Adds a new HEAD route to the router.
+   *
+   * @param this
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static head(path: string, handler: Handler, middlewares?: Middleware[] | Middleware): Route<HttpContext, Middleware, Handler>;
+  /**
+   * Defines a group of routes with a common prefix.
+   *
+   * @param prefix
+   * @param callback
+   * @param middlewares
+   */
+  static group(prefix: string, callback: () => void | Promise<void>, middlewares?: Middleware[]): Promise<void>;
+  /**
+   * Apply middlewares to a group of routes defined within the callback
+   *
+   * @param middlewares  - Middleware or array of middlewares to apply
+   * @param callback     - Function that defines the routes to which the middlewares will be applied
+   */
+  static middleware(middlewares: Middleware[], callback: () => void): void;
+  /**
+   * Get all defined routes, optionally organized by path or method
+   */
+  static allRoutes(): Array<Route<HttpContext, Middleware, Handler>>;
+  /**
+   * @param type  - 'path' to get routes organized by path
+   */
+  static allRoutes(type: 'path'): Record<string, Route<HttpContext, Middleware, Handler>>;
+  /**
+   * @param type  - 'method' to get routes organized by method
+   */
+  static allRoutes(type: 'method'): { [method in Uppercase<HttpMethod>]?: Array<Route<HttpContext, Middleware, Handler>> };
+  static allRoutes(type: 'name'): Record<string, Route<HttpContext, Middleware, Handler>>;
+  static route(name: string): Route<HttpContext, Middleware, Handler> | undefined;
+  /**
+   * Apply the defined routes to a @koa/router instance
+   *
+   * @param router  @koa/router instance
+   * @returns    The  @koa/router instance with the applied routes
+   */
+  static apply(router: KoaRouterApp): KoaRouterApp;
+}
+//#endregion
+export { Router };

package/dist/koa/router.mjs

@@ -0,0 +1,261 @@
+import { CoreRouter } from "../core/router.mjs";
+import { isFetchResponse, resolveResponseMeta } from "../core/responses.mjs";
+
+//#region src/koa/router.ts
+/**
+* @class clear-router Koa Router
+* @description Laravel-style routing system for Koa using @koa/router and shared clear-router core
+* @author 3m1n3nc3
+* @repository https://github.com/arkstack-tmp/clear-router
+*/
+var Router = class Router extends CoreRouter {
+	static routerStateNamespace = "clear-router:koa";
+	static bodyCache = /* @__PURE__ */ new WeakMap();
+	static async readBodyCached(ctx) {
+		if (this.bodyCache.has(ctx)) {
+			const cached = this.bodyCache.get(ctx) || {};
+			ctx.request.getBody = () => cached;
+			return cached;
+		}
+		let body = ctx.request.body && typeof ctx.request.body === "object" ? ctx.request.body : {};
+		if (!Object.keys(body).length && !["GET", "HEAD"].includes(ctx.method.toUpperCase())) body = await this.readBody(ctx);
+		ctx.request.getBody = () => body;
+		this.bodyCache.set(ctx, body);
+		return body;
+	}
+	static async readBody(ctx) {
+		const contentType = String(ctx.get("content-type") || "").toLowerCase();
+		const chunks = [];
+		for await (const chunk of ctx.req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+		const raw = Buffer.concat(chunks).toString("utf8");
+		if (!raw) return {};
+		if (contentType.includes("application/json")) return JSON.parse(raw);
+		if (contentType.includes("application/x-www-form-urlencoded")) return Object.fromEntries(new URLSearchParams(raw));
+		return {};
+	}
+	static async sendReturnValue(ctx, value, method, path) {
+		if (ctx.respond === false || ctx.headerSent) return value;
+		const meta = resolveResponseMeta(value, {
+			headers: ctx.headers,
+			method,
+			path,
+			status: ctx.status && ctx.status !== 404 ? ctx.status : void 0
+		});
+		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);
+			});
+			ctx.status = meta.body.status;
+			ctx.body = Buffer.from(await meta.body.arrayBuffer());
+			return ctx.body;
+		}
+		if (meta.contentType) ctx.type = meta.contentType;
+		ctx.body = meta.isEmpty ? null : meta.body;
+		return ctx.body;
+	}
+	/**
+	* Adds a new route to the router.
+	*
+	* @param methods
+	* @param path
+	* @param handler
+	* @param middlewares
+	*/
+	static add(methods, path, handler, middlewares) {
+		return super.add(methods, path, handler, middlewares);
+	}
+	/**
+	* Define a resourceful API controller with standard CRUD routes
+	*
+	* @param basePath
+	* @param controller
+	* @param options
+	*/
+	static apiResource(basePath, controller, options) {
+		super.apiResource(basePath, controller, options);
+	}
+	/**
+	* Define a GET route
+	*
+	* @param path
+	* @param handler
+	* @param middlewares
+	*/
+	static get(path, handler, middlewares) {
+		return super.get(path, handler, middlewares);
+	}
+	/**
+	* Define a POST route
+	*
+	* @param path
+	* @param handler
+	* @param middlewares
+	*/
+	static post(path, handler, middlewares) {
+		return super.post(path, handler, middlewares);
+	}
+	/**
+	* Define a PUT route
+	*
+	* @param path
+	* @param handler
+	* @param middlewares
+	*/
+	static put(path, handler, middlewares) {
+		return super.put(path, handler, middlewares);
+	}
+	/**
+	* Define a DELETE route
+	*
+	* @param path
+	* @param handler
+	* @param middlewares
+	*/
+	static delete(path, handler, middlewares) {
+		return super.delete(path, handler, middlewares);
+	}
+	/**
+	* Define a PATCH route 
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
+	*/
+	static patch(path, handler, middlewares) {
+		return super.patch(path, handler, middlewares);
+	}
+	/**
+	* Define an OPTIONS route
+	*
+	* @param path
+	* @param handler
+	* @param middlewares
+	*/
+	static options(path, handler, middlewares) {
+		return super.options(path, handler, middlewares);
+	}
+	/**
+	* Adds a new HEAD route to the router.
+	*
+	* @param this
+	* @param path
+	* @param handler
+	* @param middlewares
+	*/
+	static head(path, handler, middlewares) {
+		return super.head(path, handler, middlewares);
+	}
+	/**
+	* Defines a group of routes with a common prefix.
+	*
+	* @param prefix
+	* @param callback
+	* @param middlewares
+	*/
+	static async group(prefix, callback, middlewares) {
+		await super.group(prefix, callback, middlewares);
+	}
+	/**
+	* Apply middlewares to a group of routes defined within the callback
+	* 
+	* @param middlewares  - Middleware or array of middlewares to apply
+	* @param callback     - Function that defines the routes to which the middlewares will be applied
+	*/
+	static middleware(middlewares, callback) {
+		super.middleware(middlewares, callback);
+	}
+	static allRoutes(type) {
+		return super.allRoutes(type);
+	}
+	static route(name) {
+		return super.route(name);
+	}
+	/**
+	* Apply the defined routes to a @koa/router instance
+	* 
+	* @param router  @koa/router instance
+	* @returns    The  @koa/router instance with the applied routes
+	*/
+	static apply(router) {
+		for (const route of Array.from(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;
+			}
+			if (!handlerFunction) continue;
+			for (const method of route.methods) {
+				const allowedMethods = [
+					"get",
+					"post",
+					"put",
+					"delete",
+					"patch",
+					"options",
+					"head"
+				];
+				if (method === "options" && route.methods.length > 1) continue;
+				if (!allowedMethods.includes(method)) throw new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
+				for (const registrationPath of route.registrationPaths) router[method](registrationPath, ...route.middlewares || [], async (context, next) => {
+					const ctx = context;
+					const reqBody = await Router.readBodyCached(ctx);
+					const override = Router.resolveMethodOverride(ctx.method, ctx.headers, reqBody);
+					if (method === "post" && override && override !== "post") return next();
+					const inst = instance ?? route;
+					Router.bindRequestToInstance(ctx, inst, route, {
+						body: reqBody,
+						query: ctx.query,
+						params: ctx.params ?? {},
+						method
+					});
+					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
+					const resolved = await Promise.resolve(result);
+					const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
+					return Router.sendReturnValue(ctx, outgoing, method, route.path);
+				});
+				if ([
+					"put",
+					"patch",
+					"delete"
+				].includes(method)) for (const registrationPath of route.registrationPaths) router.post(registrationPath, ...route.middlewares || [], async (context, next) => {
+					const ctx = context;
+					const reqBody = await Router.readBodyCached(ctx);
+					if (Router.resolveMethodOverride(ctx.method, ctx.headers, reqBody) !== method) return next();
+					const inst = instance ?? route;
+					Router.bindRequestToInstance(ctx, inst, route, {
+						body: reqBody,
+						query: ctx.query,
+						params: ctx.params ?? {},
+						method
+					});
+					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
+					const resolved = await Promise.resolve(result);
+					const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
+					return Router.sendReturnValue(ctx, outgoing, method, route.path);
+				});
+			}
+		}
+		return router;
+	}
+};
+
+//#endregion
+export { Router as default };

package/dist/types/basic.d.cts

@@ -0,0 +1,43 @@
+//#region src/types/basic.d.ts
+/**
+ * Controller method reference
+ */
+type ControllerHandler = [any, string];
+/**
+ * HTTP methods supported by the router
+ */
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+/**
+ * Common controller action names
+ */
+type ControllerAction = 'index' | 'show' | 'create' | 'update' | 'destroy';
+/**
+ * Generic Object type for request data
+ */
+type RequestData = Record<string, any>;
+type ApiResourceMiddleware<M = any> = M | M[] | { [K in ControllerAction]?: M | M[] };
+interface RouterConfig {
+  /**
+   * When enabled, API param name will be infered from the route path.
+   * So instead of getting /api/users/:id, we will now get /api/users/:user
+   */
+  inferParamName?: boolean;
+  /**
+   * Configuration for method override functionality, allowing clients to use a
+   * specific header or body parameter to override the HTTP method.
+   */
+  methodOverride?: {
+    /** Whether method override is enabled */enabled?: boolean; /** Keys in the request body to check for method override */
+    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
+export { ApiResourceMiddleware, ControllerAction, ControllerHandler, HttpMethod, RequestData, RouterConfig };

package/dist/types/express.d.cts

@@ -0,0 +1,44 @@
+import { ControllerHandler } from "./basic.cjs";
+import { ClearHttpContext } from "../Contracts.cjs";
+import { Response as Response$1 } from "../core/Response.cjs";
+import { Request as Request$1 } from "../core/Request.cjs";
+import { NextFunction, Request, Response } from "express";
+
+//#region src/types/express.d.ts
+interface RequestWithGetBody extends Request {
+  getBody: () => Record<string, any>;
+}
+/**
+ * HTTP context passed to route handlers
+ */
+interface HttpContext extends ClearHttpContext {
+  req: RequestWithGetBody;
+  res: Response;
+  next: NextFunction;
+  clearRequest: Request$1;
+  clearResponse: Response$1;
+}
+/**
+ * Route handler function type
+ */
+type RouteHandler = (
+/**
+ * Express context object containing req, res, and next
+ */
+
+ctx: HttpContext,
+/**
+ * ClearRequest instance
+ */
+
+req: Request$1) => any | Promise<any>;
+/**
+ * Handler can be either a function or controller reference
+ */
+type Handler = RouteHandler | ControllerHandler;
+/**
+ * Middleware function type
+ */
+type Middleware = (req: Request, res: Response, next: NextFunction) => any | Promise<any>;
+//#endregion
+export { Handler, HttpContext, Middleware };

package/dist/types/express.d.mts

@@ -1,5 +1,7 @@
 import { ControllerHandler } from "./basic.mjs";
-import { n as Response$1, r as ClearHttpContext, t as Request$1 } from "../Request-DKXwa_W0.mjs";
+import { ClearHttpContext } from "../Contracts.mjs";
+import { Response as Response$1 } from "../core/Response.mjs";
+import { Request as Request$1 } from "../core/Request.mjs";
 import { NextFunction, Request, Response } from "express";
 
 //#region src/types/express.d.ts
@@ -39,4 +41,4 @@ type Handler = RouteHandler | ControllerHandler;
  */
 type Middleware = (req: Request, res: Response, next: NextFunction) => any | Promise<any>;
 //#endregion
-export { Handler, HttpContext, Middleware, RequestWithGetBody, RouteHandler };
+export { Handler, HttpContext, Middleware };

package/dist/types/fastify.d.cts

@@ -0,0 +1,23 @@
+import { ControllerHandler } from "./basic.cjs";
+import { ClearHttpContext } from "../Contracts.cjs";
+import { Response } from "../core/Response.cjs";
+import { Request } from "../core/Request.cjs";
+import { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
+
+//#region src/types/fastify.d.ts
+interface RequestWithGetBody extends FastifyRequest {
+  getBody: () => Record<string, any>;
+}
+interface HttpContext extends ClearHttpContext {
+  req: RequestWithGetBody;
+  reply: FastifyReply;
+  clearRequest: Request;
+  clearResponse: Response;
+}
+type RouteHandler = (ctx: HttpContext, req: Request) => any | Promise<any>;
+type Handler = RouteHandler | ControllerHandler;
+type NextFunction = (err?: Error) => void;
+type Middleware = (req: RequestWithGetBody, reply: FastifyReply, next: NextFunction) => any | Promise<any>;
+type FastifyApp = FastifyInstance;
+//#endregion
+export { FastifyApp, Handler, HttpContext, Middleware };

package/dist/types/fastify.d.mts

@@ -1,5 +1,7 @@
 import { ControllerHandler } from "./basic.mjs";
-import { n as Response, r as ClearHttpContext, t as Request } from "../Request-DKXwa_W0.mjs";
+import { ClearHttpContext } from "../Contracts.mjs";
+import { Response } from "../core/Response.mjs";
+import { Request } from "../core/Request.mjs";
 import { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
 
 //#region src/types/fastify.d.ts
@@ -18,4 +20,4 @@ type NextFunction = (err?: Error) => void;
 type Middleware = (req: RequestWithGetBody, reply: FastifyReply, next: NextFunction) => any | Promise<any>;
 type FastifyApp = FastifyInstance;
 //#endregion
-export { FastifyApp, Handler, HttpContext, Middleware, NextFunction, RequestWithGetBody, RouteHandler };
+export { FastifyApp, Handler, HttpContext, Middleware };

package/dist/types/h3.d.cts

@@ -0,0 +1,41 @@
+import { ControllerHandler } from "./basic.cjs";
+import { ClearHttpContext } from "../Contracts.cjs";
+import { Response as Response$1 } from "../core/Response.cjs";
+import { Request } from "../core/Request.cjs";
+import { EventHandlerRequest, H3, H3Event, Middleware, TypedServerRequest } from "h3";
+
+//#region src/types/h3.d.ts
+type H3App = Omit<H3, 'fetch'> & {
+  fetch: (request: TypedServerRequest<EventHandlerRequest>) => Promise<Response>;
+};
+interface HttpRequest extends TypedServerRequest<EventHandlerRequest> {
+  getBody: () => Record<string, any>;
+}
+/**
+ * HTTP context passed to route handlers
+ */
+interface HttpContext extends Omit<H3Event, 'req'>, ClearHttpContext {
+  req: HttpRequest;
+  clearRequest: Request;
+  clearResponse: Response$1;
+}
+/**
+ * Route handler function type
+ */
+type RouteHandler = (
+/**
+ * H3 event context
+ */
+
+ctx: HttpContext,
+/**
+ * ClearRequest instance
+ */
+
+req: Request) => any | Promise<any>;
+/**
+ * Handler can be either a function or controller reference
+ */
+type Handler = RouteHandler | ControllerHandler;
+//#endregion
+export { H3App, Handler, HttpContext, type Middleware };

package/dist/types/h3.d.mts

@@ -1,20 +1,20 @@
 import { ControllerHandler } from "./basic.mjs";
-import { n as Response$1, r as ClearHttpContext, t as Request } from "../Request-DKXwa_W0.mjs";
+import { ClearHttpContext } from "../Contracts.mjs";
+import { Response as Response$1 } from "../core/Response.mjs";
+import { Request } from "../core/Request.mjs";
 import { EventHandlerRequest, H3, H3Event, Middleware, TypedServerRequest } from "h3";
 
 //#region src/types/h3.d.ts
 type H3App = Omit<H3, 'fetch'> & {
   fetch: (request: TypedServerRequest<EventHandlerRequest>) => Promise<Response>;
 };
-type MaybePromise<T = unknown> = T | Promise<T>;
 interface HttpRequest extends TypedServerRequest<EventHandlerRequest> {
   getBody: () => Record<string, any>;
 }
-type MergedHttpContext = Omit<H3Event, 'req'> & ClearHttpContext;
 /**
  * HTTP context passed to route handlers
  */
-interface HttpContext extends MergedHttpContext {
+interface HttpContext extends Omit<H3Event, 'req'>, ClearHttpContext {
   req: HttpRequest;
   clearRequest: Request;
   clearResponse: Response$1;
@@ -37,6 +37,5 @@ req: Request) => any | Promise<any>;
  * Handler can be either a function or controller reference
  */
 type Handler = RouteHandler | ControllerHandler;
-type NextFunction = () => MaybePromise<unknown | undefined>;
 //#endregion
-export { H3App, Handler, HttpContext, HttpRequest, MaybePromise, type Middleware, NextFunction, RouteHandler };
+export { H3App, Handler, HttpContext, type Middleware };

package/dist/types/hono.d.cts

@@ -0,0 +1,21 @@
+import { ControllerHandler } from "./basic.cjs";
+import { ClearHttpContext } from "../Contracts.cjs";
+import { Response } from "../core/Response.cjs";
+import { Request } from "../core/Request.cjs";
+import { Context, HonoRequest, MiddlewareHandler } from "hono";
+
+//#region src/types/hono.d.ts
+type RequestWithGetBody = HonoRequest & {
+  getBody: () => Record<string, any>;
+};
+interface HttpContext extends Context, ClearHttpContext {
+  req: RequestWithGetBody;
+  clearRequest: Request;
+  clearResponse: Response;
+}
+type RouteHandler = (ctx: HttpContext, req: Request) => any | Promise<any>;
+type Handler = RouteHandler | ControllerHandler;
+type Middleware = MiddlewareHandler;
+type HonoApp = { [K in 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head']: (path: string, ...handlers: Middleware[]) => any };
+//#endregion
+export { Handler, HonoApp, HttpContext, Middleware };

package/dist/types/hono.d.mts

@@ -1,21 +1,21 @@
 import { ControllerHandler } from "./basic.mjs";
-import { n as Response, r as ClearHttpContext, t as Request } from "../Request-DKXwa_W0.mjs";
+import { ClearHttpContext } from "../Contracts.mjs";
+import { Response } from "../core/Response.mjs";
+import { Request } from "../core/Request.mjs";
 import { Context, HonoRequest, MiddlewareHandler } from "hono";
 
 //#region src/types/hono.d.ts
 type RequestWithGetBody = HonoRequest & {
   getBody: () => Record<string, any>;
 };
-type MergedHttpContext = ClearHttpContext & Context;
-interface HttpContext extends MergedHttpContext {
+interface HttpContext extends Context, ClearHttpContext {
   req: RequestWithGetBody;
   clearRequest: Request;
   clearResponse: Response;
 }
 type RouteHandler = (ctx: HttpContext, req: Request) => any | Promise<any>;
 type Handler = RouteHandler | ControllerHandler;
-type NextFunction = () => Promise<void>;
 type Middleware = MiddlewareHandler;
 type HonoApp = { [K in 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head']: (path: string, ...handlers: Middleware[]) => any };
 //#endregion
-export { Handler, HonoApp, HttpContext, Middleware, NextFunction, RequestWithGetBody, RouteHandler };
+export { Handler, HonoApp, HttpContext, Middleware };