@minisylar/express-typed-router 1.4.4 → 1.6.0

package/README.md

@@ -1,11 +1,13 @@
 # @minisylar/express-typed-router
 
-A strongly-typed Express router with Zod validation and automatic type inference for params, body, query, and middleware.
+A strongly-typed Express router with schema validation and automatic type inference for params, body, query, and middleware.
 
 ## Features
 
 - 🚀 **Full TypeScript support** with automatic type inference for route parameters
-- 🛡️ **Zod validation** for request body, query parameters, and route params
+- 🛡️ **Schema validation** for request body, query parameters, and route params (Zod, Yup, Valibot, Arktype,Joi,Effect,decoders,
+  ts.data.json,
+  unhoax, etc.)
 - 🔗 **Express.js compatibility** - works with Express 4 and Express 5
 - 🤝 **Mix with existing Express routes** - seamlessly integrates with your current codebase
 - 📝 **JSDoc documentation** with comprehensive examples
@@ -22,32 +24,53 @@ pnpm add @minisylar/express-typed-router
 yarn add @minisylar/express-typed-router
 ```
 
-> **Note:** This package requires Express 4.18.0+ or Express 5.0.0+ and Zod 3.25.0+
+> **Note:** This package requires Express 4.18.0+ or Express 5.0.0+. For schema validation the library works with multiple popular schema libraries (examples below).
 
-### Zod Compatibility
+### Schema Compatibility
 
-This library supports **both Zod 3 and Zod 4** simultaneously! The library follows [Zod's official recommendations for library authors](https://zod.dev/library-authors) and uses versioned imports internally to ensure compatibility with both versions.
+This library is schema-agnostic: it provides a validation plumbing that works with multiple popular schema libraries. Below are short examples showing how you can use different schema libraries with the router. The router expects a schema-like object that can validate input; most adapters are straightforward.
 
-- ✅ **Zod v3.25.0+** - Full support
-- ✅ **Zod v4** - Full support including Core and Mini packages
-- 🔄 **Runtime detection** - Automatically detects and handles both versions
-
-You can use schemas from either version or mix them in the same application:
+Example with Zod (v3 or v4):
 
 ```typescript
-// Works with Zod 4
-import { z } from "zod/v4";
+import { z } from "zod"; // or "zod/v4" or "zod/v3" as needed
 const userSchema = z.object({ name: z.string() });
+router.post("/users", { bodySchema: userSchema }, handler);
+```
 
-// Also works with Zod 3
-import * as z4 from "zod/v3";
-const postSchema = z4.object({ title: z4.string() });
+Example with Yup:
 
-// Both schemas work seamlessly with the router
+```javascript
+import * as yup from "yup";
+const userSchema = yup.object({ name: yup.string().required() });
+// pass the yup schema directly as bodySchema; the router will run validation
+router.post("/users", { bodySchema: userSchema }, handler);
+```
+
+Example with Valibot (valibot):
+
+```typescript
+import { object, string } from "valibot";
+const userSchema = object({ name: string() });
 router.post("/users", { bodySchema: userSchema }, handler);
-router.post("/posts", { bodySchema: postSchema }, handler);
 ```
 
+Example with Arktype:
+
+```typescript
+import { object, string } from "arktype";
+const userSchema = object({ name: string() });
+router.post("/users", { bodySchema: userSchema }, handler);
+```
+
+If a schema library needs an adapter (for example to map its errors to the router's error format), add a small wrapper that runs validation and throws the expected error shape. See the project's examples for concrete adapter patterns.
+
+Note about Joi: Joi's TypeScript typings do not reliably infer the output type from the runtime schema shape. When using Joi you should either:
+
+- provide an explicit generic type for the schema (e.g. `Joi.object<MyType>(...)`),
+- add a variable type annotation (e.g. `const s: Joi.ObjectSchema<MyType> = Joi.object(...)`), or
+- write a small adapter that validates at runtime and exposes a typed result to TypeScript.
+
 ## Quick Start
 
 ```javascript

package/dist/schema-router.cjs

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));const c=s(require(`express`)),l=s(require(`@standard-schema/utils`));function u(e,t){let n=e;if(n&&n[`~standard`]&&typeof n[`~standard`].validate==`function`){let e=n[`~standard`].validate(t);if(e instanceof Promise)throw TypeError(`Async schema validation is not supported by parseSchema`);if(e.issues)throw new l.SchemaError(e.issues);return e.value}throw TypeError(`Unsupported schema shape for parseSchema`)}function d(e,t){let n=e;if(n&&n[`~standard`]&&typeof n[`~standard`].validate==`function`)return n[`~standard`].validate(t);if(n&&typeof n.safeParse==`function`)return n.safeParse(t);if(n&&typeof n.parse==`function`)try{let e=n.parse(t);return{value:e}}catch(e){return{issues:[{message:e?.message??String(e)}]}}if(n&&typeof n.validate==`function`){let e=n.validate(t);return e&&e.then&&typeof e.then==`function`?e.then(e=>e.error?{issues:[{message:e.error.message}]}:e.issues?{issues:e.issues}:{value:e.value??e}):e&&e.error?{issues:[{message:e.error.message}]}:e&&e.issues?{issues:e.issues}:{value:e.value??e}}return{issues:[{message:`Unsupported schema shape`}]}}function f(e){return typeof e==`object`&&!!e&&`issues`in e&&Array.isArray(e.issues)}var p=class{router;constructor(){this.router=c.default.Router()}useMiddleware(e){return this.router.use(e),this}getRouter(){return this.router}get(e,t,n){return this.registerRoute(`get`,e,t,n)}post(e,t,n){return this.registerRoute(`post`,e,t,n)}put(e,t,n){return this.registerRoute(`put`,e,t,n)}patch(e,t,n){return this.registerRoute(`patch`,e,t,n)}delete(e,t,n){return this.registerRoute(`delete`,e,t,n)}options(e,t,n){return this.registerRoute(`options`,e,t,n)}head(e,t,n){return this.registerRoute(`head`,e,t,n)}all(e,t,n){return this.registerRoute(`all`,e,t,n)}registerRoute(e,t,n,r){let i=[];if(typeof n==`object`){let e=n;e.middleware&&i.push(...e.middleware),e.bodySchema&&i.push(this.createBodyValidationMiddleware(e.bodySchema)),e.querySchema&&i.push(this.createQueryValidationMiddleware(e.querySchema)),i.push(r)}else i.push(n);return this.router[e](t,...i),this}createBodyValidationMiddleware(e){return async(t,n,r)=>{try{let i=d(e,t.body),a=i&&typeof i.then==`function`?await i:i;if(a&&`issues`in a&&a.issues){n.status(400).json({error:`Validation failed`,details:a.errors||a.issues});return}t.body=a&&`value`in a?a.value:a,r()}catch(e){f(e)?n.status(400).json({error:`Validation failed`,details:e.errors||e.issues}):r(e)}}}createQueryValidationMiddleware(e){return async(t,n,r)=>{try{let i=d(e,t.query),a=i&&typeof i.then==`function`?await i:i;if(a&&`issues`in a&&a.issues){n.status(400).json({error:`Validation failed`,details:a.errors||a.issues});return}let o=a&&`value`in a?a.value:a;Object.defineProperty(t,`query`,{value:o,writable:!1,enumerable:!0,configurable:!0}),r()}catch(e){f(e)?n.status(400).json({error:`Validation failed`,details:e.errors||e.issues}):r(e)}}}};function m(){return new p}function h(e){let t=new p;return e?.errorHandler&&t.getRouter().use(e.errorHandler),t}function g(...e){let t=new p;for(let n of e)t=t.useMiddleware(n);return t}exports.createTypedRouter=m,exports.createTypedRouterWithConfig=h,exports.createTypedRouterWithMiddleware=g,exports.isSchemaError=f,exports.parseSchema=u,exports.safeParseSchema=d;

package/dist/schema-router.d.cts

@@ -0,0 +1,406 @@
+import express, { NextFunction, Request, Response } from "express";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/schema-router.d.ts
+
+type AnyStandardSchema = StandardSchemaV1<any, any>;
+type InferOutput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> : unknown;
+type InferInput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferInput<T> : unknown;
+type InferFromSafeParse<T> = T extends {
+  safeParse: (...args: any[]) => infer R;
+} ? R extends {
+  success: true;
+  data: infer O;
+} ? O : R extends Promise<infer PR> ? PR extends {
+  success: true;
+  data: infer O;
+} ? O : never : never : T extends {
+  parse: (...args: any[]) => infer R;
+} ? R : never;
+type InferSchemaOutput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> : InferFromSafeParse<T>;
+declare function parseSchema<T>(schema: T, data: unknown): InferSchemaOutput<T>;
+type SafeParseResult<T> = StandardSchemaV1.Result<InferSchemaOutput<T>> | {
+  value: InferSchemaOutput<T>;
+} | {
+  issues: any[];
+} | Promise<StandardSchemaV1.Result<InferSchemaOutput<T>> | {
+  value: InferSchemaOutput<T>;
+} | {
+  issues: any[];
+}>;
+declare function safeParseSchema<T>(schema: T, data: unknown): SafeParseResult<T>;
+declare function isSchemaError(error: unknown): error is {
+  issues: any[];
+};
+/**
+ * Extract route parameters from Express.js route patterns.
+ *
+ * Supports all Express.js routing patterns:
+ * - Named parameters: /users/:userId → { userId: string }
+ * - Multiple parameters: /users/:userId/books/:bookId → { userId: string; bookId: string }
+ * - Parameters with separators: /flights/:from-:to → { from: string; to: string }
+ * - Dot notation: /plantae/:genus.:species → { genus: string; species: string }
+ * - Regex constraints: /user/:id(\d+) → { id: string }
+ * - Optional parameters: /posts/:year/:month? → { year: string; month?: string }
+ * - Wildcard parameters: /files/* → { "0": string }
+ * - Multiple wildcards: /a/star/b/star → { "0": string; "1": string }
+ */
+type ExtractRouteParams<Path extends string> = string extends Path ? Record<string, string> : ExtractParams<Path>;
+/**
+ * Main parameter extraction logic - enhanced for Express 5 support with recursion depth limit
+ */
+type ExtractParams<Path extends string> = Path extends `${infer Before}{${infer OptionalContent}}${infer After}` ? ExtractOptionalSegment<OptionalContent> & ExtractParams<`${Before}${After}`> : Path extends `${infer _Before}:${infer Rest}` ? ExtractSingleParam<Rest> & ExtractParams<RemoveFirstParam<Path>> : Path extends `${infer _Before}*${infer After}` ? { [K in CountWildcards<_Before, "0">]: string } & ExtractParams<After> : {};
+/**
+ * Extract parameters from Express 5 optional segments in braces
+ * Handles patterns like {/:param}, {.:ext}, {/optional/:param}
+ */
+type ExtractOptionalSegment<Content extends string> = Content extends `/:${infer Rest}` ? ExtractOptionalParam<Rest> : Content extends `.:${infer Rest}` ? ExtractOptionalParam<Rest> : Content extends `${infer _Path}:${infer Rest}` ? ExtractOptionalParam<Rest> : {};
+/**
+ * Extract a single optional parameter from brace content
+ */
+type ExtractOptionalParam<Rest extends string> = Rest extends `${infer ParamName}/${infer _After}` ? { [K in ParamName]?: string } : Rest extends `${infer ParamName}-${infer _After}` ? { [K in ParamName]?: string } : Rest extends `${infer ParamName}.${infer _After}` ? { [K in ParamName]?: string } : Rest extends `${infer ParamName}` ? { [K in ParamName]?: string } : {};
+/**
+ * Extract a single parameter name from the rest of the path
+ * Enhanced to handle Express 5 patterns and optional parameters correctly
+ * Special handling for consecutive parameters like :from-:to
+ * Order matters: regex constraints must be handled before repeating parameters
+ */
+type ExtractSingleParam<Rest extends string> = Rest extends `${infer ParamName}(${infer _Constraint})${infer _After}` ? { [K in ParamName]: string } : Rest extends `${infer ParamName}-:${infer _NextParam}` ? { [K in ParamName]: string } : Rest extends `${infer ParamName}.:${infer _NextParam}` ? { [K in ParamName]: string } : Rest extends `${infer ParamName}?/${infer _After}` ? { [K in ParamName]?: string } : Rest extends `${infer ParamName}?-${infer _After}` ? { [K in ParamName]?: string } : Rest extends `${infer ParamName}?.${infer _After}` ? { [K in ParamName]?: string } : Rest extends `${infer ParamName}?#${infer _After}` ? { [K in ParamName]?: string } : Rest extends `${infer ParamName}?:${infer _After}` ? { [K in ParamName]?: string } : Rest extends `${infer ParamName}/${infer _After}` ? { [K in ParamName]: string } : Rest extends `${infer ParamName}-${infer _After}` ? { [K in ParamName]: string } : Rest extends `${infer ParamName}.${infer _After}` ? { [K in ParamName]: string } : Rest extends `${infer ParamName}#${infer _After}` ? { [K in ParamName]: string } : Rest extends `${infer ParamName}:${infer _After}` ? { [K in ParamName]: string } : Rest extends `${infer ParamName}+${infer _After}` ? { [K in ParamName]: string[] } : Rest extends `${infer ParamName}*${infer _After}` ? { [K in ParamName]?: string[] } : Rest extends `${infer ParamName}?${infer _After}` ? { [K in ParamName]?: string } : Rest extends string ? Rest extends "" ? {} : Rest extends `${infer ParamName}?` ? { [K in ParamName]?: string } : Rest extends `${infer ParamName}+` ? { [K in ParamName]: string[] } : Rest extends `${infer ParamName}*` ? { [K in ParamName]?: string[] } : { [K in Rest]: string } : {};
+/**
+ * Remove the first parameter from path to continue parsing
+ * Enhanced to handle Express 5 patterns and optional parameters
+ * Handles patterns like :from-:to by removing just :from and keeping -:to
+ * Order matters: regex constraints must be handled before repeating parameters
+ */
+type RemoveFirstParam<Path extends string> = Path extends `${infer Before}:${infer Rest}` ? Rest extends `${infer _ParamName}(${infer _Constraint})${infer After}` ? `${Before}${After}` : Rest extends `${infer _ParamName}-:${infer After}` ? `${Before}-:${After}` : Rest extends `${infer _ParamName}.:${infer After}` ? `${Before}.:${After}` : Rest extends `${infer _ParamName}?/${infer After}` ? `${Before}/${After}` : Rest extends `${infer _ParamName}?-${infer After}` ? `${Before}${After}` : Rest extends `${infer _ParamName}?.${infer After}` ? `${Before}${After}` : Rest extends `${infer _ParamName}?#${infer After}` ? `${Before}${After}` : Rest extends `${infer _ParamName}?:${infer After}` ? `${Before}:${After}` : Rest extends `${infer _ParamName}/${infer After}` ? `${Before}/${After}` : Rest extends `${infer _ParamName}-${infer After}` ? `${Before}${After}` : Rest extends `${infer _ParamName}.${infer After}` ? `${Before}${After}` : Rest extends `${infer _ParamName}#${infer After}` ? `${Before}${After}` : Rest extends `${infer _ParamName}:${infer After}` ? `${Before}:${After}` : Rest extends `${infer _ParamName}+${infer After}` ? `${Before}${After}` : Rest extends `${infer _ParamName}*${infer After}` ? `${Before}${After}` : Rest extends `${infer _ParamName}?${infer After}` ? `${Before}${After}` : Before : Path;
+/**
+ * Count wildcards to assign proper numeric indices with recursion depth limit
+ */
+type CountWildcards<Path extends string, Count extends string = "0"> = Path extends `${infer _Before}*${infer Rest}` ? CountWildcards<Rest, IncrementWildcard<Count>> : Count;
+/**
+ * Helper type to increment wildcard count as string
+ */
+type IncrementWildcard<T extends string> = T extends "0" ? "1" : T extends "1" ? "2" : T extends "2" ? "3" : T extends "3" ? "4" : T extends "4" ? "5" : T extends "5" ? "6" : T extends "6" ? "7" : T extends "7" ? "8" : T extends "8" ? "9" : "10";
+/**
+ * Express middleware that adds custom properties to the request object and/or response locals.
+ *
+ * @template TReq - The shape of the properties added to the request object.
+ * @template TLocals - The shape of the properties added to response.locals.
+ * @param req - The Express request object, extended with TReq.
+ * @param res - The Express response object with typed locals.
+ * @param next - The next middleware function.
+ */
+type TypedMiddleware<TReq extends Record<string, any> = {}, TLocals extends Record<string, any> = {}> = (req: Request & TReq, res: Response<any, TLocals>, next: NextFunction) => void | Promise<void>;
+/**
+ * Simplified TypedMiddleware for request-only extensions (backward compatibility)
+ */
+type RequestOnlyMiddleware<TReq extends Record<string, any>> = TypedMiddleware<TReq, {}>;
+/**
+ * Simplified TypedMiddleware for response locals-only extensions
+ */
+type LocalsOnlyMiddleware<TLocals extends Record<string, any>> = TypedMiddleware<{}, TLocals>;
+type InferMiddlewareProps<T extends readonly TypedMiddleware<any, any>[]> = T extends readonly [infer First, ...infer Rest] ? First extends TypedMiddleware<infer FirstReq, any> ? Rest extends readonly TypedMiddleware<any, any>[] ? FirstReq & InferMiddlewareProps<Rest> : FirstReq : {} : {};
+type InferMiddlewareLocals<T extends readonly TypedMiddleware<any, any>[]> = T extends readonly [infer First, ...infer Rest] ? First extends TypedMiddleware<any, infer FirstLocals> ? Rest extends readonly TypedMiddleware<any, any>[] ? FirstLocals & InferMiddlewareLocals<Rest> : FirstLocals : {} : {};
+type SchemaRequest<Path extends string = string, BodySchema extends AnyStandardSchema | unknown = unknown, QuerySchema extends AnyStandardSchema | unknown = unknown, MiddlewareProps extends Record<string, any> = {}> = Omit<Request, "params" | "query" | "body"> & {
+  params: ExtractRouteParams<Path>;
+  body: BodySchema extends unknown ? InferSchemaOutput<BodySchema> : unknown;
+  query: QuerySchema extends unknown ? InferSchemaOutput<QuerySchema> : unknown;
+} & MiddlewareProps;
+type SchemaRouteHandler<Path extends string = string, BodySchema extends AnyStandardSchema | unknown = unknown, QuerySchema extends AnyStandardSchema | unknown = unknown, MiddlewareProps extends Record<string, any> = {}, ResponseLocals extends Record<string, any> = {}> = (req: SchemaRequest<Path, BodySchema, QuerySchema, MiddlewareProps>, res: Response<any, ResponseLocals>, next?: NextFunction) => void | undefined | Promise<void | undefined> | Response | Promise<Response> | Promise<Response | undefined>;
+/**
+ * Options for defining a typed route, including schemas and middleware.
+ *
+ * @template BodySchema - Schema for request body validation.
+ * @template QuerySchema - Schema for query parameter validation.
+ * @property bodySchema - Optional schema for validating the request body.
+ * @property querySchema - Optional schema for validating the query string.
+ * @property middleware - Optional array of TypedMiddleware for this route.
+ */
+interface RouteOptions<BodySchema extends AnyStandardSchema | unknown = unknown, QuerySchema extends AnyStandardSchema | unknown = unknown> {
+  bodySchema?: BodySchema;
+  querySchema?: QuerySchema;
+  middleware?: TypedMiddleware<any, any>[];
+}
+type HttpMethod = "get" | "post" | "put" | "delete" | "patch" | "options" | "head" | "all";
+declare class TypedRouter<RouterMiddlewareProps extends Record<string, any> = {}, RouterLocals extends Record<string, any> = {}> {
+  private router;
+  constructor();
+  /**
+   * Add typed middleware that extends the request with additional properties
+   * and/or adds properties to response.locals
+   */ /**
+      * Add typed middleware to the router.
+      * This middleware will apply to all routes defined after this call.
+      *
+      * @template TReq - Type extensions for the request object
+      * @template TLocals - Type extensions for response.locals
+      * @param middleware - The typed middleware function
+      * @returns A new router instance with updated types
+      */
+  useMiddleware<TReq extends Record<string, any> = {}, TLocals extends Record<string, any> = {}>(middleware: TypedMiddleware<TReq, TLocals>): TypedRouter<RouterMiddlewareProps & TReq, RouterLocals & TLocals>;
+  /**
+   * Get the underlying Express router
+   */
+  getRouter(): express.Router;
+  get<Path extends string>(path: Path, handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  get<Path extends string, BodySchema extends AnyStandardSchema | unknown, QuerySchema extends AnyStandardSchema | unknown>(path: Path, options: RouteOptions<BodySchema, QuerySchema>, handler: SchemaRouteHandler<Path, BodySchema, QuerySchema, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  get<Path extends string, Middleware extends readonly TypedMiddleware<any, any>[]>(path: Path, options: {
+    middleware: Middleware;
+  }, handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps & InferMiddlewareProps<Middleware>, RouterLocals & InferMiddlewareLocals<Middleware>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  get<Path extends string, BodySchema extends AnyStandardSchema | unknown, QuerySchema extends AnyStandardSchema | unknown, M extends TypedMiddleware<any, any>[]>(path: Path, options: RouteOptions<BodySchema, QuerySchema> & {
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, BodySchema, QuerySchema, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  post<Path extends string, BodySchema extends AnyStandardSchema, QuerySchema extends AnyStandardSchema | unknown, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    bodySchema: BodySchema;
+    querySchema?: QuerySchema;
+    middleware: [...M];
+  }, handler: SchemaRouteHandler<Path, BodySchema, QuerySchema, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  post<Path extends string, BodySchema extends AnyStandardSchema, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    bodySchema: BodySchema;
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, BodySchema, unknown, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  post<Path extends string, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  post<Path extends string, BodySchema extends AnyStandardSchema | unknown, QuerySchema extends AnyStandardSchema | unknown>(path: Path, options: RouteOptions<BodySchema, QuerySchema>, handler: SchemaRouteHandler<Path, BodySchema, QuerySchema, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  post<Path extends string>(path: Path, handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  put<Path extends string, BodySchema extends AnyStandardSchema, QuerySchema extends AnyStandardSchema | unknown, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    bodySchema: BodySchema;
+    querySchema?: QuerySchema;
+    middleware: [...M];
+  }, handler: SchemaRouteHandler<Path, BodySchema, QuerySchema, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  put<Path extends string, BodySchema extends AnyStandardSchema, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    bodySchema: BodySchema;
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, BodySchema, unknown, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  put<Path extends string, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  put<Path extends string, BodySchema extends AnyStandardSchema | unknown, QuerySchema extends AnyStandardSchema | unknown>(path: Path, options: RouteOptions<BodySchema, QuerySchema>, handler: SchemaRouteHandler<Path, BodySchema, QuerySchema, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  put<Path extends string>(path: Path, handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  patch<Path extends string, BodySchema extends AnyStandardSchema, QuerySchema extends AnyStandardSchema | unknown, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    bodySchema: BodySchema;
+    querySchema?: QuerySchema;
+    middleware: [...M];
+  }, handler: SchemaRouteHandler<Path, BodySchema, QuerySchema, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  patch<Path extends string, BodySchema extends AnyStandardSchema, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    bodySchema: BodySchema;
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, BodySchema, unknown, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  patch<Path extends string, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  patch<Path extends string, BodySchema extends AnyStandardSchema | unknown, QuerySchema extends AnyStandardSchema | unknown>(path: Path, options: RouteOptions<BodySchema, QuerySchema>, handler: SchemaRouteHandler<Path, BodySchema, QuerySchema, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  patch<Path extends string>(path: Path, handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  delete<Path extends string, QuerySchema extends AnyStandardSchema | unknown, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    querySchema: QuerySchema;
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, unknown, QuerySchema, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  delete<Path extends string, QuerySchema extends AnyStandardSchema | unknown>(path: Path, options: {
+    querySchema: QuerySchema;
+  }, handler: SchemaRouteHandler<Path, unknown, QuerySchema, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  delete<Path extends string, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  delete<Path extends string>(path: Path, handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  options<Path extends string, QuerySchema extends AnyStandardSchema | unknown, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    querySchema: QuerySchema;
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, unknown, QuerySchema, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  options<Path extends string, QuerySchema extends AnyStandardSchema | unknown>(path: Path, options: {
+    querySchema: QuerySchema;
+  }, handler: SchemaRouteHandler<Path, unknown, QuerySchema, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  options<Path extends string, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  options<Path extends string>(path: Path, handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  head<Path extends string, QuerySchema extends AnyStandardSchema | unknown, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    querySchema: QuerySchema;
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, unknown, QuerySchema, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  head<Path extends string, QuerySchema extends AnyStandardSchema | unknown>(path: Path, options: {
+    querySchema: QuerySchema;
+  }, handler: SchemaRouteHandler<Path, unknown, QuerySchema, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  head<Path extends string, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  head<Path extends string>(path: Path, handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  all<Path extends string, BodySchema extends AnyStandardSchema, QuerySchema extends AnyStandardSchema | unknown, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    bodySchema: BodySchema;
+    querySchema?: QuerySchema;
+    middleware: [...M];
+  }, handler: SchemaRouteHandler<Path, BodySchema, QuerySchema, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  all<Path extends string, BodySchema extends AnyStandardSchema, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    bodySchema: BodySchema;
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, BodySchema, unknown, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  all<Path extends string, QuerySchema extends AnyStandardSchema | unknown, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    querySchema: QuerySchema;
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, unknown, QuerySchema, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  all<Path extends string, BodySchema extends AnyStandardSchema | unknown, QuerySchema extends AnyStandardSchema | unknown>(path: Path, options: RouteOptions<BodySchema, QuerySchema>, handler: SchemaRouteHandler<Path, BodySchema, QuerySchema, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  all<Path extends string, M extends TypedMiddleware<any, any>[]>(path: Path, options: {
+    middleware: [...M];
+  },
+  // Using tuple spread pattern
+  handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps & InferMiddlewareProps<readonly [...M]>,
+  // Make it readonly for type inference
+  // Make it readonly for type inference
+  RouterLocals & InferMiddlewareLocals<readonly [...M]>>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  all<Path extends string>(path: Path, handler: SchemaRouteHandler<Path, unknown, unknown, RouterMiddlewareProps, RouterLocals>): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+  private registerRoute;
+  private createBodyValidationMiddleware;
+  private createQueryValidationMiddleware;
+}
+/**
+ * Create a new strongly-typed Express router instance.
+ *
+ * This is the simplest way to get started with @minisylar/express-typed-router.
+ *
+ * @example
+ * import { createTypedRouter } from '@minisylar/express-typed-router';
+ *
+ * // Create a router and add a typed GET route
+ * const router = createTypedRouter();
+ * router.get('/hello/:name', (req, res) => {
+ *   // req.params.name is typed as string
+ *   res.json({ message: `Hello, ${req.params.name}!` });
+ * });
+ *
+ * // Use with Express
+ * import express from 'express';
+ * const app = express();
+ * app.use('/api', router.getRouter());
+ */
+declare function createTypedRouter<RouterMiddlewareProps extends Record<string, any> = {}, RouterLocals extends Record<string, any> = {}>(): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+/**
+ * Configuration options for createTypedRouterWithConfig.
+ *
+ * @property validateInput - (Future) Whether to enable global input validation.
+ * @property errorHandler - Optional global error handler middleware for the router.
+ */
+interface RouterConfig {
+  validateInput?: boolean;
+  errorHandler?: (error: any, req: Request, res: Response, next: NextFunction) => void;
+}
+/**
+ * Create a new typed router with optional configuration.
+ *
+ * Use this if you want to add a global error handler or future global options.
+ *
+ * @param config - Optional configuration for the router (e.g. error handler).
+ * @returns A new TypedRouter instance.
+ *
+ * @example
+ * import { createTypedRouterWithConfig } from '@minisylar/express-typed-router';
+ *
+ * const router = createTypedRouterWithConfig({
+ *   errorHandler: (err, req, res, next) => {
+ *     res.status(500).json({ error: 'Something went wrong', details: err });
+ *   }
+ * });
+ */
+declare function createTypedRouterWithConfig<RouterMiddlewareProps extends Record<string, any> = {}, RouterLocals extends Record<string, any> = {}>(config?: RouterConfig): TypedRouter<RouterMiddlewareProps, RouterLocals>;
+/**
+ * Create a new typed router with pre-configured middleware.
+ *
+ * This is useful for setting up router-level middleware in a single call.
+ *
+ * @param middleware - One or more TypedMiddleware functions to apply to all routes.
+ * @returns A new TypedRouter instance with the middleware applied.
+ *
+ * @example
+ * import { createTypedRouterWithMiddleware } from '@minisylar/express-typed-router';
+ *
+ * const router = createTypedRouterWithMiddleware(authMiddleware, loggingMiddleware);
+ */
+declare function createTypedRouterWithMiddleware<T extends Record<string, any>>(...middleware: TypedMiddleware<any, any>[]): TypedRouter<T>;
+//#endregion
+export { AnyStandardSchema, ExtractRouteParams, HttpMethod, InferInput, InferOutput, InferSchemaOutput, LocalsOnlyMiddleware, RequestOnlyMiddleware, RouteOptions, RouterConfig, SafeParseResult, SchemaRequest, SchemaRouteHandler, TypedMiddleware, createTypedRouter, createTypedRouterWithConfig, createTypedRouterWithMiddleware, isSchemaError, parseSchema, safeParseSchema };