@forklaunch/express 1.2.32 → 1.2.33

package/lib/index.d.mts

@@ -1,2112 +0,0 @@
-import * as _forklaunch_core_http from '@forklaunch/core/http';
-import { SessionObject, ExpressLikeApplicationOptions, ExpressLikeRouterOptions, ForklaunchExpressLikeApplication, OpenTelemetryCollector, MetricsDefinition, ParsedQs, ForklaunchExpressLikeRouter, TypedMiddlewareDefinition, ParamsObject, ResponsesObject, Body, QueryObject, HeadersObject, VersionSchema, SchemaAuthMethods, ContractDetails, ExpressLikeSchemaHandler, ResolvedSessionObject, Method, ContractDetailsOrMiddlewareOrTypedHandler, MiddlewareOrMiddlewareWithTypedHandler } from '@forklaunch/core/http';
-export { DocsConfiguration, ParsedQs } from '@forklaunch/core/http';
-import { AnySchemaValidator, LiteralSchema, IdiomaticSchema, SchemaResolve } from '@forklaunch/validator';
-import { Express, RequestHandler, Request, Response, NextFunction, Router as Router$1 } from 'express';
-export { NextFunction, Request, Response } from 'express';
-import { Server, IncomingHttpHeaders } from 'http';
-import { OptionsText, OptionsJson, OptionsUrlencoded } from 'body-parser';
-export { OptionsJson, OptionsText, OptionsUrlencoded } from 'body-parser';
-import { BusboyConfig } from 'busboy';
-export { BusboyConfig } from 'busboy';
-import express__default, { NextFunction as NextFunction$1, RequestHandler as RequestHandler$1 } from 'express-serve-static-core';
-export * from 'express-serve-static-core';
-import { ParsedQs as ParsedQs$1 } from 'qs';
-export { CorsOptions } from 'cors';
-
-type ExpressApplicationOptions<SV extends AnySchemaValidator, SessionSchema extends SessionObject<SV>> = ExpressLikeApplicationOptions<SV, SessionSchema> & {
-    busboy?: BusboyConfig;
-    text?: OptionsText;
-    json?: OptionsJson;
-    urlencoded?: OptionsUrlencoded;
-};
-type ExpressRouterOptions<SV extends AnySchemaValidator, SessionSchema extends SessionObject<SV>> = ExpressLikeRouterOptions<SV, SessionSchema> & {
-    busboy?: BusboyConfig;
-    text?: OptionsText;
-    json?: OptionsJson;
-    urlencoded?: OptionsUrlencoded;
-};
-
-/**
- * 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 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, SessionSchema extends SessionObject<SV>> extends ForklaunchExpressLikeApplication<SV, Express, RequestHandler, Request, Response, NextFunction, SessionSchema> {
-    private docsConfiguration;
-    private mcpConfiguration;
-    private openapiConfiguration;
-    private hostingConfiguration;
-    /**
-     * Creates an instance of Application.
-     *
-     * @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>, options?: ExpressApplicationOptions<SV, SessionSchema>);
-    /**
-     * 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.
-     *
-     * @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;
-    listen(port: number, callback?: () => void): Server;
-    listen(callback?: () => void): Server;
-    listen(path: string, callback?: () => void): Server;
-    listen(handle: unknown, listeningListener?: () => void): Server;
-}
-
-/**
- * Express-compatible request handler type for Forklaunch.
- *
- * @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 next middleware function in the Express stack.
- *
- * @example
- * const handler: ExpressRequestHandler = (req, res, next) => {
- *   // Access normalized query and headers
- *   const userId = req.query.userId;
- *   const customHeader = req.headers['x-custom-header'];
- *   res.json({ userId, customHeader });
- * };
- */
-type ExpressRequestHandler = (req: Omit<Request, 'query' | 'headers'> & {
-    query: ParsedQs | Record<string, unknown>;
-    headers: IncomingHttpHeaders | Record<string, unknown>;
-}, res: Response, next: NextFunction$1) => void;
-
-/**
- * Router class that sets up routes and middleware for an Express router.
- *
- * @template SV - A type that extends AnySchemaValidator.
- * @implements {ForklaunchRouter<SV>}
- */
-declare class Router<SV extends AnySchemaValidator, BasePath extends `/${string}`, RouterSession extends SessionObject<SV>> extends ForklaunchExpressLikeRouter<SV, BasePath, RequestHandler$1, Router$1, Request, Response, NextFunction, RouterSession> {
-    basePath: BasePath;
-    private configOptions;
-    /**
-     * Creates an instance of Router.
-     *
-     * @param {string} basePath - The base path for the router.
-     * @param {SV} schemaValidator - The schema validator.
-     */
-    constructor(basePath: BasePath, schemaValidator: SV, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, options?: ExpressRouterOptions<SV, RouterSession>);
-    route(path: string): this;
-    param<ParamName extends string, Types extends {
-        req?: LiteralSchema | SV['_SchemaCatchall'];
-        res?: IdiomaticSchema<SV>;
-    } & {
-        [K in ParamName]: IdiomaticSchema<SV>;
-    }>(name: ParamName, _types: Types, handler: (req: SchemaResolve<Types['req']>, res: SchemaResolve<Types['res']>, next: NextFunction, value: SchemaResolve<Types[ParamName]>, name: ParamName) => void): this;
-    checkout: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    copy: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    lock: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    merge: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    mkcactivity: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    mkcol: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    move: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    'm-search': TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    notify: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    propfind: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    proppatch: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    purge: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    report: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    search: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    subscribe: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    unlock: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    unsubscribe: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    link: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    unlink: TypedMiddlewareDefinition<this, SV, RouterSession, Request, Response, NextFunction, ExpressRequestHandler>;
-    clone(): this;
-}
-
-/**
- * Creates a checkout route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Name - The name of the route
- * @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', Name, 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication method type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route path type
- * @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
- * @template Auth - The authentication methods type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'delete', Name, Path, P, ResBodyMap, never, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "delete", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "delete", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Response<any, Record<string, any>>, NextFunction, Auth>;
-
-/**
- * Creates a GET route handler with schema validation and type safety.
- *
- * @template SV - Schema validator type extending AnySchemaValidator
- * @template Name - The name of the route
- * @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>
- * @template Auth - Auth methods type extending AuthMethodsBase
- *
- * @param {SV} schemaValidator - Schema validator instance
- * @param {Path} path - Route path starting with '/'
- * @param {ContractDetails<SV, 'get', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "get", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "get", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Response<any, Record<string, any>>, NextFunction, Auth>;
-
-/**
- * Creates a HEAD route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Name - The name of the route
- * @template Path - The route path type
- * @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
- * @template Auth - The authentication method type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'head', Name, Path, P, ResBodyMap, never, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "head", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "head", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Response<any, Record<string, any>>, NextFunction, Auth>;
-
-/**
- * Creates a LINK route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication methods base type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication method type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication methods base type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication methods base type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication methods type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Name} name - The name of the route
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication methods base type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication methods base type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication methods base type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication method type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication methods base type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'options', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "options", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "options", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Response<any, Record<string, any>>, NextFunction, Auth>;
-
-/**
- * Creates a PATCH route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Name - The name of the route
- * @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
- * @template Auth - The authentication methods base type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'patch', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "patch", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "patch", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Response<any, Record<string, any>>, NextFunction, Auth>;
-
-/**
- * Creates a POST route handler with schema validation and type safety.
- *
- * @template SV - Schema validator type extending AnySchemaValidator
- * @template Name - The name of the route
- * @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>
- * @template Auth - Auth methods type extending AuthMethodsBase
- *
- * @param {SV} schemaValidator - Schema validator instance
- * @param {Path} path - Route path starting with '/'
- * @param {ContractDetails<SV, 'post', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "post", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "post", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Response<any, Record<string, any>>, NextFunction, Auth>;
-
-/**
- * Creates a PROPFIND route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication methods base type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'propfind', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication methods base type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route path type
- * @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', Name, 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication method type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'put', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "put", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "put", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Response<any, Record<string, any>>, NextFunction, Auth>;
-
-/**
- * Creates a REPORT route handler with schema validation and type safety.
- *
- * @template SV - The schema validator type
- * @template Name - The name of the route
- * @template Path - The route 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 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, 'report', Name, 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @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
- * @template Auth - The authentication methods type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication method 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, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication method type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'trace', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "trace", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => _forklaunch_core_http.ExpressLikeTypedHandler<SV, Name, "trace", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Response<any, Record<string, any>>, NextFunction, Auth>;
-
-/**
- * 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
- * @template Auth - The authentication method 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, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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
- * @template Auth - The authentication method 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, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, 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 Name - The name of the route
- * @template Path - The route 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 parameters type
- * @template ReqHeaders - The request headers type
- * @template ResHeaders - The response headers type
- * @template LocalsObj - The locals object type
- * @template Auth - The authentication methods base type
- *
- * @param {SV} schemaValidator - The schema validator instance
- * @param {Path} path - The route path
- * @param {ContractDetails<SV, 'middleware', Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Request, Auth>} contractDetails - The contract details for the route
- * @param {...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, Request, Auth>} 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, 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>>(schemaValidator: SV, path: Path, contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request, Response, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: _forklaunch_core_http.MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, Request<express__default.ParamsDictionary, any, any, ParsedQs$1, Record<string, any>>, Response<any, Record<string, any>>, NextFunction>[];
-};
-
-/**
- * Creates a new instance of Application with the given schema validator.
- *
- * @template SV - A type that extends AnySchemaValidator.
- * @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>;
-/**
- * Creates a new instance of Router with the given base path and schema validator.
- *
- * @template SV - A type that extends AnySchemaValidator.
- * @param {string} basePath - The base path for the router.
- * @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: {
-    checkout: typeof checkout;
-    copy: typeof copy;
-    delete: typeof delete_;
-    get: typeof get;
-    head: typeof head;
-    link: typeof link;
-    lock: typeof lock;
-    mSearch: typeof mSearch;
-    merge: typeof merge;
-    middleware: typeof middleware;
-    mkcActivity: typeof mkcActivity;
-    mkcol: typeof mkcol;
-    move: typeof move;
-    notify: typeof notify;
-    options: typeof options;
-    patch: typeof patch;
-    post: typeof post;
-    propfind: typeof propfind;
-    proppatch: typeof proppatch;
-    purge: typeof purge;
-    put: typeof put;
-    report: typeof report;
-    search: typeof search;
-    subscribe: typeof subscribe;
-    trace: typeof trace;
-    unlink: typeof unlink;
-    unlock: typeof unlock;
-    unsubscribe: typeof unsubscribe;
-};
-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: {
-    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>[]) => RequestHandler[];
-
-export { Application, type ExpressApplicationOptions, type ExpressRouterOptions, Router, forklaunchExpress, forklaunchRouter, handlers, port };