@forklaunch/express 0.4.6 → 0.4.8

package/lib/index.d.mts

@@ -10,22 +10,46 @@ import * as express_serve_static_core from 'express-serve-static-core';
 
 /**
  * Application class that sets up an Express server with Forklaunch routers and middleware.
+ * This class extends ForklaunchExpressLikeApplication to provide Express-specific functionality.
  *
- * @template SV - A type that extends AnySchemaValidator.
+ * @template SV - A type that extends AnySchemaValidator for schema validation.
+ * @example
+ * ```typescript
+ * const app = new Application(schemaValidator, openTelemetryCollector);
+ * app.listen(3000, () => console.log('Server running on port 3000'));
+ * ```
  */
 declare class Application<SV extends AnySchemaValidator> extends ForklaunchExpressLikeApplication<SV, Express, RequestHandler, Request, Response, NextFunction> {
     private readonly docsConfiguration?;
     /**
      * Creates an instance of Application.
      *
-     * @param {SV} schemaValidator - The schema validator.
+     * @param {SV} schemaValidator - The schema validator for request/response validation.
+     * @param {OpenTelemetryCollector<MetricsDefinition>} openTelemetryCollector - Collector for OpenTelemetry metrics.
+     * @param {DocsConfiguration} [docsConfiguration] - Optional configuration for API documentation (Swagger/Scalar).
      */
     constructor(schemaValidator: SV, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, docsConfiguration?: DocsConfiguration | undefined);
     /**
-     * Starts the server and sets up Swagger documentation.
+     * Starts the Express server and sets up API documentation (Swagger/Scalar).
+     * This method is overloaded to support various ways of starting the server.
+     *
+     * @param {number} [port] - The port number to listen on. Defaults to process.env.PORT.
+     * @param {string} [hostname] - The hostname to bind to.
+     * @param {number} [backlog] - The maximum length of the queue of pending connections.
+     * @param {() => void} [callback] - Optional callback to execute when the server starts listening.
+     * @returns {Server} - The HTTP server instance.
      *
-     * @param {...unknown[]} args - The arguments to pass to the listen method.
-     * @returns {Server} - The HTTP server.
+     * @example
+     * ```typescript
+     * // Start server on port 3000
+     * app.listen(3000);
+     *
+     * // Start server with callback
+     * app.listen(3000, () => console.log('Server started'));
+     *
+     * // Start server with hostname and port
+     * app.listen(3000, 'localhost');
+     * ```
      */
     listen(port: number, hostname: string, backlog: number, callback?: () => void): Server;
     listen(port: number, hostname: string, callback?: () => void): Server;
@@ -78,6 +102,33 @@ declare class Router<SV extends AnySchemaValidator, BasePath extends `/${string}
     unlink: TypedMiddlewareDefinition<this, SV, Request, Response, NextFunction>;
 }
 
+/**
+ * Creates a checkout route handler with schema validation and type safety.
+ *
+ * @template SV - The schema validator type
+ * @template Path - The path type
+ * @template P - The path parameters type
+ * @template ResBodyMap - The response body map type
+ * @template ReqBody - The request body type
+ * @template ReqQuery - The request query 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 path of the route
+ * @param {ContractDetails<SV, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The handlers for the route
+ *
+ * @example
+ * ```typescript
+ * const checkout = checkout(
+ *   schemaValidator,
+ *   '/checkout',
+ *   contractDetails,
+ *   handler);
+ * ```
+ */
 declare const checkout: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -85,6 +136,81 @@ declare const checkout: <SV extends AnySchemaValidator, Path extends `/${string}
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a COPY 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, 'copy', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * copy(
+ *   schemaValidator,
+ *   '/files/:id',
+ *   {
+ *     summary: 'Copy file',
+ *     description: 'Creates a copy of a file at a new location',
+ *     tags: ['files'],
+ *     parameters: [
+ *       {
+ *         name: 'id',
+ *         in: 'path',
+ *         required: true,
+ *         schema: { type: 'string' }
+ *       }
+ *     ],
+ *     requestBody: {
+ *       content: {
+ *         'application/json': {
+ *           schema: {
+ *             type: 'object',
+ *             properties: {
+ *               destination: { type: 'string' }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     },
+ *     responses: {
+ *       201: {
+ *         description: 'File copied successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 id: { type: 'string' },
+ *                 location: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     const { destination } = req.body;
+ *     const result = await copyFile(id, destination);
+ *     res.status(201).json(result);
+ *   }
+ * );
+ * ```
+ */
 declare const copy: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -92,12 +218,236 @@ declare const copy: <SV extends AnySchemaValidator, Path extends `/${string}`, P
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * 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 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, never, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, never, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * del(
+ *   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'
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     await deleteUser(id);
+ *     res.status(204).send();
+ *   }
+ * );
+ * ```
+ */
 declare const delete_: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "delete", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, "delete", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>;
 
+/**
+ * Creates a GET route handler with schema validation and type safety.
+ *
+ * @template SV - Schema validator type extending AnySchemaValidator
+ * @template Path - Route path type extending string with leading slash
+ * @template P - Parameters object type extending ParamsObject
+ * @template ResBodyMap - Response body map type extending ResponsesObject
+ * @template ReqBody - Request body type extending Body
+ * @template ReqQuery - Request query type extending QueryObject
+ * @template ReqHeaders - Request headers type extending HeadersObject
+ * @template ResHeaders - Response headers type extending HeadersObject
+ * @template LocalsObj - Local variables type extending Record<string, unknown>
+ *
+ * @param {SV} schemaValidator - Schema validator instance
+ * @param {Path} path - Route path starting with '/'
+ * @param {ContractDetails} contractDetails - Contract details for route validation
+ * @param {...ExpressLikeSchemaHandler[]} handlers - Route handler middleware functions
+ * @returns {Function} Express route handler with schema validation
+ *
+ * @example
+ * ```typescript
+ * const getUser = get(
+ *   schemaValidator,
+ *   '/users/:id',
+ *   {
+ *     params: { id: 'string' },
+ *     responses: {
+ *       200: { type: 'object', properties: { name: { type: 'string' } } }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const user = await getUserById(req.params.id);
+ *     res.json(user);
+ *   }
+ * );
+ * ```
+ */
 declare const get: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "get", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, "get", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>;
 
+/**
+ * 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 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, never, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, never, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * head(
+ *   schemaValidator,
+ *   '/files/:id',
+ *   {
+ *     summary: 'Get file metadata',
+ *     description: 'Returns metadata about a file without the file content',
+ *     tags: ['files'],
+ *     parameters: [
+ *       {
+ *         name: 'id',
+ *         in: 'path',
+ *         required: true,
+ *         schema: { type: 'string' }
+ *       }
+ *     ],
+ *     responses: {
+ *       200: {
+ *         description: 'File metadata',
+ *         headers: {
+ *           'Content-Length': {
+ *             schema: { type: 'integer' }
+ *           },
+ *           'Content-Type': {
+ *             schema: { type: 'string' }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     const metadata = await getFileMetadata(id);
+ *     res.set('Content-Length', metadata.size);
+ *     res.set('Content-Type', metadata.type);
+ *     res.status(200).end();
+ *   }
+ * );
+ * ```
+ */
 declare const head: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "head", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, "head", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>;
 
+/**
+ * Creates a LINK 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, 'link', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * link(
+ *   schemaValidator,
+ *   '/resources/:id',
+ *   {
+ *     summary: 'Link resources',
+ *     description: 'Establishes a relationship between two resources',
+ *     tags: ['resources'],
+ *     parameters: [
+ *       {
+ *         name: 'id',
+ *         in: 'path',
+ *         required: true,
+ *         schema: { type: 'string' }
+ *       }
+ *     ],
+ *     requestBody: {
+ *       content: {
+ *         'application/json': {
+ *           schema: {
+ *             type: 'object',
+ *             properties: {
+ *               targetId: { type: 'string' },
+ *               relationshipType: { type: 'string' }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     },
+ *     responses: {
+ *       201: {
+ *         description: 'Resources linked successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 sourceId: { type: 'string' },
+ *                 targetId: { type: 'string' },
+ *                 relationshipType: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     const { targetId, relationshipType } = req.body;
+ *     const result = await linkResources(id, targetId, relationshipType);
+ *     res.status(201).json(result);
+ *   }
+ * );
+ * ```
+ */
 declare const link: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -105,6 +455,82 @@ declare const link: <SV extends AnySchemaValidator, Path extends `/${string}`, P
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a LOCK 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, 'lock', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * lock(
+ *   schemaValidator,
+ *   '/resources/:id',
+ *   {
+ *     summary: 'Lock resource',
+ *     description: 'Locks a resource to prevent concurrent modifications',
+ *     tags: ['resources'],
+ *     parameters: [
+ *       {
+ *         name: 'id',
+ *         in: 'path',
+ *         required: true,
+ *         schema: { type: 'string' }
+ *       }
+ *     ],
+ *     requestBody: {
+ *       content: {
+ *         'application/json': {
+ *           schema: {
+ *             type: 'object',
+ *             properties: {
+ *               timeout: { type: 'integer' },
+ *               owner: { type: 'string' }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     },
+ *     responses: {
+ *       200: {
+ *         description: 'Resource locked successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 lockToken: { type: 'string' },
+ *                 expiresAt: { type: 'string', format: 'date-time' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     const { timeout, owner } = req.body;
+ *     const result = await lockResource(id, timeout, owner);
+ *     res.json(result);
+ *   }
+ * );
+ * ```
+ */
 declare const lock: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -112,6 +538,77 @@ declare const lock: <SV extends AnySchemaValidator, Path extends `/${string}`, P
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a M-SEARCH 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, 'm-search', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * mSearch(
+ *   schemaValidator,
+ *   '/devices',
+ *   {
+ *     summary: 'Search for devices',
+ *     description: 'Multicast search for devices on the network',
+ *     tags: ['devices'],
+ *     requestBody: {
+ *       content: {
+ *         'application/json': {
+ *           schema: {
+ *             type: 'object',
+ *             properties: {
+ *               searchType: { type: 'string' },
+ *               maxWait: { type: 'integer' }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     },
+ *     responses: {
+ *       200: {
+ *         description: 'Devices found',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'array',
+ *               items: {
+ *                 type: 'object',
+ *                 properties: {
+ *                   id: { type: 'string' },
+ *                   type: { type: 'string' },
+ *                   location: { type: 'string' }
+ *                 }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { searchType, maxWait } = req.body;
+ *     const devices = await searchDevices(searchType, maxWait);
+ *     res.json(devices);
+ *   }
+ * );
+ * ```
+ */
 declare const mSearch: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -119,6 +616,93 @@ declare const mSearch: <SV extends AnySchemaValidator, Path extends `/${string}`
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a MERGE 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, 'merge', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * merge(
+ *   schemaValidator,
+ *   '/documents/:id',
+ *   {
+ *     summary: 'Merge document',
+ *     description: 'Merges changes from multiple sources into a document',
+ *     tags: ['documents'],
+ *     parameters: [
+ *       {
+ *         name: 'id',
+ *         in: 'path',
+ *         required: true,
+ *         schema: { type: 'string' }
+ *       }
+ *     ],
+ *     requestBody: {
+ *       content: {
+ *         'application/json': {
+ *           schema: {
+ *             type: 'object',
+ *             properties: {
+ *               changes: {
+ *                 type: 'array',
+ *                 items: {
+ *                   type: 'object',
+ *                   properties: {
+ *                     source: { type: 'string' },
+ *                     content: { type: 'string' }
+ *                   }
+ *                 }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     },
+ *     responses: {
+ *       200: {
+ *         description: 'Document merged successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 id: { type: 'string' },
+ *                 mergedContent: { type: 'string' },
+ *                 conflicts: {
+ *                   type: 'array',
+ *                   items: { type: 'string' }
+ *                 }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     const { changes } = req.body;
+ *     const result = await mergeDocument(id, changes);
+ *     res.json(result);
+ *   }
+ * );
+ */
 declare const merge: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -126,6 +710,58 @@ declare const merge: <SV extends AnySchemaValidator, Path extends `/${string}`,
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a middleware 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, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * middleware(
+ *   schemaValidator,
+ *   '/middleware',
+ *   {
+ *     summary: 'Middleware example',
+ *     description: 'Example middleware route',
+ *     tags: ['middleware'],
+ *     responses: {
+ *       200: {
+ *         description: 'Middleware executed successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 message: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res, next) => {
+ *     // Middleware logic
+ *     next();
+ *   }
+ * );
+ * ```
+ */
 declare const middleware: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -133,6 +769,68 @@ declare const middleware: <SV extends AnySchemaValidator, Path extends `/${strin
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates an MKCACTIVITY 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, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * mkcActivity(
+ *   schemaValidator,
+ *   '/activities',
+ *   {
+ *     summary: 'Create activity',
+ *     description: 'Creates a new activity',
+ *     tags: ['activities'],
+ *     body: {
+ *       type: 'object',
+ *       properties: {
+ *         name: { type: 'string' },
+ *         type: { type: 'string' }
+ *       }
+ *     },
+ *     responses: {
+ *       201: {
+ *         description: 'Activity created successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 id: { type: 'string' },
+ *                 name: { type: 'string' },
+ *                 type: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { name, type } = req.body;
+ *     // Create activity logic
+ *     res.status(201).json({ id: 'act_123', name, type });
+ *   }
+ * );
+ * ```
+ */
 declare const mkcActivity: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -140,6 +838,68 @@ declare const mkcActivity: <SV extends AnySchemaValidator, Path extends `/${stri
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates an MKCOL 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, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * mkcol(
+ *   schemaValidator,
+ *   '/collections',
+ *   {
+ *     summary: 'Create collection',
+ *     description: 'Creates a new collection',
+ *     tags: ['collections'],
+ *     body: {
+ *       type: 'object',
+ *       properties: {
+ *         name: { type: 'string' },
+ *         description: { type: 'string' }
+ *       }
+ *     },
+ *     responses: {
+ *       201: {
+ *         description: 'Collection created successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 id: { type: 'string' },
+ *                 name: { type: 'string' },
+ *                 description: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { name, description } = req.body;
+ *     // Create collection logic
+ *     res.status(201).json({ id: 'col_123', name, description });
+ *   }
+ * );
+ * ```
+ */
 declare const mkcol: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -147,6 +907,70 @@ declare const mkcol: <SV extends AnySchemaValidator, Path extends `/${string}`,
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a MOVE 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, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * move(
+ *   schemaValidator,
+ *   '/resources/:id/move',
+ *   {
+ *     summary: 'Move resource',
+ *     description: 'Moves a resource to a new location',
+ *     tags: ['resources'],
+ *     pathParams: {
+ *       id: { type: 'string' }
+ *     },
+ *     body: {
+ *       type: 'object',
+ *       properties: {
+ *         destination: { type: 'string' }
+ *       }
+ *     },
+ *     responses: {
+ *       200: {
+ *         description: 'Resource moved successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 id: { type: 'string' },
+ *                 location: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     const { destination } = req.body;
+ *     // Move logic
+ *     res.json({ id, location: destination });
+ *   }
+ * );
+ * ```
+ */
 declare const move: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -154,6 +978,67 @@ declare const move: <SV extends AnySchemaValidator, Path extends `/${string}`, P
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a NOTIFY 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, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * notify(
+ *   schemaValidator,
+ *   '/notifications',
+ *   {
+ *     summary: 'Send notification',
+ *     description: 'Sends a notification to subscribers',
+ *     tags: ['notifications'],
+ *     body: {
+ *       type: 'object',
+ *       properties: {
+ *         message: { type: 'string' },
+ *         type: { type: 'string' }
+ *       }
+ *     },
+ *     responses: {
+ *       200: {
+ *         description: 'Notification sent successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 id: { type: 'string' },
+ *                 status: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { message, type } = req.body;
+ *     // Notification logic
+ *     res.json({ id: 'not_123', status: 'sent' });
+ *   }
+ * );
+ * ```
+ */
 declare const notify: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -161,12 +1046,258 @@ declare const notify: <SV extends AnySchemaValidator, Path extends `/${string}`,
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * 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>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * options(
+ *   schemaValidator,
+ *   '/api',
+ *   {
+ *     summary: 'Get API options',
+ *     description: 'Returns the available HTTP methods and other options for the API',
+ *     tags: ['api'],
+ *     responses: {
+ *       200: {
+ *         description: 'Available options',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 methods: {
+ *                   type: 'array',
+ *                   items: { type: 'string' }
+ *                 },
+ *                 cors: { type: 'boolean' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     res.json({
+ *       methods: ['GET', 'POST', 'PUT', 'DELETE'],
+ *       cors: true
+ *     });
+ *   }
+ * );
+ * ```
+ */
 declare const options: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "options", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, "options", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>;
 
+/**
+ * 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>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with 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' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     const updates = req.body;
+ *     const user = await updateUser(id, updates);
+ *     res.json(user);
+ *   }
+ * );
+ * ```
+ */
 declare const patch: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "patch", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, "patch", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>;
 
+/**
+ * Creates a POST route handler with schema validation and type safety.
+ *
+ * @template SV - Schema validator type extending AnySchemaValidator
+ * @template Path - Route path type extending string with leading slash
+ * @template P - Parameters object type extending ParamsObject
+ * @template ResBodyMap - Response body map type extending ResponsesObject
+ * @template ReqBody - Request body type extending Body
+ * @template ReqQuery - Request query type extending QueryObject
+ * @template ReqHeaders - Request headers type extending HeadersObject
+ * @template ResHeaders - Response headers type extending HeadersObject
+ * @template LocalsObj - Local variables type extending Record<string, unknown>
+ *
+ * @param {SV} schemaValidator - Schema validator instance
+ * @param {Path} path - Route path starting with '/'
+ * @param {ContractDetails} contractDetails - Contract details for route validation
+ * @param {...ExpressLikeSchemaHandler[]} handlers - Route handler middleware functions
+ * @returns {Function} Express route handler with schema validation
+ *
+ * @example
+ * ```typescript
+ * const createUser = post(
+ *   schemaValidator,
+ *   '/users',
+ *   {
+ *     body: {
+ *       type: 'object',
+ *       properties: { name: { type: 'string' } },
+ *       required: ['name']
+ *     },
+ *     responses: {
+ *       201: { type: 'object', properties: { id: { type: 'string' } } }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const user = await createNewUser(req.body);
+ *     res.status(201).json(user);
+ *   }
+ * );
+ * ```
+ */
 declare const post: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "post", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, "post", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>;
 
+/**
+ * Creates a PROPFIND 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, 'propfind', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * propfind(
+ *   schemaValidator,
+ *   '/resources/:id',
+ *   {
+ *     summary: 'Get resource properties',
+ *     description: 'Retrieves properties of a resource',
+ *     tags: ['resources'],
+ *     parameters: [
+ *       {
+ *         name: 'id',
+ *         in: 'path',
+ *         required: true,
+ *         schema: { type: 'string' }
+ *       }
+ *     ],
+ *     requestBody: {
+ *       content: {
+ *         'application/xml': {
+ *           schema: {
+ *             type: 'string',
+ *             description: 'XML request body with property names to retrieve'
+ *           }
+ *         }
+ *       }
+ *     },
+ *     responses: {
+ *       207: {
+ *         description: 'Multi-status response with property values',
+ *         content: {
+ *           'application/xml': {
+ *             schema: {
+ *               type: 'string',
+ *               description: 'XML response with property values'
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     const xmlRequest = req.body;
+ *     const properties = await getResourceProperties(id, xmlRequest);
+ *     res.status(207).type('application/xml').send(properties);
+ *   }
+ * );
+ * ```
+ */
 declare const propfind: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -174,6 +1305,76 @@ declare const propfind: <SV extends AnySchemaValidator, Path extends `/${string}
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a PROPPATCH 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, 'proppatch', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * proppatch(
+ *   schemaValidator,
+ *   '/resources/:id',
+ *   {
+ *     summary: 'Update resource properties',
+ *     description: 'Updates properties of a resource',
+ *     tags: ['resources'],
+ *     parameters: [
+ *       {
+ *         name: 'id',
+ *         in: 'path',
+ *         required: true,
+ *         schema: { type: 'string' }
+ *       }
+ *     ],
+ *     requestBody: {
+ *       content: {
+ *         'application/xml': {
+ *           schema: {
+ *             type: 'string',
+ *             description: 'XML request body with property updates'
+ *           }
+ *         }
+ *       }
+ *     },
+ *     responses: {
+ *       207: {
+ *         description: 'Multi-status response with property update results',
+ *         content: {
+ *           'application/xml': {
+ *             schema: {
+ *               type: 'string',
+ *               description: 'XML response with property update status'
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     const xmlRequest = req.body;
+ *     const result = await updateResourceProperties(id, xmlRequest);
+ *     res.status(207).type('application/xml').send(result);
+ *   }
+ * );
+ * ```
+ */
 declare const proppatch: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -181,6 +1382,56 @@ declare const proppatch: <SV extends AnySchemaValidator, Path extends `/${string
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a PURGE 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 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, 'purge', Path, P, ResBodyMap, never, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, never, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * purge(
+ *   schemaValidator,
+ *   '/cache/:id',
+ *   {
+ *     summary: 'Purge cache',
+ *     description: 'Removes an item from the cache',
+ *     tags: ['cache'],
+ *     parameters: [
+ *       {
+ *         name: 'id',
+ *         in: 'path',
+ *         required: true,
+ *         schema: { type: 'string' }
+ *       }
+ *     ],
+ *     responses: {
+ *       204: {
+ *         description: 'Cache item purged successfully'
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     await purgeCacheItem(id);
+ *     res.status(204).send();
+ *   }
+ * );
+ * ```
+ */
 declare const purge: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -188,8 +1439,129 @@ declare const purge: <SV extends AnySchemaValidator, Path extends `/${string}`,
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a PUT 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, 'put', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "put", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, "put", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>;
 
+/**
+ * Creates a REPORT 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, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * report(
+ *   schemaValidator,
+ *   '/reports/:id',
+ *   {
+ *     summary: 'Generate report',
+ *     description: 'Generates a report for the specified resource',
+ *     tags: ['reports'],
+ *     pathParams: {
+ *       id: { type: 'string' }
+ *     },
+ *     responses: {
+ *       200: {
+ *         description: 'Report generated successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 id: { type: 'string' },
+ *                 status: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     // Generate report logic
+ *     res.json({ id, status: 'completed' });
+ *   }
+ * );
+ * ```
+ */
 declare const report: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -197,6 +1569,75 @@ declare const report: <SV extends AnySchemaValidator, Path extends `/${string}`,
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a SEARCH 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, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * search(
+ *   schemaValidator,
+ *   '/search',
+ *   {
+ *     summary: 'Search resources',
+ *     description: 'Searches for resources based on query parameters',
+ *     tags: ['search'],
+ *     query: {
+ *       type: 'object',
+ *       properties: {
+ *         q: { type: 'string' },
+ *         limit: { type: 'number' }
+ *       }
+ *     },
+ *     responses: {
+ *       200: {
+ *         description: 'Search results',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 results: {
+ *                   type: 'array',
+ *                   items: {
+ *                     type: 'object',
+ *                     properties: {
+ *                       id: { type: 'string' },
+ *                       title: { type: 'string' }
+ *                     }
+ *                   }
+ *                 }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { q, limit } = req.query;
+ *     // Search logic
+ *     res.json({ results: [] });
+ *   }
+ * );
+ * ```
+ */
 declare const search: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -204,6 +1645,67 @@ declare const search: <SV extends AnySchemaValidator, Path extends `/${string}`,
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates a SUBSCRIBE 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, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * subscribe(
+ *   schemaValidator,
+ *   '/subscribe',
+ *   {
+ *     summary: 'Subscribe to updates',
+ *     description: 'Subscribes to receive updates for a resource',
+ *     tags: ['subscriptions'],
+ *     body: {
+ *       type: 'object',
+ *       properties: {
+ *         email: { type: 'string' },
+ *         resourceId: { type: 'string' }
+ *       }
+ *     },
+ *     responses: {
+ *       200: {
+ *         description: 'Subscription created successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 id: { type: 'string' },
+ *                 status: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { email, resourceId } = req.body;
+ *     // Subscription logic
+ *     res.json({ id: 'sub_123', status: 'active' });
+ *   }
+ * );
+ * ```
+ */
 declare const subscribe: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -211,8 +1713,115 @@ declare const subscribe: <SV extends AnySchemaValidator, Path extends `/${string
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * 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>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * trace(
+ *   schemaValidator,
+ *   '/trace',
+ *   {
+ *     summary: 'Trace request',
+ *     description: 'Traces the request path and returns diagnostic information',
+ *     tags: ['diagnostics'],
+ *     responses: {
+ *       200: {
+ *         description: 'Trace information',
+ *         content: {
+ *           'message/http': {
+ *             schema: {
+ *               type: 'string'
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     // Trace logic
+ *     res.set('Content-Type', 'message/http');
+ *     res.send('TRACE /trace HTTP/1.1');
+ *   }
+ * );
+ * ```
+ */
 declare const trace: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "trace", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, "trace", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>;
 
+/**
+ * Creates an UNLINK 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, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * unlink(
+ *   schemaValidator,
+ *   '/resources/:id/link',
+ *   {
+ *     summary: 'Unlink resource',
+ *     description: 'Removes a link between two resources',
+ *     tags: ['resources'],
+ *     pathParams: {
+ *       id: { type: 'string' }
+ *     },
+ *     responses: {
+ *       200: {
+ *         description: 'Resource unlinked successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 id: { type: 'string' },
+ *                 status: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     // Unlink logic
+ *     res.json({ id, status: 'unlinked' });
+ *   }
+ * );
+ * ```
+ */
 declare const unlink: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -220,6 +1829,63 @@ declare const unlink: <SV extends AnySchemaValidator, Path extends `/${string}`,
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates an UNLOCK 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, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * unlock(
+ *   schemaValidator,
+ *   '/resources/:id/lock',
+ *   {
+ *     summary: 'Unlock resource',
+ *     description: 'Removes a lock from a resource',
+ *     tags: ['resources'],
+ *     pathParams: {
+ *       id: { type: 'string' }
+ *     },
+ *     responses: {
+ *       200: {
+ *         description: 'Resource unlocked successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 id: { type: 'string' },
+ *                 status: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     // Unlock logic
+ *     res.json({ id, status: 'unlocked' });
+ *   }
+ * );
+ * ```
+ */
 declare const unlock: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
@@ -227,6 +1893,63 @@ declare const unlock: <SV extends AnySchemaValidator, Path extends `/${string}`,
     handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
 };
 
+/**
+ * Creates an UNSUBSCRIBE 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, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>} contractDetails - The contract details for the route
+ * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]} handlers - The route handlers
+ *
+ * @returns {void} - Returns nothing, registers the route with Express
+ *
+ * @example
+ * ```typescript
+ * unsubscribe(
+ *   schemaValidator,
+ *   '/subscriptions/:id',
+ *   {
+ *     summary: 'Unsubscribe from updates',
+ *     description: 'Removes a subscription to resource updates',
+ *     tags: ['subscriptions'],
+ *     pathParams: {
+ *       id: { type: 'string' }
+ *     },
+ *     responses: {
+ *       200: {
+ *         description: 'Subscription removed successfully',
+ *         content: {
+ *           'application/json': {
+ *             schema: {
+ *               type: 'object',
+ *               properties: {
+ *                 id: { type: 'string' },
+ *                 status: { type: 'string' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   async (req, res) => {
+ *     const { id } = req.params;
+ *     // Unsubscribe logic
+ *     res.json({ id, status: 'unsubscribed' });
+ *   }
+ * );
+ * ```
+ */
 declare const unsubscribe: <SV extends AnySchemaValidator, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Response, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;