@forklaunch/hyper-express 1.2.31 → 1.2.33

package/lib/index.d.ts

@@ -1,860 +1,20 @@
-import * as _forklaunch_core_http from '@forklaunch/core/http';
-import { ParamsObject, ResponsesObject, Body, QueryObject, HeadersObject, VersionSchema, SchemaAuthMethods, ContractDetails, ExpressLikeSchemaHandler, ResolvedSessionObject, SessionObject, ExpressLikeApplicationOptions, ExpressLikeRouterOptions, ForklaunchExpressLikeApplication, OpenTelemetryCollector, MetricsDefinition, ParsedQs, StringOnlyObject, MiddlewareContractDetails, PathMatch, TypedHandler, ForklaunchExpressLikeRouter, ForklaunchRouter, TypedMiddlewareDefinition, Method, ContractDetailsOrMiddlewareOrTypedHandler, MiddlewareOrMiddlewareWithTypedHandler } from '@forklaunch/core/http';
-import { Request, Response, MiddlewareNext, ServerConstructorOptions, Server, MiddlewareHandler, Router as Router$1, WSRouteOptions, WSRouteHandler } from '@forklaunch/hyper-express-fork';
-export { MiddlewareNext as NextFunction, Request, Response, ServerConstructorOptions } from '@forklaunch/hyper-express-fork';
-import { AnySchemaValidator, Schema } from '@forklaunch/validator';
-import * as uWebsockets from 'uWebSockets.js';
-import { BusboyConfig } from 'busboy';
-export { BusboyConfig } from 'busboy';
-import { CorsOptions } from 'cors';
-export { CorsOptions } from 'cors';
-import { EventSchema } from '@forklaunch/core/ws';
-
-/**
- * Creates a route handler that matches any HTTP method with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Path - The route path type (must start with '/')
- * @template P - The path parameters type
- * @template ResBodyMap - The response body map type
- * @template ReqBody - The request body type
- * @template ReqQuery - The request query parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'any', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request<LocalsObj>>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]} handlers - The route handlers
- *
- * @returns {void} - Returns nothing, registers the route with Hyper-Express
- *
- * @example
- * ```typescript
- * any(
- *   schemaValidator,
- *   '/webhooks',
- *   {
- *     summary: 'Webhook endpoint',
- *     description: 'Handles webhook requests from any HTTP method',
- *     tags: ['webhooks'],
- *     responses: {
- *       200: {
- *         description: 'Webhook processed successfully',
- *         content: {
- *           'application/json': {
- *             schema: {
- *               type: 'object',
- *               properties: {
- *                 status: { type: 'string' }
- *               }
- *             }
- *           }
- *         }
- *       }
- *     }
- *   },
- *   async (req, res) => {
- *     const method = req.method;
- *     const body = await req.json();
- *     await processWebhook(method, body);
- *     res.status(200).json({ status: 'processed' });
- *   }
- * );
- * ```
- */
-declare const any: <SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, "middleware">, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, Request<LocalsObj>>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[];
-};
-
-/**
- * Creates a DELETE route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Path - The route path type (must start with '/')
- * @template P - The path parameters type
- * @template ResBodyMap - The response body map type
- * @template ReqBody - The request body type
- * @template ReqQuery - The request query parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'delete', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request<LocalsObj>>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]} handlers - The route handlers
- *
- * @returns {void} - Returns nothing, registers the route with Hyper-Express
- *
- * @example
- * ```typescript
- * delete_(
- *   schemaValidator,
- *   '/users/:id',
- *   {
- *     summary: 'Delete user',
- *     description: 'Deletes a user by ID',
- *     tags: ['users'],
- *     parameters: [
- *       {
- *         name: 'id',
- *         in: 'path',
- *         required: true,
- *         schema: { type: 'string' }
- *       }
- *     ],
- *     responses: {
- *       204: {
- *         description: 'User deleted successfully'
- *       },
- *       404: {
- *         description: 'User not found',
- *         content: {
- *           'application/json': {
- *             schema: {
- *               type: 'object',
- *               properties: {
- *                 error: { type: 'string' }
- *               }
- *             }
- *           }
- *         }
- *       }
- *     }
- *   },
- *   async (req, res) => {
- *     const { id } = req.params;
- *     await deleteUser(id);
- *     res.status(204).end();
- *   }
- * );
- * ```
- */
-declare const delete_: <SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, "delete">, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, Request<LocalsObj>>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "delete", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "delete", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext, Auth>;
-
-/**
- * Creates a GET route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Path - The route path type (must start with '/')
- * @template P - The path parameters type
- * @template ResBodyMap - The response body map type
- * @template ReqBody - The request body type
- * @template ReqQuery - The request query parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'get', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request<LocalsObj>>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]} handlers - The route handlers
- *
- * @returns {void} - Returns nothing, registers the route with Hyper-Express
- *
- * @example
- * ```typescript
- * get(
- *   schemaValidator,
- *   '/users/:id',
- *   {
- *     summary: 'Get user',
- *     description: 'Retrieves a user by ID',
- *     tags: ['users'],
- *     parameters: [
- *       {
- *         name: 'id',
- *         in: 'path',
- *         required: true,
- *         schema: { type: 'string' }
- *       }
- *     ],
- *     responses: {
- *       200: {
- *         description: 'User retrieved successfully',
- *         content: {
- *           'application/json': {
- *             schema: {
- *               type: 'object',
- *               properties: {
- *                 id: { type: 'string' },
- *                 name: { type: 'string' },
- *                 email: { type: 'string' }
- *               }
- *             }
- *           }
- *         }
- *       },
- *       404: {
- *         description: 'User not found',
- *         content: {
- *           'application/json': {
- *             schema: {
- *               type: 'object',
- *               properties: {
- *                 error: { type: 'string' }
- *               }
- *             }
- *           }
- *         }
- *       }
- *     }
- *   },
- *   async (req, res) => {
- *     const { id } = req.params;
- *     const user = await getUser(id);
- *     res.status(200).json(user);
- *   }
- * );
- * ```
- */
-declare const get: <SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, "get">, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, Request<LocalsObj>>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "get", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "get", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext, Auth>;
-
-/**
- * Creates a HEAD route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Path - The route path type (must start with '/')
- * @template P - The path parameters type
- * @template ResBodyMap - The response body map type
- * @template ReqBody - The request body type
- * @template ReqQuery - The request query parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'head', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request<LocalsObj>>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]} handlers - The route handlers
- *
- * @returns {void} - Returns nothing, registers the route with Hyper-Express
- *
- * @example
- * ```typescript
- * head(
- *   schemaValidator,
- *   '/files/:id',
- *   {
- *     summary: 'Get file metadata',
- *     description: 'Retrieves metadata for a file without downloading its contents',
- *     tags: ['files'],
- *     parameters: [
- *       {
- *         name: 'id',
- *         in: 'path',
- *         required: true,
- *         schema: { type: 'string' }
- *       }
- *     ],
- *     responses: {
- *       200: {
- *         description: 'File metadata retrieved successfully',
- *         headers: {
- *           'content-length': {
- *             schema: { type: 'string' }
- *           },
- *           'content-type': {
- *             schema: { type: 'string' }
- *           },
- *           'last-modified': {
- *             schema: { type: 'string' }
- *           }
- *         }
- *       },
- *       404: {
- *         description: 'File not found'
- *       }
- *     }
- *   },
- *   async (req, res) => {
- *     const { id } = req.params;
- *     const metadata = await getFileMetadata(id);
- *     res.setHeader('content-length', metadata.size);
- *     res.setHeader('content-type', metadata.type);
- *     res.setHeader('last-modified', metadata.lastModified);
- *     res.status(200).end();
- *   }
- * );
- * ```
- */
-declare const head: <SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, "head">, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, Request<LocalsObj>>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "head", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "head", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext, Auth>;
-
-/**
- * Creates a middleware handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Path - The route path type (must start with '/')
- * @template P - The path parameters type
- * @template ResBodyMap - The response body map type
- * @template ReqBody - The request body type
- * @template ReqQuery - The request query parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request<LocalsObj>>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]} handlers - The route handlers
- *
- * @returns {void} - Returns nothing, registers the middleware with Hyper-Express
- *
- * @example
- * ```typescript
- * middleware(
- *   schemaValidator,
- *   '/api/*',
- *   {
- *     summary: 'Authentication middleware',
- *     description: 'Validates JWT tokens for API routes',
- *     tags: ['auth'],
- *     responses: {
- *       401: {
- *         description: 'Unauthorized',
- *         content: {
- *           'application/json': {
- *             schema: {
- *               type: 'object',
- *               properties: {
- *                 error: { type: 'string' }
- *               }
- *             }
- *           }
- *         }
- *       }
- *     }
- *   },
- *   async (req, res, next) => {
- *     const token = req.headers.authorization?.split(' ')[1];
- *     if (!token) {
- *       res.status(401).json({ error: 'No token provided' });
- *       return;
- *     }
- *     try {
- *       const decoded = await verifyToken(token);
- *       req.user = decoded;
- *       next();
- *     } catch (err) {
- *       res.status(401).json({ error: 'Invalid token' });
- *     }
- *   }
- * );
- * ```
- */
-declare const middleware: <SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, "middleware">, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, Request<LocalsObj>>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[];
-};
-
-/**
- * Creates an OPTIONS route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Path - The route path type (must start with '/')
- * @template P - The path parameters type
- * @template ResBodyMap - The response body map type
- * @template ReqBody - The request body type
- * @template ReqQuery - The request query parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'options', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request<LocalsObj>>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]} handlers - The route handlers
- *
- * @returns {void} - Returns nothing, registers the route with Hyper-Express
- *
- * @example
- * ```typescript
- * options(
- *   schemaValidator,
- *   '/users/:id',
- *   {
- *     summary: 'Get user options',
- *     description: 'Returns the allowed HTTP methods for the user resource',
- *     tags: ['users'],
- *     parameters: [
- *       {
- *         name: 'id',
- *         in: 'path',
- *         required: true,
- *         schema: { type: 'string' }
- *       }
- *     ],
- *     responses: {
- *       200: {
- *         description: 'Allowed methods retrieved successfully',
- *         headers: {
- *           'allow': {
- *             schema: { type: 'string' }
- *           }
- *         }
- *       }
- *     }
- *   },
- *   async (req, res) => {
- *     res.setHeader('allow', 'GET, PUT, PATCH, DELETE');
- *     res.status(200).end();
- *   }
- * );
- * ```
- */
-declare const options: <SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, "options">, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, Request<LocalsObj>>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "options", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "options", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext, Auth>;
-
-/**
- * Creates a PATCH route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Path - The route path type (must start with '/')
- * @template P - The path parameters type
- * @template ResBodyMap - The response body map type
- * @template ReqBody - The request body type
- * @template ReqQuery - The request query parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'patch', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request<LocalsObj>>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]} handlers - The route handlers
- *
- * @returns {void} - Returns nothing, registers the route with Hyper-Express
- *
- * @example
- * ```typescript
- * patch(
- *   schemaValidator,
- *   '/users/:id',
- *   {
- *     summary: 'Update user partially',
- *     description: 'Updates specific fields of a user by ID',
- *     tags: ['users'],
- *     parameters: [
- *       {
- *         name: 'id',
- *         in: 'path',
- *         required: true,
- *         schema: { type: 'string' }
- *       }
- *     ],
- *     requestBody: {
- *       content: {
- *         'application/json': {
- *           schema: {
- *             type: 'object',
- *             properties: {
- *               name: { type: 'string' },
- *               email: { type: 'string' }
- *             }
- *           }
- *         }
- *       }
- *     },
- *     responses: {
- *       200: {
- *         description: 'User updated successfully',
- *         content: {
- *           'application/json': {
- *             schema: {
- *               type: 'object',
- *               properties: {
- *                 id: { type: 'string' },
- *                 name: { type: 'string' },
- *                 email: { type: 'string' }
- *               }
- *             }
- *           }
- *         }
- *       },
- *       404: {
- *         description: 'User not found',
- *         content: {
- *           'application/json': {
- *             schema: {
- *               type: 'object',
- *               properties: {
- *                 error: { type: 'string' }
- *               }
- *             }
- *           }
- *         }
- *       }
- *     }
- *   },
- *   async (req, res) => {
- *     const { id } = req.params;
- *     const updates = await req.json();
- *     const user = await updateUser(id, updates);
- *     res.status(200).json(user);
- *   }
- * );
- * ```
- */
-declare const patch: <SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, "patch">, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, Request<LocalsObj>>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "patch", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "patch", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext, Auth>;
-
-/**
- * Creates a POST route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Path - The route path type (must start with '/')
- * @template P - The path parameters type
- * @template ResBodyMap - The response body map type
- * @template ReqBody - The request body type
- * @template ReqQuery - The request query parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'post', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request<LocalsObj>>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]} handlers - The route handlers
- *
- * @returns {void} - Returns nothing, registers the route with Hyper-Express
- *
- * @example
- * ```typescript
- * post(
- *   schemaValidator,
- *   '/users',
- *   {
- *     summary: 'Create user',
- *     description: 'Creates a new user',
- *     tags: ['users'],
- *     requestBody: {
- *       content: {
- *         'application/json': {
- *           schema: {
- *             type: 'object',
- *             properties: {
- *               name: { type: 'string' },
- *               email: { type: 'string' },
- *               password: { type: 'string' }
- *             },
- *             required: ['name', 'email', 'password']
- *           }
- *         }
- *       }
- *     },
- *     responses: {
- *       201: {
- *         description: 'User created successfully',
- *         content: {
- *           'application/json': {
- *             schema: {
- *               type: 'object',
- *               properties: {
- *                 id: { type: 'string' },
- *                 name: { type: 'string' },
- *                 email: { type: 'string' }
- *               }
- *             }
- *           }
- *         }
- *       },
- *       400: {
- *         description: 'Invalid input',
- *         content: {
- *           'application/json': {
- *             schema: {
- *               type: 'object',
- *               properties: {
- *                 error: { type: 'string' }
- *               }
- *             }
- *           }
- *         }
- *       }
- *     }
- *   },
- *   async (req, res) => {
- *     const userData = await req.json();
- *     const user = await createUser(userData);
- *     res.status(201).json(user);
- *   }
- * );
- * ```
- */
-declare const post: <SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, "post">, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, Request<LocalsObj>>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "post", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "post", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext, Auth>;
-
-/**
- * Creates a PUT route handler with schema validation and type safety for Hyper-Express.
- *
- * @template SV - The schema validator type
- * @template Path - The route path type (must start with '/')
- * @template P - The path parameters type
- * @template ResBodyMap - The response body map type
- * @template ReqBody - The request body type
- * @template ReqQuery - The request query parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'put', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request<LocalsObj>>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]} handlers - The route handlers
- *
- * @returns {void} - Returns nothing, registers the route with Hyper-Express
- *
- * @example
- * ```typescript
- * put(
- *   schemaValidator,
- *   '/users/:id',
- *   {
- *     summary: 'Update user',
- *     description: 'Updates a user by ID',
- *     tags: ['users'],
- *     pathParams: {
- *       id: { type: 'string' }
- *     },
- *     body: {
- *       type: 'object',
- *       properties: {
- *         name: { type: 'string' }
- *       }
- *     },
- *     responses: {
- *       200: {
- *         description: 'User updated successfully',
- *         content: {
- *           'application/json': {
- *             schema: {
- *               type: 'object',
- *               properties: {
- *                 id: { type: 'string' },
- *                 name: { type: 'string' }
- *               }
- *             }
- *           }
- *         }
- *       }
- *     }
- *   },
- *   async (req, res) => {
- *     const { id } = req.params;
- *     const { name } = req.body;
- *     // Update user logic
- *     res.json({ id, name });
- *   }
- * );
- * ```
- */
-declare const put: <SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, "put">, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, Request<LocalsObj>>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "put", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "put", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext, Auth>;
-
-/**
- * Creates a TRACE route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Path - The route path type (must start with '/')
- * @template P - The path parameters type
- * @template ResBodyMap - The response body map type
- * @template ReqBody - The request body type
- * @template ReqQuery - The request query parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'trace', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request<LocalsObj>>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]} handlers - The route handlers
- *
- * @returns {void} - Returns nothing, registers the route with Hyper-Express
- *
- * @example
- * ```typescript
- * trace(
- *   schemaValidator,
- *   '/debug',
- *   {
- *     summary: 'Debug endpoint',
- *     description: 'Returns the request message for debugging purposes',
- *     tags: ['debug'],
- *     responses: {
- *       200: {
- *         description: 'Request message returned successfully',
- *         content: {
- *           'message/http': {
- *             schema: {
- *               type: 'string'
- *             }
- *           }
- *         }
- *       }
- *     }
- *   },
- *   async (req, res) => {
- *     const message = await req.text();
- *     res.setHeader('content-type', 'message/http');
- *     res.status(200).send(message);
- *   }
- * );
- * ```
- */
-declare const trace: <SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, "trace">, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, Request<LocalsObj>>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "trace", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<LocalsObj>, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "trace", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<LocalsObj>, Response<LocalsObj>, MiddlewareNext, Auth>;
-
-type ExpressApplicationOptions<SV extends AnySchemaValidator, SessionSchema extends SessionObject<SV>> = ExpressLikeApplicationOptions<SV, SessionSchema> & {
-    busboy?: BusboyConfig;
-    server?: ServerConstructorOptions;
-    cors?: CorsOptions;
-};
-type ExpressRouterOptions<SV extends AnySchemaValidator, SessionSchema extends SessionObject<SV>> = ExpressLikeRouterOptions<SV, SessionSchema> & {
-    busboy?: BusboyConfig;
-};
-
-/**
- * Represents an application built on top of Hyper-Express and Forklaunch.
- * This class provides a high-performance web server implementation using uWebSockets.js
- * with Forklaunch's schema validation and API documentation capabilities.
- *
- * @template SV - Schema validator type extending AnySchemaValidator
- *
- * @example
- * ```typescript
- * const app = new Application(schemaValidator, openTelemetryCollector);
- *
- * app.get('/users', {
- *   responses: {
- *     200: { type: 'array', items: { type: 'object' } }
- *   }
- * }, async (req, res) => {
- *   res.json(await getUsers());
- * });
- *
- * await app.listen(3000);
- * ```
- */
-declare class Application<SV extends AnySchemaValidator, SessionSchema extends SessionObject<SV>> extends ForklaunchExpressLikeApplication<SV, Server, MiddlewareHandler, Request<Record<string, unknown>>, Response<Record<string, unknown>>, MiddlewareNext, SessionSchema> {
-    private docsConfiguration;
-    private mcpConfiguration;
-    private openapiConfiguration;
-    private hostingConfiguration;
-    /**
-     * Creates an instance of the Application class.
-     *
-     * @param {SV} schemaValidator - Schema validator for request/response validation
-     * @param {OpenTelemetryCollector<MetricsDefinition>} openTelemetryCollector - Collector for OpenTelemetry metrics
-     * @param {DocsConfiguration} [docsConfiguration] - Optional configuration for API documentation (Swagger/Scalar)
-     *
-     * @example
-     * ```typescript
-     * const app = new Application(
-     *   new SchemaValidator(),
-     *   new OpenTelemetryCollector(),
-     *   { type: 'swagger' }
-     * );
-     * ```
-     */
-    constructor(schemaValidator: SV, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, configurationOptions?: ExpressApplicationOptions<SV, SessionSchema>);
-    /**
-     * Starts the server and sets up API documentation.
-     * Supports multiple listening configurations including port, host, and UNIX socket path.
-     * Automatically sets up Swagger or Scalar documentation based on configuration.
-     *
-     * @param {number | string} arg0 - Port number or UNIX socket path
-     * @param {string | Function} [arg1] - Host name or callback function
-     * @param {Function} [arg2] - Callback function when host is specified
-     * @returns {Promise<uWebsockets.us_listen_socket>} Promise resolving to the listening socket
-     *
-     * @example
-     * ```typescript
-     * // Listen on port 3000
-     * await app.listen(3000);
-     *
-     * // Listen on specific host and port
-     * await app.listen(3000, 'localhost');
-     *
-     * // Listen on UNIX socket
-     * await app.listen('/tmp/app.sock');
-     *
-     * // With callback
-     * await app.listen(3000, (socket) => {
-     *   console.log('Server started');
-     * });
-     * ```
-     */
-    listen(port: number, callback?: (listen_socket: uWebsockets.us_listen_socket) => void): Promise<uWebsockets.us_listen_socket>;
-    listen(port: number, host?: string, callback?: (listen_socket: uWebsockets.us_listen_socket) => void): Promise<uWebsockets.us_listen_socket>;
-    listen(unix_path: string, callback?: (listen_socket: uWebsockets.us_listen_socket) => void): Promise<uWebsockets.us_listen_socket>;
-}
-
-/**
- * A request handler function compatible with Hyper-Express, used for processing HTTP requests.
- *
- * @param req - The incoming request object, with `query` and `headers` properties normalized to either `ParsedQs` or a generic record.
- * @param res - The response object for sending data back to the client.
- * @param next - The middleware next function to pass control to the next handler.
- */
-type ExpressRequestHandler = (req: Omit<Request<Record<string, unknown>>, 'query' | 'headers'> & {
-    query: ParsedQs | Record<string, unknown>;
-    headers: Record<string, unknown>;
-}, res: Response<Record<string, unknown>>, next: MiddlewareNext) => void;
-
-type WebSocketUpgradeContext<SV extends AnySchemaValidator, BaseResponse, Upgrade extends StringOnlyObject<SV>> = Omit<BaseResponse, 'upgrade'> & {
-    upgrade: (context: Upgrade extends infer U ? U extends StringOnlyObject<SV> ? Schema<U, SV> : U : never) => void;
-};
-type WebSocketContractDetails<SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, VersionedApi extends VersionSchema<SV, 'middleware'>, BaseRequest, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>, Upgrade extends StringOnlyObject<SV>> = MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth> & {
-    upgrade?: Upgrade;
-};
-type WebSocketTypedHandler<SV extends AnySchemaValidator, Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, BaseRequest, BaseResponse, NextFunction, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>, Upgrade extends StringOnlyObject<SV>> = Omit<TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, WebSocketUpgradeContext<SV, BaseResponse, Upgrade>, NextFunction, Auth>, 'contractDetails' | 'handlers'> & {
-    contractDetails: WebSocketContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth, Upgrade>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, WebSocketUpgradeContext<SV, BaseResponse, Upgrade>, NextFunction>[];
-};
-interface TypedWebSocketMiddlewareDefinition<ChainableRouter, SV extends AnySchemaValidator, Session extends SessionObject<SV>, BaseRequest, BaseResponse, NextFunction, RouterHandler> {
-    <Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, SessionSchema extends SessionObject<SV>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>, Upgrade extends StringOnlyObject<SV>>(path: Path, contractDetails: WebSocketContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth, Upgrade>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, WebSocketUpgradeContext<SV, BaseResponse, Upgrade>, NextFunction>, ...middlewares: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, SessionSchema, BaseRequest, WebSocketUpgradeContext<SV, BaseResponse, Upgrade>, NextFunction>[]): ChainableRouter;
-    <Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>, Upgrade extends StringOnlyObject<SV>>(contractDetails: WebSocketContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth, Upgrade>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, WebSocketUpgradeContext<SV, BaseResponse, Upgrade>, NextFunction>, ...middlewares: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, WebSocketUpgradeContext<SV, BaseResponse, Upgrade>, NextFunction>[]): ChainableRouter;
-    (middleware: RouterHandler, ...otherMiddleware: RouterHandler[]): ChainableRouter;
-    <Name extends string, Path extends `/${string}`, SuppliedPath extends Path, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>, Upgrade extends StringOnlyObject<SV>>(path: PathMatch<SuppliedPath, Path>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, WebSocketUpgradeContext<SV, BaseResponse, Upgrade>, NextFunction>, ...middlewareAndTypedHandler: [
-        ...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, Omit<BaseResponse, 'upgrade'> & {
-            upgrade: (context: Schema<Upgrade, SV>) => void;
-        }, NextFunction>[],
-        WebSocketTypedHandler<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, Omit<BaseResponse, 'upgrade'> & {
-            upgrade: (context: Schema<Upgrade, SV>) => void;
-        }, NextFunction, Auth, Upgrade>
-    ]): ChainableRouter;
-    <Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>, Upgrade extends StringOnlyObject<SV>>(middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, Omit<BaseResponse, 'upgrade'> & {
-        upgrade: (context: Schema<Upgrade, SV>) => void;
-    }, NextFunction>, ...middlewareAndTypedHandler: [
-        ...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, Omit<BaseResponse, 'upgrade'> & {
-            upgrade: (context: Schema<Upgrade, SV>) => void;
-        }, NextFunction>[],
-        WebSocketTypedHandler<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, Omit<BaseResponse, 'upgrade'> & {
-            upgrade: (context: Schema<Upgrade, SV>) => void;
-        }, NextFunction, Auth, Upgrade>
-    ]): ChainableRouter;
-    <Name extends string, Path extends `/${string}`, SuppliedPath extends Path, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>, Upgrade extends StringOnlyObject<SV>>(path: PathMatch<SuppliedPath, Path>, typedHandler: WebSocketTypedHandler<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, Omit<BaseResponse, 'upgrade'> & {
-        upgrade: (context: Schema<Upgrade, SV>) => void;
-    }, NextFunction, Auth, Upgrade>): ChainableRouter;
-    <Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>, Upgrade extends StringOnlyObject<SV>>(typedHandler: WebSocketTypedHandler<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, Omit<BaseResponse, 'upgrade'> & {
-        upgrade: (context: Schema<Upgrade, SV>) => void;
-    }, NextFunction, Auth, Upgrade>): ChainableRouter;
-}
-
-declare class Router<SV extends AnySchemaValidator, BasePath extends `/${string}`, RouterSession extends SessionObject<SV>> extends ForklaunchExpressLikeRouter<SV, BasePath, MiddlewareHandler, Router$1, Request<Record<string, unknown>>, Response<Record<string, unknown>>, MiddlewareNext, RouterSession> implements ForklaunchRouter<SV> {
-    basePath: BasePath;
-    private configOptions;
-    constructor(basePath: BasePath, schemaValidator: SV, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, options?: ExpressRouterOptions<SV, RouterSession>);
-    route(path: string): this;
-    any: TypedMiddlewareDefinition<this, SV, RouterSession, Request<Record<string, unknown>>, Response<Record<string, unknown>>, MiddlewareNext, ExpressRequestHandler>;
-    upgrade: TypedWebSocketMiddlewareDefinition<this, SV, RouterSession, Request<Record<string, unknown>>, Response<Record<string, unknown>>, MiddlewareNext, ExpressRequestHandler>;
-    ws(pattern: string, eventSchemas: EventSchema<SV>, options?: WSRouteOptions, handler?: WSRouteHandler<(typeof eventSchemas)['userData']>): void;
-    clone(): this;
-}
-
-type App<SV extends AnySchemaValidator, SessionSchema extends SessionObject<SV>> = Application<SV, SessionSchema>;
+import { ContractDetailsOrMiddlewareOrTypedHandler, HeadersObject, Body as HttpBody, Method, MetricsDefinition, MiddlewareOrMiddlewareWithTypedHandler, OpenTelemetryCollector, ParamsObject, QueryObject, ResponsesObject, SchemaAuthMethods, SessionObject, VersionSchema } from '@forklaunch/core/http';
+import { MiddlewareHandler } from '@forklaunch/hyper-express-fork';
+import { AnySchemaValidator } from '@forklaunch/validator';
+import { any } from './src/handlers/any';
+import { delete_ } from './src/handlers/delete';
+import { get } from './src/handlers/get';
+import { head } from './src/handlers/head';
+import { middleware } from './src/handlers/middleware';
+import { options } from './src/handlers/options';
+import { patch } from './src/handlers/patch';
+import { post } from './src/handlers/post';
+import { put } from './src/handlers/put';
+import { trace } from './src/handlers/trace';
+import { Application } from './src/hyperExpressApplication';
+import { Router } from './src/hyperExpressRouter';
+import { ExpressApplicationOptions, ExpressRouterOptions } from './src/types/hyperExpressOptions.types';
+export type App<SV extends AnySchemaValidator, SessionSchema extends SessionObject<SV>> = Application<SV, SessionSchema>;
 /**
  * Creates a new instance of Application with the given schema validator.
  *
@@ -862,7 +22,7 @@ type App<SV extends AnySchemaValidator, SessionSchema extends SessionObject<SV>>
  * @param {SV} schemaValidator - The schema validator.
  * @returns {Application<SV>} - The new application instance.
  */
-declare function forklaunchExpress<SV extends AnySchemaValidator, SessionSchema extends SessionObject<SV>>(schemaValidator: SV, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, options?: ExpressApplicationOptions<SV, SessionSchema>): Application<SV, SessionSchema>;
+export declare function forklaunchExpress<SV extends AnySchemaValidator, SessionSchema extends SessionObject<SV>>(schemaValidator: SV, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, options?: ExpressApplicationOptions<SV, SessionSchema>): Application<SV, SessionSchema>;
 /**
  * Creates a new instance of Router with the given base path and schema validator.
  *
@@ -871,9 +31,14 @@ declare function forklaunchExpress<SV extends AnySchemaValidator, SessionSchema
  * @param {SV} schemaValidator - The schema validator.
  * @returns {Router<SV>} - The new router instance.
  */
-declare function forklaunchRouter<SV extends AnySchemaValidator, BasePath extends `/${string}`, SessionSchema extends SessionObject<SV>>(basePath: BasePath, schemaValidator: SV, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, options?: ExpressRouterOptions<SV, SessionSchema>): Router<SV, BasePath, SessionSchema>;
-
-declare const handlers: {
+export declare function forklaunchRouter<SV extends AnySchemaValidator, BasePath extends `/${string}`, SessionSchema extends SessionObject<SV>>(basePath: BasePath, schemaValidator: SV, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, options?: ExpressRouterOptions<SV, SessionSchema>): Router<SV, BasePath, SessionSchema>;
+export type { MiddlewareNext as NextFunction, Request, Response, ServerConstructorOptions } from '@forklaunch/hyper-express-fork';
+export type { BusboyConfig } from 'busboy';
+export type { CorsOptions } from 'cors';
+export type { Application } from './src/hyperExpressApplication';
+export type { Router } from './src/hyperExpressRouter';
+export type { ExpressApplicationOptions, ExpressRouterOptions } from './src/types/hyperExpressOptions.types';
+export declare const handlers: {
     any: typeof any;
     delete: typeof delete_;
     get: typeof get;
@@ -885,12 +50,11 @@ declare const handlers: {
     put: typeof put;
     trace: typeof trace;
 };
-declare const port: <SV extends AnySchemaValidator, Name extends string, ContractMethod extends Method, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, ContractMethod>, RouterSession extends SessionObject<SV>, BaseRequest, BaseResponse, NextFunction, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>, RouterHandler>(options: {
+export declare const port: <SV extends AnySchemaValidator, Name extends string, ContractMethod extends Method, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends HttpBody<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, ContractMethod>, RouterSession extends SessionObject<SV>, BaseRequest, BaseResponse, NextFunction, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>, RouterHandler>(options: {
     method: ContractMethod;
     path: Path;
     basePath: string;
     schemaValidator: SV;
     openTelemetryCollector?: OpenTelemetryCollector<MetricsDefinition>;
 }, contractDetailsOrMiddlewareOrTypedHandler: ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, RouterSession, Auth>, ...middlewareOrMiddlewareAndTypedHandler: MiddlewareOrMiddlewareWithTypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, RouterSession, Auth>[]) => MiddlewareHandler[];
-
-export { type App, Application, type ExpressApplicationOptions, type ExpressRouterOptions, Router, forklaunchExpress, forklaunchRouter, handlers, port };
+//# sourceMappingURL=index.d.ts.map