@forklaunch/core 1.5.1 → 1.5.3

package/lib/http/index.d.ts

@@ -1,1244 +1,47 @@
-import { ParsedQs } from 'qs';
-export { ParsedQs } from 'qs';
-import { Prettify, SanitizePathSlashes, PrettyCamelCase, TypeSafeFunction, UnionToIntersection, EmptyObject } from '@forklaunch/common';
-import { AnySchemaValidator } from '@forklaunch/validator';
-import { ServerOptions, IncomingMessage, ServerResponse } from 'node:http';
-import { O as OpenTelemetryCollector, M as MetricsDefinition, T as TelemetryOptions } from '../openTelemetryCollector-BS-ej09T.js';
-export { L as LogFn, a as LoggerMeta, b as MetricType, P as PinoLogger, h as httpRequestsTotalCounter, c as httpServerDurationHistogram, l as logger, m as meta } from '../openTelemetryCollector-BS-ej09T.js';
-import { M as Method, P as PathParamHttpContractDetails, H as HttpContractDetails, E as ExpressLikeRouterOptions, a as SessionObject, b as ParamsObject, R as ResponsesObject, B as Body, Q as QueryObject, c as HeadersObject, V as VersionSchema, d as SchemaAuthMethods, e as ExpressLikeSchemaHandler, f as ResolvedSessionObject, C as ContractDetails, g as PathMatch, L as LiveTypeFunction, h as LiveSdkFunction, A as AuthMethodsBase, i as ExpressLikeApplicationOptions, j as ParamsDictionary, k as VersionedRequests, l as AuthMethods, D as DecodeResource, m as BasicAuthMethods, F as ForklaunchRequest, n as MiddlewareContractDetails, o as ExpressLikeSchemaAuthMapper, p as ForklaunchNextFunction, q as ForklaunchResponse, r as ForklaunchResHeaders, s as ForklaunchStatusResponse, t as ForklaunchSendableData } from '../apiDefinition.types-DW4lfZqy.js';
-export { u as AccessLevel, v as BodyObject, w as DefaultSubscriptionData, x as DocsConfiguration, y as ErrorContainer, z as ExpressLikeAuthMapper, G as ExpressLikeGlobalAuthOptions, I as ExpressLikeHandler, J as ExpressLikeSchemaGlobalAuthOptions, K as ExtractBody, N as ExtractContentType, O as ExtractResponseBody, T as ExtractedParamsObject, U as FileBody, W as ForklaunchBaseRequest, X as ForklaunchResErrors, Y as HmacMethods, Z as HttpMethod, _ as JsonBody, $ as JwtAuthMethods, a0 as LiveTypeFunctionRequestInit, a1 as MapParamsSchema, a2 as MapReqBodySchema, a3 as MapReqHeadersSchema, a4 as MapReqQuerySchema, a5 as MapResBodyMapSchema, a6 as MapResHeadersSchema, a7 as MapSchema, a8 as MapSessionSchema, a9 as MapVersionedReqsSchema, aa as MapVersionedRespsSchema, ab as MultipartForm, ac as NumberOnlyObject, ad as PathParamMethod, ae as PermissionSet, af as RawTypedResponseBody, ag as RequestContext, ah as ResolvedForklaunchAuthRequest, ai as ResolvedForklaunchRequest, aj as ResolvedForklaunchResponse, ak as ResponseBody, al as ResponseCompiledSchema, am as ResponseShape, an as RoleSet, ao as ServerSentEventBody, S as StringOnlyObject, ap as TextBody, aq as TypedBody, ar as TypedRequestBody, as as TypedResponseBody, at as UnknownBody, au as UnknownResponseBody, av as UrlEncodedForm, aw as VersionedResponses } from '../apiDefinition.types-DW4lfZqy.js';
-import { JWTPayload, JWK } from 'jose';
-import { ZodSchemaValidator } from '@forklaunch/validator/zod';
-import { FastMCP } from 'fastmcp';
-import http from 'http';
-import { OpenAPIObject } from 'openapi3-ts/oas31';
-import { LevelWithSilentOrString } from 'pino';
-export { LevelWithSilent, LevelWithSilentOrString, Logger } from 'pino';
-import { T as TtlCache } from '../ttlCache.interface-B3xaLT00.js';
-export { ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-import '@opentelemetry/api';
-import '@opentelemetry/api-logs';
-import 'stream';
-import 'cors';
-import '@scalar/express-api-reference';
-import '../ttlCacheRecord.types-oX0ti5SP.js';
-
-interface PathBasedHandler<RouterHandler> {
-    (path: string, ...handlers: RouterHandler[]): unknown;
-}
-interface PathOrMiddlewareBasedHandler<RouterHandler> extends PathBasedHandler<RouterHandler> {
-    (...args: RouterHandler[]): unknown;
-}
-interface NestableRouterBasedHandler<RouterHandler, Router> extends PathOrMiddlewareBasedHandler<RouterHandler> {
-    (...args: (Router | RouterHandler)[]): unknown;
-    (path: string, ...handlers: (Router | RouterHandler)[]): unknown;
-}
-interface ExpressLikeRouter<RouterHandler, Router> extends ServerOptions<typeof IncomingMessage, typeof ServerResponse> {
-    use: NestableRouterBasedHandler<RouterHandler, Router>;
-    all: PathOrMiddlewareBasedHandler<RouterHandler>;
-    connect: PathOrMiddlewareBasedHandler<RouterHandler>;
-    get: PathBasedHandler<RouterHandler>;
-    post: PathBasedHandler<RouterHandler>;
-    put: PathBasedHandler<RouterHandler>;
-    patch: PathBasedHandler<RouterHandler>;
-    delete: PathBasedHandler<RouterHandler>;
-    options: PathBasedHandler<RouterHandler>;
-    head: PathBasedHandler<RouterHandler>;
-    trace: PathBasedHandler<RouterHandler>;
-}
-
-interface ConstrainedForklaunchRouter<SV extends AnySchemaValidator, RequestHandler> extends ForklaunchRouter<SV> {
-    requestHandler: RequestHandler;
-}
-/**
- * Interface representing a Forklaunch router.
- *
- * @template SV - A type that extends AnySchemaValidator.
- */
-interface ForklaunchRouter<SV extends AnySchemaValidator> {
-    /** The base path for the router */
-    basePath: `/${string}`;
-    /** The routes associated with the router */
-    routes: ForklaunchRoute<SV>[];
-    /** Nested routers */
-    routers: ForklaunchRouter<SV>[];
-    /** Nested route map */
-    _fetchMap: Record<string, unknown>;
-    /** The SDK for the router */
-    sdk: Record<string, unknown>;
-    /** The name of the SDK for the router */
-    sdkName?: string;
-    /** The SDK paths for the router */
-    sdkPaths: Record<string, string>;
-    /** Options for the router */
-    routerOptions?: ExpressLikeRouterOptions<SV, SessionObject<SV>>;
-    /** Insert the SDK path into the router */
-    insertIntoRouterSdkPaths?: (params: {
-        sdkPath: string;
-        path: string;
-        method: string;
-        name: string;
-    }) => void;
-}
-/**
- * Interface representing a Forklaunch route.
- *
- * @template SV - A type that extends AnySchemaValidator.
- */
-interface ForklaunchRoute<SV extends AnySchemaValidator> {
-    /** The base path for the route */
-    basePath: string;
-    /** The path for the route, which can be a string, RegExp, or an array of strings or RegExps */
-    path: `/${string}`;
-    /** The HTTP method for the route */
-    method: Method;
-    /** The contract details for the route */
-    contractDetails: PathParamHttpContractDetails<SV> | HttpContractDetails<SV>;
-}
-
-type ContractDetailsExpressLikeSchemaHandler<SV extends AnySchemaValidator, ContractMethod extends Method, 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>, BaseRequest, BaseResponse, NextFunction, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>> = ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>;
-type TypedHandler<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>, BaseRequest, BaseResponse, NextFunction, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>> = {
-    _typedHandler: true;
-    _path: Path | undefined;
-    contractDetails: ContractDetails<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>;
-    handlers: ContractDetailsExpressLikeSchemaHandler<SV, ContractMethod, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>[];
-};
-type ExpressLikeTypedHandler<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>, BaseRequest, BaseResponse, NextFunction, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>> = {
-    _typedHandler: true;
-    _path: Path | undefined;
-    _method: ContractMethod;
-    contractDetails: ContractDetails<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[];
-};
-
-interface LiveTypeRouteDefinition<SV extends AnySchemaValidator, BasePath extends `/${string}`, ContractMethod extends Method, RouterHandler, Internal extends ExpressLikeRouter<RouterHandler, Internal>, Session extends SessionObject<SV>, BaseRequest, BaseResponse, NextFunction, ChainableRouter extends {
-    _fetchMap: object;
-    sdk: object;
-}> {
-    <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, ContractMethod>, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(path: Path, contractDetails: ContractDetails<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, BaseResponse, NextFunction>[]): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] extends Record<SanitizePathSlashes<`${BasePath}${Path}`>, unknown> ? ChainableRouter['_fetchMap'] & Record<SanitizePathSlashes<`${BasePath}${Path}`>, ChainableRouter['_fetchMap'][SanitizePathSlashes<`${BasePath}${Path}`>] & Record<Uppercase<ContractMethod>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, VersionedApi, Auth>>> : ChainableRouter['_fetchMap'] & Record<SanitizePathSlashes<`${BasePath}${Path}`>, Record<Uppercase<ContractMethod>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, VersionedApi, Auth>>>>;
-        sdk: Prettify<ChainableRouter['sdk'] & Record<PrettyCamelCase<Name>, LiveSdkFunction<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Auth>>>;
-    };
-    <Name extends string, Path extends `/${string}`, SuppliedPath extends Path, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, ContractMethod>, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(path: PathMatch<SuppliedPath, Path>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, BaseResponse, NextFunction>, ...middlewareAndTypedHandler: [
-        ...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, BaseResponse, NextFunction>[],
-        TypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>
-    ]): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] extends Record<SanitizePathSlashes<`${BasePath}${Path}`>, unknown> ? ChainableRouter['_fetchMap'] & Record<SanitizePathSlashes<`${BasePath}${Path}`>, ChainableRouter['_fetchMap'][SanitizePathSlashes<`${BasePath}${Path}`>] & Record<Uppercase<ContractMethod>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, VersionedApi, Auth>>> : ChainableRouter['_fetchMap'] & Record<SanitizePathSlashes<`${BasePath}${Path}`>, Record<Uppercase<ContractMethod>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, VersionedApi, Auth>>>>;
-        sdk: Prettify<ChainableRouter['sdk'] & Record<PrettyCamelCase<Name>, LiveSdkFunction<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Auth>>>;
-    };
-    <Name extends string, Path extends `/${string}`, SuppliedPath extends Path, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, const VersionedApi extends VersionSchema<SV, ContractMethod>, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(path: PathMatch<SuppliedPath, Path>, typedHandler: TypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] extends Record<SanitizePathSlashes<`${BasePath}${Path}`>, unknown> ? ChainableRouter['_fetchMap'] & Record<SanitizePathSlashes<`${BasePath}${Path}`>, ChainableRouter['_fetchMap'][SanitizePathSlashes<`${BasePath}${Path}`>] & Record<Uppercase<ContractMethod>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, VersionedApi, Auth>>> : ChainableRouter['_fetchMap'] & Record<SanitizePathSlashes<`${BasePath}${Path}`>, Record<Uppercase<ContractMethod>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, VersionedApi, Auth>>>>;
-        sdk: Prettify<ChainableRouter['sdk'] & Record<PrettyCamelCase<Name>, LiveSdkFunction<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Auth>>>;
-    };
-}
-interface TypedMiddlewareDefinition<ChainableRouter, SV extends AnySchemaValidator, Session extends SessionObject<SV>, BaseRequest, BaseResponse, NextFunction, RouterHandler> {
-    <Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(contractDetails: ContractDetails<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, BaseResponse, NextFunction>, ...middlewares: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, BaseResponse, NextFunction>[]): ChainableRouter;
-    <Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, SessionSchema extends SessionObject<SV>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(path: Path, contractDetails: ContractDetails<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, BaseResponse, NextFunction>, ...middlewares: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, SessionSchema, BaseRequest, BaseResponse, NextFunction>[]): ChainableRouter;
-    (middleware: RouterHandler, ...otherMiddleware: RouterHandler[]): ChainableRouter;
-    <Name extends string, Path extends `/${string}`, SuppliedPath extends Path, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(path: PathMatch<SuppliedPath, Path>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, BaseResponse, NextFunction>, ...middlewareAndTypedHandler: [
-        ...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, BaseResponse, NextFunction>[],
-        TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>
-    ]): ChainableRouter;
-    <Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, BaseResponse, NextFunction>, ...middlewareAndTypedHandler: [
-        ...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, Session>, BaseRequest, BaseResponse, NextFunction>[],
-        TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>
-    ]): ChainableRouter;
-    <Name extends string, Path extends `/${string}`, SuppliedPath extends Path, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(path: PathMatch<SuppliedPath, Path>, typedHandler: TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>): ChainableRouter;
-    <Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(typedHandler: TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>): ChainableRouter;
-}
-interface TypedNestableMiddlewareDefinition<ChainableRouter extends {
-    _fetchMap: object;
-    basePath: `/${string}`;
-    sdk: Record<string, unknown>;
-}, RouterHandler, Internal extends ExpressLikeRouter<RouterHandler, Internal>, SV extends AnySchemaValidator, Session extends SessionObject<SV>, BaseRequest, BaseResponse, NextFunction> extends TypedMiddlewareDefinition<ChainableRouter, SV, Session, BaseRequest, BaseResponse, NextFunction, RouterHandler> {
-    (middleware: RouterHandler, ...otherMiddleware: RouterHandler[]): ChainableRouter;
-    <Router extends ConstrainedForklaunchRouter<SV, RouterHandler>>(router: Router): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] & {
-            [Key in keyof Router['_fetchMap'] as Key extends string ? SanitizePathSlashes<`${ChainableRouter['basePath']}${Key}`> : never]: Router['_fetchMap'][Key];
-        }>;
-        sdk: Prettify<ChainableRouter['sdk'] & {
-            [K in PrettyCamelCase<Router['sdkName'] extends string ? Router['sdkName'] : Router['basePath']>]: Prettify<Router['sdk']>;
-        }>;
-    };
-    <Router extends ConstrainedForklaunchRouter<SV, RouterHandler>>(middlewareOrRouter: RouterHandler | Router, ...otherMiddlewareOrRouters: [...(RouterHandler | Router)[]]): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] & {
-            [Key in keyof Router['_fetchMap'] as Key extends string ? SanitizePathSlashes<`${ChainableRouter['basePath']}${Key}`> : never]: Router['_fetchMap'][Key];
-        }>;
-        sdk: Prettify<ChainableRouter['sdk'] & {
-            [K in PrettyCamelCase<Router['sdkName'] extends string ? Router['sdkName'] : Router['basePath']>]: Prettify<Router['sdk']>;
-        }>;
-    };
-    <Router extends ConstrainedForklaunchRouter<SV, RouterHandler>>(path: Router['basePath'], router: Router): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] & {
-            [Key in keyof Router['_fetchMap'] as Key extends string ? SanitizePathSlashes<`${ChainableRouter['basePath']}${Key}`> : never]: Router['_fetchMap'][Key];
-        }>;
-        sdk: Prettify<ChainableRouter['sdk'] & {
-            [K in PrettyCamelCase<Router['sdkName'] extends string ? Router['sdkName'] : Router['basePath']>]: Prettify<Router['sdk']>;
-        }>;
-    };
-    <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>, Router extends ConstrainedForklaunchRouter<SV, RouterHandler>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(contractDetails: ContractDetails<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Session, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewares: (ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Session, BaseRequest, BaseResponse, NextFunction> | Router)[]): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] & {
-            [Key in keyof Router['_fetchMap'] as Key extends string ? SanitizePathSlashes<`${ChainableRouter['basePath']}${Key}`> : never]: Router['_fetchMap'][Key];
-        }>;
-        sdk: Prettify<ChainableRouter['sdk'] & {
-            [K in PrettyCamelCase<Router['sdkName'] extends string ? Router['sdkName'] : Router['basePath']>]: Prettify<Router['sdk']>;
-        }>;
-    };
-    <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>, Router extends ConstrainedForklaunchRouter<SV, RouterHandler>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Session, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewareAndTypedHandler: [
-        ...(ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Session, BaseRequest, BaseResponse, NextFunction> | Router)[],
-        TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>
-    ]): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] & {
-            [Key in keyof Router['_fetchMap'] as Key extends string ? SanitizePathSlashes<`${ChainableRouter['basePath']}${Key}`> : never]: Router['_fetchMap'][Key];
-        }>;
-        sdk: Prettify<ChainableRouter['sdk'] & {
-            [K in PrettyCamelCase<Router['sdkName'] extends string ? Router['sdkName'] : Router['basePath']>]: Prettify<Router['sdk']>;
-        }>;
-    };
-    <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>, Router extends ConstrainedForklaunchRouter<SV, RouterHandler>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(path: `/${string}` extends Router['basePath'] ? Path : PathMatch<Path, Router['basePath']>, contractDetails: ContractDetails<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Session, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewares: (ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Session, BaseRequest, BaseResponse, NextFunction> | Router)[]): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] & {
-            [Key in keyof Router['_fetchMap'] as Key extends string ? SanitizePathSlashes<`${ChainableRouter['basePath']}${Key}`> : never]: Router['_fetchMap'][Key];
-        }>;
-        sdk: Prettify<ChainableRouter['sdk'] & {
-            [K in PrettyCamelCase<Router['sdkName'] extends string ? Router['sdkName'] : Router['basePath']>]: Prettify<Router['sdk']>;
-        }>;
-    };
-    <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>, Router extends ConstrainedForklaunchRouter<SV, RouterHandler>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(contractDetails: ContractDetails<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Session, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewares: (ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, Session, BaseRequest, BaseResponse, NextFunction> | Router)[]): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] & {
-            [Key in keyof Router['_fetchMap'] as Key extends string ? SanitizePathSlashes<`${ChainableRouter['basePath']}${Key}`> : never]: Router['_fetchMap'][Key];
-        }>;
-        sdk: Prettify<ChainableRouter['sdk'] & {
-            [K in PrettyCamelCase<Router['sdkName'] extends string ? Router['sdkName'] : Router['basePath']>]: Prettify<Router['sdk']>;
-        }>;
-    };
-    <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>, Router extends ConstrainedForklaunchRouter<SV, RouterHandler>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(path: `/${string}` extends Router['basePath'] ? Path : PathMatch<Path, Router['basePath']>, typedHandler: TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] & {
-            [Key in keyof Router['_fetchMap'] as Key extends string ? SanitizePathSlashes<`${ChainableRouter['basePath']}${Key}`> : never]: Router['_fetchMap'][Key];
-        }>;
-        sdk: Prettify<ChainableRouter['sdk'] & {
-            [K in PrettyCamelCase<Router['sdkName'] extends string ? Router['sdkName'] : Router['basePath']>]: Prettify<Router['sdk']>;
-        }>;
-    };
-    <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>, Router extends ConstrainedForklaunchRouter<SV, RouterHandler>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(typedHandler: TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>): ChainableRouter & {
-        _fetchMap: Prettify<ChainableRouter['_fetchMap'] & {
-            [Key in keyof Router['_fetchMap'] as Key extends string ? SanitizePathSlashes<`${ChainableRouter['basePath']}${Key}`> : never]: Router['_fetchMap'][Key];
-        }>;
-        sdk: Prettify<ChainableRouter['sdk'] & {
-            [K in PrettyCamelCase<Router['sdkName'] extends string ? Router['sdkName'] : Router['basePath']>]: Prettify<Router['sdk']>;
-        }>;
-    };
-}
-type ContractDetailsOrMiddlewareOrTypedHandler<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>, BaseRequest, BaseResponse, NextFunction, BaseSession extends SessionObject<SV>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>> = ContractDetails<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth> | ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, BaseSession>, BaseRequest, BaseResponse, NextFunction> | TypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-type MiddlewareOrMiddlewareWithTypedHandler<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>, BaseRequest, BaseResponse, NextFunction, BaseSession extends SessionObject<SV>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>> = ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, BaseSession>, BaseRequest, BaseResponse, NextFunction> | TypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-
-/**
- * Creates a type-safe fetch function based on a provided fetch map.
- * This type generates a function that provides compile-time type safety for HTTP requests,
- * ensuring that the correct path and request parameters are used for each endpoint.
- *
- * @template FetchMap - A record mapping paths to their corresponding TypeSafeFunction signatures
- * @param FetchMap[Path] - Each path should map to a TypeSafeFunction that defines the request/response contract
- *
- * @returns A generic function that:
- * - Takes a path parameter constrained to keys of FetchMap
- * - Takes optional request initialization parameters based on the function signature
- * - Returns a Promise of the expected response type
- *
- * @remarks
- * The function parameters are conditionally typed:
- * - If the mapped function expects body, query, params, or headers, reqInit is required
- * - Otherwise, reqInit is optional
- * - If the path doesn't map to a TypeSafeFunction, reqInit is never
- **/
-type FetchFunction<FetchMap> = <const Path extends keyof FetchMap, const Method extends keyof FetchMap[Path], const Version extends keyof FetchMap[Path][Method]>(path: Path, ...reqInit: FetchMap[Path][Method] extends TypeSafeFunction ? 'GET' extends keyof FetchMap[Path] ? FetchMap[Path]['GET'] extends TypeSafeFunction ? Parameters<FetchMap[Path]['GET']>[1] extends {
-    body: unknown;
-} | {
-    query: unknown;
-} | {
-    params: unknown;
-} | {
-    headers: unknown;
-} | {
-    version: unknown;
-} ? [
-    reqInit: Omit<Parameters<FetchMap[Path][Method]>[1], 'method'> & {
-        method: Method;
-    }
-] : [
-    reqInit?: Omit<Parameters<FetchMap[Path][Method]>[1], 'method'> & {
-        method: Method;
-    }
-] : [
-    reqInit: Omit<Parameters<FetchMap[Path][Method]>[1], 'method'> & {
-        method: Method;
-    }
-] : [
-    reqInit: Omit<Parameters<FetchMap[Path][Method]>[1], 'method'> & {
-        method: Method;
-    }
-] : FetchMap[Path][Method] extends Record<string, TypeSafeFunction> ? [
-    reqInit: Omit<Parameters<FetchMap[Path][Method][Version]>[0], 'method' | 'version'> & {
-        method: Method;
-        version: Version;
-    }
-] : [{
-    method: Method;
-}]) => Promise<FetchMap[Path][Method] extends TypeSafeFunction ? Awaited<ReturnType<FetchMap[Path][Method]>> : FetchMap[Path][Method] extends Record<string, TypeSafeFunction> ? Awaited<ReturnType<FetchMap[Path][Method][Version]>> : never>;
-/**
- * Represents the structure of a SDK router.
- *
- * @property sdk - The SDK object containing all the SDK functions.
- * @property _fetchMap - The fetch map object containing all the fetch functions.
- * @property sdkPaths - The SDK paths object containing all the SDK paths.
- */
-type SdkRouter = {
-    sdk: Record<string, unknown>;
-    _fetchMap: Record<string, unknown>;
-    sdkPaths: Record<string, string>;
-};
-/**
- * Recursive interface representing a hierarchical map of router configurations.
- * Each entry can either be a leaf node with SDK and fetch map configurations,
- * or a nested RouterMap for deeper routing structures.
- *
- * @template SV - The schema validator type that constrains the router structure
- * @param SV - Must extend AnySchemaValidator to ensure type safety
- *
- * @example
- * ```typescript
- * const routerMap: RouterMap<ZodValidator> = {
- *   api: {
- *     users: {
- *       sdk: { getUser: () => Promise.resolve({}) },
- *       _fetchMap: { getUser: { get: () => fetch('/api/users') } }
- *     },
- *     posts: {
- *       sdk: { getPosts: () => Promise.resolve([]) },
- *       _fetchMap: { getPosts: { get: () => fetch('/api/posts') } }
- *     }
- *   }
- * };
- * ```
- */
-type RouterMap<SV extends AnySchemaValidator> = {
-    [K: string]: SdkRouter | RouterMap<SV>;
-};
-/**
- * Recursive type representing a hierarchical map of SDK handlers.
- * Each key can either be a leaf node containing a SdkHandler, or a nested SdkHandlerObject for deeper structures.
- *
- * @template SV - The schema validator type that constrains the handler structure.
- *
- * @example
- * ```typescript
- * const handlers: SdkHandlerObject<ZodValidator> = {
- *   users: {
- *     getUser: someSdkHandler,
- *     posts: {
- *       getPosts: anotherSdkHandler
- *     }
- *   }
- * };
- * ```
- */
-type SdkHandlerObject<SV extends AnySchemaValidator> = {
-    [K: string]: SdkHandler | SdkHandlerObject<SV>;
-};
-/**
- * @deprecated
- * Tail-recursive type that extracts and flattens fetch map interfaces from a RouterMap structure.
- * This version uses an accumulator pattern to avoid deep recursion and improve performance.
- * Similar to MapToSdk but focuses on _fetchMap properties and merges all fetch maps into a single intersection type.
- *
- * @template SV - The schema validator type
- * @template T - The RouterMap to extract fetch maps from
- * @template Acc - The accumulator type for collecting fetch maps (defaults to empty object)
- * @param SV - Must extend AnySchemaValidator
- * @param T - Must extend RouterMap<SV>
- * @param Acc - The accumulated fetch maps so far
- *
- * @returns An intersection type containing all fetch map interfaces from the router structure,
- *         flattened into a single type for unified fetch functionality
- *
- * @example
- * ```typescript
- * // Given a RouterMap with nested fetch maps
- * type ExtractedFetch = MapToFetch<ZodValidator, typeof routerMap>;
- * // Results in: { getUser: { get: () => Promise<Response> } } & { getPosts: { get: () => Promise<Response> } }
- * ```
- */
-type MapToFetch<SV extends AnySchemaValidator, T extends RouterMap<SV>> = UnionToIntersection<Prettify<{
-    [K in keyof T]: T[K] extends RouterMap<SV> ? MapToFetch<SV, T[K]> : T[K] extends {
-        _fetchMap: unknown;
-    } ? T[K]['_fetchMap'] extends Record<string, unknown> ? T[K]['_fetchMap'] : never : never;
-}[keyof T]>>;
-/**
- * Base interface for controller entries that defines the structure
- * of each controller method with its path, HTTP method, and contract details.
- * This type serves as the foundation for type-safe SDK generation by ensuring
- * all controller entries follow a consistent structure.
- *
- * @example
- * ```typescript
- * const controller: Record<string, SdkHandler> = {
- *   createUser: {
- *     _path: '/users',
- *     _method: 'post',
- *     contractDetails: {
- *       name: 'createUser',
- *       body: { name: string, email: string },
- *       responses: { 201: { id: string, name: string } }
- *     }
- *   }
- * };
- * ```
- */
-type SdkHandler = {
-    /** The HTTP path for this endpoint, must start with '/' */
-    _path?: `/${string}`;
-    /** The HTTP method for this endpoint (get, post, put, etc.) */
-    _method?: Method;
-    /** Contract details defining the request/response schema for this endpoint */
-    contractDetails: {
-        /** The name of this endpoint/method */
-        name: string;
-        /** URL parameters schema */
-        params?: unknown;
-        /** Response schemas for different status codes */
-        responses?: unknown;
-        /** Query parameters schema */
-        query?: unknown;
-        /** Request body schema */
-        body?: unknown;
-        /** Request headers schema */
-        requestHeaders?: unknown;
-        /** Response headers schema */
-        responseHeaders?: unknown;
-        /** Authentication requirements */
-        auth?: unknown;
-        /** API versioning information */
-        versions?: unknown;
-    };
-};
-/**
- * Recursively maps a client controller definition to its corresponding live SDK function types.
- *
- * This utility type traverses the structure of a client controller object, replacing each
- * {@link SdkHandler} with its corresponding {@link MapHandlerToLiveSdk} type, while recursively
- * processing nested objects. This enables type-safe SDK generation for complex controller hierarchies.
- *
- * @template SV - The schema validator type (e.g., zod, typebox).
- * @template Client - The client controller object to map.
- *
- * @example
- * type MySdk = MapToSdk<typeof z, typeof myController>;
- */
-type MapToSdk<SV extends AnySchemaValidator, Client> = {
-    [K in keyof Client]: Client[K] extends SdkHandler ? MapHandlerToLiveSdk<SV, Client[K]> : MapToSdk<SV, Client[K]>;
-};
-type MapHandlerToLiveSdk<SV extends AnySchemaValidator, T extends SdkHandler> = LiveSdkFunction<SV, T['contractDetails']['params'] extends infer Params | undefined ? Params extends ParamsObject<SV> ? Params : ParamsObject<SV> : ParamsObject<SV>, T['contractDetails']['responses'] extends infer Responses | undefined ? Responses extends ResponsesObject<SV> ? Responses : ResponsesObject<SV> : ResponsesObject<SV>, T['contractDetails']['body'] extends infer B | undefined ? B extends Body<SV> ? B : Body<SV> : Body<SV>, T['contractDetails']['query'] extends infer Q | undefined ? Q extends QueryObject<SV> ? Q : QueryObject<SV> : QueryObject<SV>, T['contractDetails']['requestHeaders'] extends infer RequestHeaders | undefined ? RequestHeaders extends HeadersObject<SV> ? RequestHeaders : HeadersObject<SV> : HeadersObject<SV>, T['contractDetails']['responseHeaders'] extends infer ResponseHeaders | undefined ? ResponseHeaders extends HeadersObject<SV> ? ResponseHeaders : HeadersObject<SV> : HeadersObject<SV>, T['contractDetails']['versions'] extends infer Versions | undefined ? Versions extends VersionSchema<SV, Method> ? Versions : VersionSchema<SV, Method> : VersionSchema<SV, Method>, T['contractDetails']['auth'] extends infer Auth | undefined ? Auth extends AuthMethodsBase ? Auth : AuthMethodsBase : AuthMethodsBase>;
-/**
- * @deprecated
- * Extracts and constructs a LiveTypeFunction from an SdkHandler object.
- * This optimized version reduces redundant type inference while maintaining type safety.
- *
- * @template Entry - The controller entry containing path, method, and contract details
- * @template SV - The schema validator type that constrains the contract details
- * @template BasePath - The base path prefix to prepend to the entry's path
- *
- * @example
- * ```typescript
- * type UserCreateFunction = ExtractLiveTypeFn<
- *   { _path: '/users', _method: 'post', contractDetails: { body: { name: string } } },
- *   SchemaValidator,
- *   '/api/v1'
- * >;
- * ```
- */
-type ExtractLiveTypeFn<Entry extends SdkHandler, SV extends AnySchemaValidator, BasePath extends `/${string}`> = LiveTypeFunction<SV, Entry['_path'] extends infer Path | undefined ? Path extends `/${string}` ? `${BasePath}${Path}` : never : never, Entry['contractDetails']['params'] extends infer Params | undefined ? Params extends ParamsObject<SV> ? Params : ParamsObject<SV> : ParamsObject<SV>, Entry['contractDetails']['responses'] extends infer Responses | undefined ? Responses extends ResponsesObject<SV> ? Responses : ResponsesObject<SV> : ResponsesObject<SV>, Entry['contractDetails']['body'] extends infer B | undefined ? B extends Body<SV> ? B : Body<SV> : Body<SV>, Entry['contractDetails']['query'] extends infer Q | undefined ? Q extends QueryObject<SV> ? Q : QueryObject<SV> : QueryObject<SV>, Entry['contractDetails']['requestHeaders'] extends infer RequestHeaders | undefined ? RequestHeaders extends HeadersObject<SV> ? RequestHeaders : HeadersObject<SV> : HeadersObject<SV>, Entry['contractDetails']['responseHeaders'] extends infer ResponseHeaders | undefined ? ResponseHeaders extends HeadersObject<SV> ? ResponseHeaders : HeadersObject<SV> : HeadersObject<SV>, Entry['_method'] extends Method ? Entry['_method'] : never, Entry['contractDetails']['versions'] extends infer Versions | undefined ? Versions extends VersionSchema<SV, Method> ? Versions : VersionSchema<SV, Method> : VersionSchema<SV, Method>, Entry['contractDetails']['auth'] extends infer Auth | undefined ? Auth extends AuthMethodsBase ? Auth : AuthMethodsBase : AuthMethodsBase>;
-/**
- * @deprecated
- * Transforms a controller object into a fetch map structure that provides
- * type-safe access to HTTP endpoints. This optimized version reduces complexity
- * while maintaining full type safety and discriminated union behavior.
- *
- * @template T - The controller object type containing all endpoint definitions
- * @template SV - The schema validator type that constrains the contract details
- * @template RouterBasePath - The base path prefix for the router
- *
- * @example
- * ```typescript
- * const controller = {
- *   createUser: { _path: '/users', _method: 'post', contractDetails: { body: { name: string } } },
- *   getUser: { _path: '/users/:id', _method: 'get', contractDetails: { params: { id: string } } }
- * } as const;
- *
- * type FetchMap = ToFetchMap<typeof controller, SchemaValidator, '/api/v1'>;
- * // Results in properly typed fetch map with discriminated methods per path
- * ```
- */
-type ToFetchMap<T extends Record<string, SdkHandler>, SV extends AnySchemaValidator, RouterBasePath extends `/${string}`> = Prettify<{
-    [K in keyof T as T[K]['_path'] extends infer P | undefined ? P extends `/${string}` ? `${RouterBasePath}${P}` : never : never]: {
-        [M in T[K]['_method'] as M extends Method ? Uppercase<M> : never]: ExtractLiveTypeFn<Extract<T[K], {
-            _path: T[K]['_path'];
-            _method: M;
-        }>, SV, RouterBasePath>;
-    };
-}>;
-
-/**
- * Extracts route middleware and handlers from route registration arguments.
- * This is a port function that converts typed handlers into Express middleware
- * without actually registering them on a router.
- *
- * @template SV - The schema validator type.
- * @template Name - The route name.
- * @template ContractMethod - The HTTP method.
- * @template Path - The route path.
- * @template P - The type of request parameters.
- * @template ResBodyMap - The type of response body map.
- * @template ReqBody - The type of request body.
- * @template ReqQuery - The type of request query.
- * @template ReqHeaders - The type of request headers.
- * @template ResHeaders - The type of response headers.
- * @template LocalsObj - The type of local variables.
- * @template VersionedApi - The versioned API schema.
- * @template RouterSession - The router session type.
- * @template BaseRequest - The base request type.
- * @template BaseResponse - The base response type.
- * @template NextFunction - The next function type.
- * @template Auth - The auth schema.
- * @template RouterHandler - The router handler type.
- * @param {object} params - The parameters for extracting route handlers.
- * @param {ContractMethod} params.method - The HTTP method.
- * @param {Path} params.path - The route path.
- * @param {string} params.basePath - The base path for the router.
- * @param {SV} params.schemaValidator - The schema validator.
- * @param {ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, RouterSession, Auth>} params.contractDetailsOrMiddlewareOrTypedHandler - The contract details or typed handler.
- * @param {MiddlewareOrMiddlewareWithTypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, RouterSession, Auth>[]} params.middlewareOrMiddlewareAndTypedHandler - Additional middleware or typed handlers.
- * @param {OpenTelemetryCollector<MetricsDefinition>} params.openTelemetryCollector - The OpenTelemetry collector.
- * @param {RouterHandler[]} params.postEnrichMiddleware - Additional middleware to run after enrichment.
- * @param {ExpressLikeRouterOptions<SV, RouterSession> | undefined} params.routerOptions - Router options.
- * @returns {{ middlewares: RouterHandler[]; controllerHandler: ExpressLikeHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedRequests, VersionedResponses, RouterSession, BaseRequest, BaseResponse, NextFunction> }} - The extracted middlewares and controller handler.
- */
-declare function extractRouteHandlers<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>(params: {
-    method: ContractMethod;
-    path: Path;
-    basePath: string;
-    schemaValidator: SV;
-    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>[];
-    openTelemetryCollector?: OpenTelemetryCollector<MetricsDefinition>;
-    postEnrichMiddleware?: RouterHandler[];
-    routerOptions?: ExpressLikeRouterOptions<SV, RouterSession>;
-}): {
-    middlewares: RouterHandler[];
-    controllerHandler: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, RouterSession, BaseRequest, BaseResponse, NextFunction>;
-};
-/**
- * A class that represents an Express-like router.
- */
-declare class ForklaunchExpressLikeRouter<SV extends AnySchemaValidator, BasePath extends `/${string}`, RouterHandler, Internal extends ExpressLikeRouter<RouterHandler, Internal>, BaseRequest, BaseResponse, NextFunction, RouterSession extends SessionObject<SV>, FetchMap extends Record<string, unknown> = EmptyObject, Sdk extends Record<string, unknown> = EmptyObject> implements ConstrainedForklaunchRouter<SV, RouterHandler> {
-    #private;
-    readonly basePath: BasePath;
-    readonly schemaValidator: SV;
-    readonly internal: Internal;
-    readonly postEnrichMiddleware: RouterHandler[];
-    readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
-    readonly routerOptions?: ExpressLikeRouterOptions<SV, RouterSession> | undefined;
-    requestHandler: RouterHandler;
-    routers: ForklaunchRouter<SV>[];
-    routes: ForklaunchRoute<SV>[];
-    _fetchMap: FetchMap;
-    sdk: Sdk;
-    sdkPaths: Record<string, string>;
-    constructor(basePath: BasePath, schemaValidator: SV, internal: Internal, postEnrichMiddleware: RouterHandler[], openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, routerOptions?: ExpressLikeRouterOptions<SV, RouterSession> | undefined);
-    /**
-     * Extracts the controller handler from the provided handlers.
-     *
-     * @template P - The type of request parameters.
-     * @template ResBodyMap - The type of response body.
-     * @template ReqBody - The type of request body.
-     * @template ReqQuery - The type of request query.
-     * @template LocalsObj - The type of local variables.
-     * @param {MiddlewareHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The provided handlers.
-     * @returns {MiddlewareHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>} - The extracted controller handler.
-     * @throws {Error} - Throws an error if the last argument is not a handler.
-     */
-    /**
-     * Fetches a route from the route map and executes it with the given parameters.
-     *
-     * @template Path - The path type that extends keyof _fetchMap and string.
-     * @param {Path} path - The route path
-     * @param {Parameters<_fetchMap[Path]>[1]} [requestInit] - Optional request initialization parameters.
-     * @returns {Promise<ReturnType<_fetchMap[Path]>>} - The result of executing the route handler.
-     */
-    fetch: FetchFunction<this['_fetchMap']>;
-    registerRoute<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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(method: ContractMethod, path: Path, registrationMethod: PathBasedHandler<RouterHandler>, 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>[]): this & {
-        _fetchMap: Prettify<FetchMap extends Record<SanitizePathSlashes<`${BasePath}${Path}`>, unknown> ? FetchMap & Record<SanitizePathSlashes<`${BasePath}${Path}`>, FetchMap[SanitizePathSlashes<`${BasePath}${Path}`>] & Record<Uppercase<ContractMethod>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, VersionedApi, Auth>>> : FetchMap & Record<SanitizePathSlashes<`${BasePath}${Path}`>, Record<Uppercase<ContractMethod>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, VersionedApi, Auth>>>>;
-        sdk: Prettify<Sdk & Record<PrettyCamelCase<Name extends string ? Name : SanitizePathSlashes<`${BasePath}${Path}`>>, LiveSdkFunction<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, Auth>>>;
-    };
-    registerMiddlewareHandler<Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(registrationMethod: PathOrMiddlewareBasedHandler<RouterHandler>, pathOrContractDetailsOrMiddlewareOrTypedHandler: Path | ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, RouterSession, Auth> | RouterHandler, contractDetailsOrMiddlewareOrTypedHandler?: ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, RouterSession, Auth> | RouterHandler, ...middlewareOrMiddlewareWithTypedHandler: (MiddlewareOrMiddlewareWithTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, RouterSession, Auth> | RouterHandler)[]): this;
-    private addRouterToSdk;
-    registerNestableMiddlewareHandler<Name extends string, Path extends `/${string}`, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, const SessionSchema extends SessionObject<SV>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(registrationMethod: NestableRouterBasedHandler<RouterHandler, Internal>, pathOrContractDetailsOrMiddlewareOrTypedHandler: Path | ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, RouterSession, Auth> | ConstrainedForklaunchRouter<SV, RouterHandler>, contractDetailsOrMiddlewareOrTypedHandler?: ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, RouterSession, Auth> | ConstrainedForklaunchRouter<SV, RouterHandler>, ...middlewareOrMiddlewareWithTypedHandler: (MiddlewareOrMiddlewareWithTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, RouterSession, Auth> | ConstrainedForklaunchRouter<SV, RouterHandler>)[]): this;
-    private addRouterOptions;
-    /**
-     * Validates that all protected routes have the required surfacing functions
-     * available (from the route, router, or application level).
-     * Call this at listen() time when the full option chain is assembled.
-     */
-    validateSurfacingFunctions(router?: ForklaunchRouter<SV>, parentAuth?: Record<string, unknown>): void;
-    use: TypedNestableMiddlewareDefinition<this, RouterHandler, Internal, SV, RouterSession, BaseRequest, BaseResponse, NextFunction>;
-    all: TypedMiddlewareDefinition<this, SV, RouterSession, BaseRequest, BaseResponse, NextFunction, RouterHandler>;
-    connect: TypedMiddlewareDefinition<this, SV, RouterSession, BaseRequest, BaseResponse, NextFunction, RouterHandler>;
-    /**
-     * Registers a GET route with the specified contract details and handler handlers.
-     *
-     * @template P - The type of request parameters.
-     * @template ResBodyMap - The type of response body.
-     * @template ReqBody - The type of request body.
-     * @template ReqQuery - The type of request query.
-     * @template LocalsObj - The type of local variables.
-     * @param {string} path - The path for the route.
-     * @param {PathParamHttpContractDetails<SV, P, ResBodyMap, ReqQuery>} contractDetails - The contract details.
-     * @param {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    get: LiveTypeRouteDefinition<SV, BasePath, 'get', RouterHandler, Internal, RouterSession, BaseRequest, BaseResponse, NextFunction, this>;
-    /**
-     * Registers a POST route with the specified contract details and handler handlers.
-     *
-     * @template P - The type of request parameters.
-     * @template ResBodyMap - The type of response body.
-     * @template ReqBody - The type of request body.
-     * @template ReqQuery - The type of request query.
-     * @template LocalsObj - The type of local variables.
-     * @param {string} path - The path for the route.
-     * @param {HttpContractDetails<SV, P, ResBodyMap, ReqBody, ReqQuery>} contractDetails - The contract details.
-     * @param {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Expxwress router.
-     */
-    post: LiveTypeRouteDefinition<SV, BasePath, 'post', RouterHandler, Internal, RouterSession, BaseRequest, BaseResponse, NextFunction, this>;
-    /**
-     * Registers a PUT route with the specified contract details and handler handlers.
-     *
-     * @template P - The type of request parameters.
-     * @template ResBodyMap - The type of response body.
-     * @template ReqBody - The type of request body.
-     * @template ReqQuery - The type of request query.
-     * @template LocalsObj - The type of local variables.
-     * @param {string} path - The path for the route.
-     * @param {HttpContractDetails<SV, P, ResBodyMap, ReqBody, ReqQuery>} contractDetails - The contract details.
-     * @param {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    put: LiveTypeRouteDefinition<SV, BasePath, 'put', RouterHandler, Internal, RouterSession, BaseRequest, BaseResponse, NextFunction, this>;
-    /**
-     * Registers a PATCH route with the specified contract details and handler handlers.
-     *
-     * @template P - The type of request parameters.
-     * @template ResBodyMap - The type of response body.
-     * @template ReqBody - The type of request body.
-     * @template ReqQuery - The type of request query.
-     * @template LocalsObj - The type of local variables.
-     * @param {string} path - The path for the route.
-     * @param {HttpContractDetails<SV, P, ResBodyMap, ReqBody, ReqQuery>} contractDetails - The contract details.
-     * @param {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    patch: LiveTypeRouteDefinition<SV, BasePath, 'patch', RouterHandler, Internal, RouterSession, BaseRequest, BaseResponse, NextFunction, this>;
-    /**
-     * Registers a DELETE route with the specified contract details and handler handlers.
-     *
-     * @template P - The type of request parameters.
-     * @template ResBodyMap - The type of response body.
-     * @template ReqBody - The type of request body.
-     * @template ReqQuery - The type of request query.
-     * @template LocalsObj - The type of local variables.
-     * @param {string} path - The path for the route.
-     * @param {PathParamHttpContractDetails<SV, P, ResBodyMap, ReqQuery>} contractDetails - The contract details.
-     * @param {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    delete: LiveTypeRouteDefinition<SV, BasePath, 'delete', RouterHandler, Internal, RouterSession, BaseRequest, BaseResponse, NextFunction, this>;
-    /**
-     * Registers a OPTIONS route with the specified contract details and handler handlers.
-     *
-     * @template P - The type of request parameters.
-     * @template ResBodyMap - The type of response body.
-     * @template ReqBody - The type of request body.
-     * @template ReqQuery - The type of request query.
-     * @template LocalsObj - The type of local variables.
-     * @param {string} path - The path for the route.
-     * @param {PathParamHttpContractDetails<SV, P, ResBodyMap, ReqQuery>} contractDetails - The contract details.
-     * @param {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    options: LiveTypeRouteDefinition<SV, BasePath, 'options', RouterHandler, Internal, RouterSession, BaseRequest, BaseResponse, NextFunction, this>;
-    /**
-     * Registers a HEAD route with the specified contract details and handler handlers.
-     *
-     * @template P - The type of request parameters.
-     * @template ResBodyMap - The type of response body.
-     * @template ReqBody - The type of request body.
-     * @template ReqQuery - The type of request query.
-     * @template LocalsObj - The type of local variables.
-     * @param {string} path - The path for the route.
-     * @param {PathParamHttpContractDetails<SV, P, ResBodyMap, ReqQuery>} contractDetails - The contract details.
-     * @param {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    head: LiveTypeRouteDefinition<SV, BasePath, 'head', RouterHandler, Internal, RouterSession, BaseRequest, BaseResponse, NextFunction, this>;
-    /**
-     * Registers a TRACE route with the specified contract details and handler handlers.
-     *
-     * @template P - The type of request parameters.
-     * @template ResBodyMap - The type of response body.
-     * @template ReqBody - The type of request body.
-     * @template ReqQuery - The type of request query.
-     * @template LocalsObj - The type of local variables.
-     * @param {string} path - The path for the route.
-     * @param {PathParamHttpContractDetails<SV, P, ResBodyMap, ReqQuery>} contractDetails - The contract details.
-     * @param {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    trace: LiveTypeRouteDefinition<SV, BasePath, 'trace', RouterHandler, Internal, RouterSession, BaseRequest, BaseResponse, NextFunction, this>;
-    insertIntoRouterSdkPaths({ sdkPath, path, method, name }: {
-        sdkPath: string;
-        name: string;
-        path: string;
-        method: string;
-    }): void;
-    private unpackSdks;
-    registerSdks(sdks: SdkHandlerObject<SV>): void;
-    protected cloneInternals(clone: this): void;
-    clone(): this;
-}
-
-/**
- * ForklaunchExpressLikeApplication class that sets up routes and middleware for an Express-like application, for use with controller/routes pattern.
- *
- * @template SV - A type that extends AnySchemaValidator.
- * @template Server - The server type.
- */
-declare abstract class ForklaunchExpressLikeApplication<SV extends AnySchemaValidator, Server extends ExpressLikeRouter<RouterHandler, Server>, RouterHandler, BaseRequest, BaseResponse, NextFunction, Session extends SessionObject<SV>, FetchMap extends Record<string, unknown> = EmptyObject, Sdk extends Record<string, unknown> = EmptyObject> extends ForklaunchExpressLikeRouter<SV, '/', RouterHandler, Server, BaseRequest, BaseResponse, NextFunction, Session, FetchMap, Sdk> {
-    readonly schemaValidator: SV;
-    readonly internal: Server;
-    readonly postEnrichMiddleware: RouterHandler[];
-    readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
-    readonly appOptions?: ExpressLikeApplicationOptions<SV, Session> | undefined;
-    /**
-     * Creates an instance of the Application class.
-     *
-     * @param {SV} schemaValidator - The schema validator.
-     */
-    constructor(schemaValidator: SV, internal: Server, postEnrichMiddleware: RouterHandler[], openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, appOptions?: ExpressLikeApplicationOptions<SV, Session> | undefined);
-    /**
-     * Validates all registered routes across the app and all mounted routers.
-     * Call this at the start of listen() to fail fast at startup.
-     */
-    protected validateAllRoutes(): void;
-    abstract listen(...args: unknown[]): void;
-}
-
-type RoutingStrategy = 'round-robin' | 'sticky' | 'random';
-interface ClusterConfig<ExpressApp> {
-    port: number;
-    host: string;
-    workerCount: number;
-    routingStrategy?: RoutingStrategy;
-    expressApp: ExpressApp;
-    openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
-    ssl?: {
-        keyFile: string;
-        certFile: string;
-        caFile: string;
-    };
-}
-
-declare function isPortBound(port: number, host?: string): Promise<boolean>;
-
-/**
- * Creates an HMAC token for a given method, path, body, timestamp, nonce, and secret key.
- * @param method - The HTTP method to use.
- * @param path - The path to use.
- * @param body - The body to use.
- * @param timestamp - The timestamp to use.
- * @param nonce - The nonce to use.
- * @param secretKey - The secret key to use.
- * @returns The HMAC token.
- */
-declare function createHmacToken({ method, path, body, timestamp, nonce, secretKey }: {
-    method: string;
-    path: string;
-    body?: unknown;
-    timestamp: Date;
-    nonce: string;
-    secretKey: string;
-}): string;
-
-/**
- * Generate HMAC authorization headers for service-to-service authentication.
- *
- * @param secretKey - The shared HMAC secret key
- * @param method - HTTP method (GET, POST, etc.)
- * @param path - The API path
- * @param body - Optional request body
- * @param keyId - Optional key identifier (defaults to 'default')
- * @returns Authorization header object
- *
- * @example
- * ```typescript
- * const headers = generateHmacAuthHeaders({
- *   secretKey: 'my-secret-key',
- *   method: 'POST',
- *   path: '/api/users',
- *   body: { name: 'John' }
- * });
- * // headers.authorization = 'HMAC keyId=default ts=2024-01-16T12:00:00.000Z nonce=... signature=...'
- * ```
- */
-declare function generateHmacAuthHeaders({ secretKey, method, path, body, keyId }: {
-    secretKey: string;
-    method: string;
-    path: string;
-    body?: unknown;
-    keyId?: string;
-}): {
-    authorization: `HMAC keyId=${string} ts=${string} nonce=${string} signature=${string}`;
-};
-
-/**
- * Retrieves and caches the JSON Web Key Set (JWKS) from a given public key URL.
- *
- * This function fetches the JWKS from the specified URL and caches the result in memory
- * to avoid unnecessary network requests. The cache is considered valid for a duration
- * specified by the `cache-control` header in the JWKS HTTP response (in seconds), or
- * falls back to a default TTL if the header is not present. If the cache is still valid,
- * the cached keys are returned immediately.
- *
- * @param {string} jwksPublicKeyUrl - The URL to fetch the JWKS from.
- * @returns {Promise<JWK[]>} A promise that resolves to an array of JWK objects.
- *
- * @example
- * const jwks = await getCachedJwks('https://example.com/.well-known/jwks.json');
- * // Use jwks for JWT verification, etc.
- */
-declare function getCachedJwks(jwksPublicKeyUrl: string): Promise<JWK[]>;
-/**
- * Discriminates between different authentication methods and returns a typed result.
- *
- * This function analyzes the provided authentication configuration and determines
- * whether it uses basic authentication or JWT authentication. It returns a
- * discriminated union type that includes the authentication type and the
- * corresponding authentication configuration.
- *
- * @template SV - A type that extends AnySchemaValidator
- * @template P - A type that extends ParamsDictionary
- * @template ReqBody - A type that extends Record<string, unknown>
- * @template ReqQuery - A type that extends ParsedQs
- * @template ReqHeaders - A type that extends Record<string, unknown>
- * @template BaseRequest - The base request type
- *
- * @param auth - The authentication methods configuration object
- * @returns A discriminated union object with either:
- *   - `{ type: 'basic', auth: BasicAuthMethods['basic'] }` for basic authentication
- *   - `{ type: 'jwt', auth?: JwtAuthMethods['jwt'] }` for JWT authentication (auth is optional)
- *
- * @example
- * ```typescript
- * const authConfig = {
- *   basic: {
- *     login: (username: string, password: string) => boolean
- *   }
- * };
- * const result = discriminateAuthMethod(authConfig);
- * // result.type === 'basic'
- * // result.auth === authConfig.basic
- * ```
- */
-declare function discriminateAuthMethod<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends ParsedQs, ReqHeaders extends Record<string, string>, VersionedReqs extends VersionedRequests, BaseRequest>(auth: AuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedReqs, BaseRequest>, openTelemetryCollector?: OpenTelemetryCollector<MetricsDefinition>): Promise<{
-    type: 'basic';
-    auth: {
-        decodeResource?: DecodeResource;
-        login: BasicAuthMethods['basic']['login'];
-    };
-} | {
-    type: 'jwt';
-    auth: {
-        decodeResource?: DecodeResource;
-    } | {
-        verificationFunction: (token: string) => Promise<JWTPayload | undefined>;
-    };
-} | {
-    type: 'hmac';
-    auth: {
-        secretKeys: Record<string, string>;
-        verificationFunction: ({ body, path, method, timestamp, nonce, signature, secretKey }: {
-            method: string;
-            path: string;
-            body?: unknown;
-            timestamp: Date;
-            nonce: string;
-            signature: string;
-            secretKey: string;
-        }) => Promise<boolean | undefined>;
-    };
-}>;
-
-/**
- * Type guard that checks if an object is a Forklaunch request.
- * A Forklaunch request is an object that contains contract details and follows the Forklaunch request structure.
- *
- * @template SV - A type that extends AnySchemaValidator
- * @template P - The type of route parameters that extends ParamsDictionary
- * @template ReqBody - The type of request body that extends Record<string, unknown>
- * @template ReqQuery - The type of request query parameters that extends ParsedQs
- * @template ReqHeaders - The type of request headers that extends Record<string, unknown>
- * @param {unknown} request - The object to check
- * @returns {boolean} A type predicate indicating whether the object is a ForklaunchRequest
- *
- * @example
- * ```ts
- * if (isForklaunchRequest(request)) {
- *   // request is now typed as ForklaunchRequest
- *   const { contractDetails } = request;
- * }
- * ```
- */
-declare function isForklaunchRequest<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends ParsedQs, ReqHeaders extends Record<string, string>, VersionedReqs extends VersionedRequests, SessionSchema extends Record<string, unknown>>(request: unknown): request is ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, Extract<keyof VersionedReqs, string>, SessionSchema>;
-
-/**
- * Type guard that checks if an object is a Forklaunch router.
- * A Forklaunch router is an object that has a base path and an array of routes.
- *
- * @template SV - A type that extends AnySchemaValidator
- * @param {unknown} maybeForklaunchRouter - The object to check
- * @returns {boolean} A type predicate indicating whether the object is a ForklaunchRouter
- *
- * @example
- * ```ts
- * if (isForklaunchRouter(router)) {
- *   // router is now typed as ForklaunchRouter
- *   router.basePath; // '/api'
- *   router.routes; // Route[]
- * }
- * ```
- */
-declare function isForklaunchRouter<SV extends AnySchemaValidator>(maybeForklaunchRouter: unknown): maybeForklaunchRouter is ForklaunchRouter<SV>;
-
-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>, VersionedApi extends VersionSchema<SV, "delete">, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: PathParamHttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "delete", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-
-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>, VersionedApi extends VersionSchema<SV, "get">, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: PathParamHttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "get", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-
-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>, VersionedApi extends VersionSchema<SV, "head">, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: PathParamHttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "head", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-
-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>, VersionedApi extends VersionSchema<SV, "middleware">, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[]) => {
-    _typedHandler: true;
-    _path: Path;
-    contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[];
-};
-
-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>, VersionedApi extends VersionSchema<SV, "options">, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: PathParamHttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "options", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-
-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>, VersionedApi extends VersionSchema<SV, "patch">, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: HttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "patch", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-
-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>, VersionedApi extends VersionSchema<SV, "post">, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: HttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "post", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-
-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>, VersionedApi extends VersionSchema<SV, "put">, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: HttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "put", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-
-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>, VersionedApi extends VersionSchema<SV, "trace">, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: PathParamHttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "trace", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-
-declare function typedAuthHandler<SV extends AnySchemaValidator, Name extends string, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, VersionedApi extends VersionSchema<SV, Method>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>, BaseRequest>(_schemaValidator: SV, _contractDetails: ContractDetails<SV, Name, Method, `/${string}`, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, authHandler: ExpressLikeSchemaAuthMapper<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest>): ExpressLikeSchemaAuthMapper<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest>;
-
-/**
- * Router class that sets up routes and middleware for an Express router, for use with controller/routes pattern.
- *
- * @template SV - A type that extends AnySchemaValidator.
- * @template contractDetails - The contract details.
- * @template handlers - The handler middlware and handler.
- */
-declare function typedHandler<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>, const VersionedApi extends VersionSchema<SV, ContractMethod>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(_schemaValidator: SV, _path: Path | undefined, _contractMethod: ContractMethod, contractDetails: ContractDetails<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[]): ExpressLikeTypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-declare function typedHandler<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>, const VersionedApi extends VersionSchema<SV, ContractMethod>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(_schemaValidator: SV, _contractMethod: ContractMethod, contractDetails: ContractDetails<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, ResolvedSessionObject<SV, Auth, SessionObject<SV>>, BaseRequest, BaseResponse, NextFunction>[]): ExpressLikeTypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth>;
-
-/**
- * Object-map of the HTTP Status Codes. Maps from the status code, to the
- * textual name. The key is the HTTP Status Code number, and the resulting
- * value will be the textual name for that Status Code.
- *
- * The comments for each item are taken from httpstatuses.com and the RFC-7231
- * document.
- *
- * @see https://httpstatuses.com
- * @see https://datatracker.ietf.org/doc/html/rfc7231
- */
-declare const HTTPStatuses: Readonly<{
-    [key: number]: string;
-}>;
-/**
- * Numerical HTTP status code.
- */
-type StatusCode = keyof typeof HTTPStatuses;
-/**
- * Checks if the given numerical status code is in the known HTTP status codes
- * list.
- *
- * @param code HTTP Status code
- * @returns True if the code is a valid HTTP status code
- */
-declare const isValidStatusCode: (code: number) => boolean;
-/**
- * Checks if the given status code is in the informational range (1XX).
- *
- * @param code HTTP Status code
- * @returns True if the code is in the "informational" range.
- */
-declare const isInformational: (code: StatusCode) => boolean;
-/**
- * Checks if the given status code is in the successful range (2XX).
- *
- * @param code HTTP Status code
- * @returns True if the code is in the "success" range.
- */
-declare const isSuccessful: (code: StatusCode) => boolean;
-/**
- * Checks if the given status code is in the redirection range (3XX).
- *
- * @param code HTTP Status code
- * @returns True if the code is in the "redirection" range.
- */
-declare const isRedirection: (code: StatusCode) => boolean;
-/**
- * Checks if the given status code is in the client error range (4XX).
- *
- * @param code HTTP Status code
- * @returns True if the code is in the "client error" range.
- */
-declare const isClientError: (code: StatusCode) => boolean;
-/**
- * Checks if the given status code is in the server error range (5XX).
- *
- * @param code HTTP Status code
- * @returns True if the code is in the "server error" range.
- */
-declare const isServerError: (code: StatusCode) => boolean;
-/**
- * Searches the list of HTTP statuses for a matching textual name to the one
- * provided. If a match is found, then the numerical status code is returned,
- * otherwise `null`.
- *
- * Internally, the parameter and the status names are normalized by lower-casing
- * the strings and trimming space.
- *
- * @param status HTTP Status textual name
- * @returns The numerical status code, or null if not found
- */
-declare const getCodeForStatus: (status: string) => null | StatusCode;
-
-/**
- * Generates a ModelContextProtocol server from given routers.
- *
- * @template SV - A type that extends AnySchemaValidator.
- * @param {SV} schemaValidator - The schema validator.
- * @param {string | number} port - The port on which the server is running.
- * @param {ForklaunchRouter<SV>[]} routers - The routers to include in the server.
- * @returns {McpServer} - The generated ModelContextProtocol server.
- */
-declare function generateMcpServer<T extends Record<string, unknown> | undefined = Record<string, unknown> | undefined>(schemaValidator: ZodSchemaValidator, protocol: 'http' | 'https', host: string, port: number, version: `${number}.${number}.${number}`, application: ForklaunchRouter<ZodSchemaValidator>, appOptions?: ExpressLikeApplicationOptions<ZodSchemaValidator, SessionObject<ZodSchemaValidator>>['mcp'], options?: ConstructorParameters<typeof FastMCP<T>>[0], contentTypeMap?: Record<string, string>, authenticate?: (request: http.IncomingMessage) => Promise<Record<string, unknown> | undefined>): FastMCP<Record<string, unknown> | undefined>;
-
-/**
- * Middleware to create and add a request context.
- *
- * @template SV - A type that extends AnySchemaValidator.
- * @template Request - A type that extends ForklaunchRequest.
- * @template Response - A type that extends ForklaunchResponse.
- * @template NextFunction - A type that extends ForklaunchNextFunction.
- * @param {SV} schemaValidator - The schema validator.
- * @returns {Function} - Middleware function to create request context.
- */
-declare function createContext<SV extends AnySchemaValidator, P extends ParamsObject<SV>, ResBodyMap extends ResponsesObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, LocalsObj extends Record<string, unknown>, VersionedApi extends VersionSchema<SV, 'middleware'>, SessionSchema extends SessionObject<SV>>(schemaValidator: SV): ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, SessionSchema, unknown, unknown, ForklaunchNextFunction>;
-
-/**
- * Enhances the Express-like `send` method with additional logic for response handling and validation.
- *
- * This function intercepts the `send` method to provide custom behavior, including response validation
- * through the `parseResponse` middleware. If the response status is 404, it sends a "Not Found" message.
- * If the response validation fails, it sends a parsing error message. Otherwise, it calls the original `send`
- * method with the provided data.
- *
- * @template SV - The type of the schema validator used in the request.
- * @template P - The type of the parameters dictionary used in the request.
- * @template ResBodyMap - A record type mapping status codes to response body types.
- * @template ReqBody - The type of the request body.
- * @template ReqQuery - The type of the parsed query string.
- * @template ReqHeaders - The type of the request headers.
- * @template ResHeaders - The type of the response headers, extended from `ForklaunchResHeaders`.
- * @template LocalsObj - The type of the locals object in the response.
- *
- * @param {unknown} instance - The context (typically `this`) in which the original `send` method is called.
- * @param {ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders>} req - The request object, containing the schema validator and other request data.
- * @param {ForklaunchResponse<ResBodyMap, ForklaunchResHeaders & ResHeaders, LocalsObj>} res - The response object, including headers and body data.
- * @param {Function} originalSend - The original `send` method from the response object, to be called after custom logic.
- * @param {string | ArrayBuffer | ArrayBufferView | NodeJS.ReadableStream | null | undefined} data - The data to be sent as the response body.
- * @param {boolean} shouldEnrich - A flag indicating whether the response should be sent immediately.
- *
- * @returns {unknown} The return value of the original `send` method, typically the response itself.
- */
-declare function enrichExpressLikeSend<SV extends AnySchemaValidator, P extends ParamsDictionary, ResBodyMap extends Record<number, unknown>, ReqBody extends Record<string, unknown>, ReqQuery extends ParsedQs, ReqHeaders extends Record<string, string>, ResHeaders extends Record<string, unknown>, LocalsObj extends Record<string, unknown>, VersionedReqs extends VersionedRequests, SessionSchema extends Record<string, unknown>>(instance: unknown, req: ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, Extract<keyof VersionedReqs, string>, SessionSchema>, res: ForklaunchResponse<unknown, ResBodyMap, ForklaunchResHeaders & ResHeaders, LocalsObj, Extract<keyof VersionedReqs, string>>, originalOperation: ForklaunchStatusResponse<ForklaunchSendableData>['json'] | ForklaunchStatusResponse<ForklaunchSendableData>['jsonp'], originalSend: ForklaunchStatusResponse<ForklaunchSendableData>['send'], data: ForklaunchSendableData | File | Blob | AsyncGenerator<Record<string, unknown>> | null | undefined, shouldEnrich: boolean): void;
-
-declare const OPENAPI_DEFAULT_VERSION: unique symbol;
-/**
- * Generates a Swagger document from given routers.
- *
- * @template SV - A type that extends AnySchemaValidator.
- * @param {SV} schemaValidator - The schema validator.
- * @param {string | number} port - The port on which the server is running.
- * @param {ForklaunchRouter<SV>[]} routers - The routers to include in the Swagger document.
- * @returns {OpenAPIObject} - The generated Swagger document.
- */
-declare function generateOpenApiSpecs<SV extends AnySchemaValidator>(schemaValidator: SV, serverUrls: string[], serverDescriptions: string[], application: ForklaunchRouter<SV>, appOptions?: ExpressLikeApplicationOptions<SV, SessionObject<SV>>['openapi']): Record<string | symbol, OpenAPIObject>;
-
-/**
- * Discriminates the body type from the given contract details and returns information
- * necessary for parsing and validation.
- *
- * @template SV - Schema validator type.
- * @template Path - Route path type.
- * @template P - Params schema type.
- * @template ResBodyMap - Response body map type.
- * @template ReqBody - Request body type.
- * @template ReqQuery - Request query object type.
- * @template ReqHeaders - Request headers object type.
- * @template ResHeaders - Response headers object type.
- * @param contractDetails - The HTTP contract details.
- * @returns An object containing the content type, parser type, and schema.
- * @throws If no body-related information is found in the contract details.
- */
-declare function discriminateBody<SV extends AnySchemaValidator>(schemaValidator: SV, body: Body<SV> | undefined): {
-    contentType: string;
-    parserType: 'json' | 'text' | 'multipart' | 'urlEncoded' | 'file';
-    schema: SV['_ValidSchemaObject'];
-} | undefined;
-/**
- * Discriminates all response body types from the given contract details and returns
- * information necessary for parsing and validation for each status code.
- *
- * @template SV - Schema validator type.
- * @template Path - Route path type.
- * @template P - Params schema type.
- * @template ResBodyMap - Response body map type.
- * @template ReqQuery - Request query object type.
- * @template ReqHeaders - Request headers object type.
- * @template ResHeaders - Response headers object type.
- * @param contractDetails - The contract details containing response schemas.
- * @returns A record mapping status codes to content type, parser type, and schema info.
- */
-declare function discriminateResponseBodies<SV extends AnySchemaValidator>(schemaValidator: SV, responses: ResponsesObject<SV>): Record<number, {
-    contentType: string;
-    parserType: "json" | "text" | "serverSentEvent" | "file" | "multipart";
-    schema: SV["_ValidSchemaObject"];
-}>;
-
-type AuditEntry = {
-    timestamp: string;
-    userId: string | null;
-    tenantId: string | null;
-    route: string;
-    method: string;
-    bodyHash: string;
-    status: number;
-    duration: number;
-    redactedFields: string[];
-    eventType: 'http' | 'ws' | 'auth_failure' | 'rate_limit' | 'rbac_deny' | 'super_admin_bypass';
-};
-declare class AuditLogger {
-    _otel: OpenTelemetryCollector<MetricsDefinition>;
-    constructor(otel: OpenTelemetryCollector<MetricsDefinition>);
-    append(entry: AuditEntry): void;
-    static hashBody(body: string | Buffer | undefined | null): string;
-}
-
-declare const ATTR_API_NAME = "api.name";
-declare const ATTR_CORRELATION_ID = "correlation.id";
-declare const ATTR_APPLICATION_ID = "application_id";
-
-declare function evaluateTelemetryOptions(telemetryOptions: TelemetryOptions): {
-    enabled: {
-        metrics?: boolean;
-        tracing?: boolean;
-        logging?: boolean;
-    };
-    level: LevelWithSilentOrString;
-};
-
-declare function metricsDefinitions<T extends MetricsDefinition>(metrics: T): T;
-
-declare function recordMetric<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends ParsedQs, ResBodyMap extends Record<string, unknown>, ReqHeaders extends Record<string, string>, ResHeaders extends Record<string, unknown>, LocalsObj extends Record<string, unknown>, VersionedReqs extends VersionedRequests, SessionSchema extends Record<string, unknown>>(req: ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, Extract<keyof VersionedReqs, string>, SessionSchema>, res: ForklaunchResponse<unknown, ResBodyMap, ResHeaders, LocalsObj, Extract<keyof VersionedReqs, string>>): void;
-
-/**
- * Configuration for rate limiting with separate read/write limits.
- */
-type RateLimitConfig = {
-    /** Max requests per window for GET/HEAD/OPTIONS */
-    read: number;
-    /** Max requests per window for POST/PUT/PATCH/DELETE */
-    write: number;
-    /** Window duration in milliseconds */
-    windowMs: number;
-};
-/**
- * Result of a rate limit check.
- */
-type RateLimitResult = {
-    /** Whether the request is allowed */
-    allowed: boolean;
-    /** Number of remaining requests in the current window */
-    remaining: number;
-    /** Unix timestamp (ms) when the current window resets */
-    resetAt: number;
-};
-/**
- * Rate limiter backed by a TtlCache.
- *
- * Uses a sliding-window counter pattern: each unique key maps to a
- * {@link RateLimitCounter} stored in the cache with a TTL equal to the
- * configured window duration.
- */
-declare class RateLimiter {
-    private cache;
-    constructor(cache: TtlCache);
-    /**
-     * Check whether the given key is within its rate limit.
-     *
-     * The counter is read from the cache, incremented, and written back.
-     * If the cache is unreachable the limiter **fails open** (allows the
-     * request) so that a cache outage does not take down the service.
-     *
-     * @param key - The rate limit key (see {@link RateLimiter.buildKey}).
-     * @param limit - Maximum number of requests allowed in the window.
-     * @param windowMs - Window duration in milliseconds.
-     */
-    check(key: string, limit: number, windowMs: number): Promise<RateLimitResult>;
-    /**
-     * Build a rate limit key from request context parts.
-     *
-     * Format: `ratelimit:{tenantId}:{route}:{userId}:{operationType}`
-     *
-     * When `tenantId` or `userId` is `null`, the placeholder `"anon"` is used.
-     */
-    static buildKey(parts: {
-        tenantId: string | null;
-        route: string;
-        userId: string | null;
-        operationType: 'read' | 'write';
-    }): string;
-    /**
-     * Determine whether an HTTP method is a read or write operation.
-     *
-     * GET, HEAD, and OPTIONS are reads; everything else is a write.
-     */
-    static operationType(method: string): 'read' | 'write';
-}
-
-export { ATTR_API_NAME, ATTR_APPLICATION_ID, ATTR_CORRELATION_ID, type AuditEntry, AuditLogger, AuthMethods, AuthMethodsBase, BasicAuthMethods, Body, type ClusterConfig, type ConstrainedForklaunchRouter, ContractDetails, type ContractDetailsExpressLikeSchemaHandler, type ContractDetailsOrMiddlewareOrTypedHandler, DecodeResource, ExpressLikeApplicationOptions, type ExpressLikeRouter, ExpressLikeRouterOptions, ExpressLikeSchemaAuthMapper, ExpressLikeSchemaHandler, type ExpressLikeTypedHandler, type ExtractLiveTypeFn, type FetchFunction, ForklaunchExpressLikeApplication, ForklaunchExpressLikeRouter, ForklaunchNextFunction, ForklaunchRequest, ForklaunchResHeaders, ForklaunchResponse, type ForklaunchRoute, type ForklaunchRouter, ForklaunchSendableData, ForklaunchStatusResponse, HTTPStatuses, HeadersObject, HttpContractDetails, LiveSdkFunction, LiveTypeFunction, type LiveTypeRouteDefinition, type MapHandlerToLiveSdk, type MapToFetch, type MapToSdk, Method, MetricsDefinition, MiddlewareContractDetails, type MiddlewareOrMiddlewareWithTypedHandler, type NestableRouterBasedHandler, OPENAPI_DEFAULT_VERSION, OpenTelemetryCollector, ParamsDictionary, ParamsObject, type PathBasedHandler, PathMatch, type PathOrMiddlewareBasedHandler, PathParamHttpContractDetails, QueryObject, type RateLimitConfig, type RateLimitResult, RateLimiter, ResolvedSessionObject, ResponsesObject, type RouterMap, type RoutingStrategy, SchemaAuthMethods, type SdkHandler, type SdkHandlerObject, type SdkRouter, SessionObject, type StatusCode, TelemetryOptions, type ToFetchMap, type TypedHandler, type TypedMiddlewareDefinition, type TypedNestableMiddlewareDefinition, VersionSchema, VersionedRequests, createContext, createHmacToken, delete_, discriminateAuthMethod, discriminateBody, discriminateResponseBodies, enrichExpressLikeSend, evaluateTelemetryOptions, extractRouteHandlers, generateHmacAuthHeaders, generateMcpServer, generateOpenApiSpecs, get, getCachedJwks, getCodeForStatus, head, isClientError, isForklaunchRequest, isForklaunchRouter, isInformational, isPortBound, isRedirection, isServerError, isSuccessful, isValidStatusCode, metricsDefinitions, middleware, options, patch, post, put, recordMetric, trace, typedAuthHandler, typedHandler };
+export type { ParsedQs } from 'qs';
+export * from './application/expressLikeApplication';
+export * from './cluster/cluster.types';
+export * from './cluster/isPortBound';
+export * from './createHmacToken';
+export * from './generateHmacAuthHeaders';
+export * from './discriminateAuthMethod';
+export * from './guards/isForklaunchRequest';
+export * from './guards/isForklaunchRouter';
+export * from './handlers/delete';
+export * from './handlers/get';
+export * from './handlers/head';
+export * from './handlers/middleware';
+export * from './handlers/options';
+export * from './handlers/patch';
+export * from './handlers/post';
+export * from './handlers/put';
+export * from './handlers/trace';
+export * from './handlers/typedAuthHandler';
+export * from './handlers/typedHandler';
+export * from './httpStatusCodes';
+export * from './interfaces/expressLikeRouter.interface';
+export * from './mcpGenerator/mcpGenerator';
+export * from './middleware/request/createContext.middleware';
+export * from './middleware/response/enrichExpressLikeSend.middleware';
+export * from './openApiV3Generator/openApiV3Generator';
+export * from './router/discriminateBody';
+export * from './router/expressLikeRouter';
+export * from './telemetry/auditLogger';
+export * from './telemetry/constants';
+export * from './telemetry/evaluateTelemetryOptions';
+export * from './telemetry/metricsDefinition';
+export * from './telemetry/openTelemetryCollector';
+export * from './telemetry/pinoLogger';
+export * from './telemetry/recordMetric';
+export * from './types/apiDefinition.types';
+export * from './types/contractDetails.types';
+export * from './types/docsConfiguration.types';
+export * from './types/expressLikeOptions';
+export * from './types/expressLikeRouter.types';
+export * from './types/openTelemetryCollector.types';
+export * from './types/router.types';
+export * from './rateLimit/index';
+export * from './types/sdk.types';
+export { MapToSdk } from './types/sdk.types';
+export * from './types/typedHandler.types';
+//# sourceMappingURL=index.d.ts.map