@forklaunch/core 0.11.5 → 0.11.7

package/lib/http/index.d.mts

@@ -1,6 +1,6 @@
 import { ParsedQs } from 'qs';
 export { ParsedQs } from 'qs';
-import { UnionToIntersection, StringWithoutSlash, ExclusiveRecord, Prettify, SanitizePathSlashes, MakePropertyOptionalIfChildrenOptional, PrettyCamelCase, TypeSafeFunction, EmptyObject } from '@forklaunch/common';
+import { UnionToIntersection, StringWithoutSlash, Prettify, SanitizePathSlashes, MakePropertyOptionalIfChildrenOptional, PrettyCamelCase, TypeSafeFunction, EmptyObject } from '@forklaunch/common';
 import { AnySchemaValidator, UnboxedObjectSchema, IdiomaticSchema, Schema } from '@forklaunch/validator';
 import { CorsOptions } from 'cors';
 import { Counter, Gauge, Histogram, UpDownCounter, ObservableCounter, ObservableGauge, ObservableUpDownCounter, Span } from '@opentelemetry/api';
@@ -148,7 +148,7 @@ type TypedResponseBody<SV extends AnySchemaValidator> = {
 } | {
     [K in keyof (ExclusiveSchemaCatchall<SV> & ExclusiveResponseBodyBase<SV>)]?: K extends keyof UnknownResponseBody<SV> ? UnknownResponseBody<SV>[K] : undefined;
 };
-type ResponseBody<SV extends AnySchemaValidator> = TypedResponseBody<SV> | (ExclusiveResponseBodyBase<SV> & SV['_ValidSchemaObject']) | (ExclusiveResponseBodyBase<SV> & UnboxedObjectSchema<SV>) | (ExclusiveResponseBodyBase<SV> & SV['string']) | (ExclusiveResponseBodyBase<SV> & SV['number']) | (ExclusiveResponseBodyBase<SV> & SV['boolean']) | (ExclusiveResponseBodyBase<SV> & SV['array']) | (ExclusiveResponseBodyBase<SV> & SV['file']);
+type ResponseBody<SV extends AnySchemaValidator> = TypedResponseBody<SV> | (ExclusiveResponseBodyBase<SV> & SV['_ValidSchemaObject']) | (ExclusiveResponseBodyBase<SV> & UnboxedObjectSchema<SV>) | (ExclusiveResponseBodyBase<SV> & SV['string']) | (ExclusiveResponseBodyBase<SV> & SV['number']) | (ExclusiveResponseBodyBase<SV> & SV['boolean']) | (ExclusiveResponseBodyBase<SV> & SV['date']) | (ExclusiveResponseBodyBase<SV> & SV['array']) | (ExclusiveResponseBodyBase<SV> & SV['file']);
 /**
  * Type representing the responses object in a request.
  *
@@ -207,8 +207,24 @@ type UnknownResponseBody<SV extends AnySchemaValidator> = {
     contentType?: string;
     schema: BodyObject<SV> | SV['_ValidSchemaObject'] | SV['_SchemaCatchall'];
 };
+type ExclusiveRequestBodyBase<SV extends AnySchemaValidator> = {
+    [K in keyof UnionToIntersection<TypedBody<SV>>]?: undefined;
+};
+type TypedRequestBody<SV extends AnySchemaValidator> = {
+    [K in keyof (ExclusiveSchemaCatchall<SV> & ExclusiveRequestBodyBase<SV>)]?: K extends keyof TextBody<SV> ? TextBody<SV>[K] : undefined;
+} | {
+    [K in keyof (ExclusiveSchemaCatchall<SV> & ExclusiveRequestBodyBase<SV>)]?: K extends keyof JsonBody<SV> ? JsonBody<SV>[K] : undefined;
+} | {
+    [K in keyof (ExclusiveSchemaCatchall<SV> & ExclusiveRequestBodyBase<SV>)]?: K extends keyof FileBody<SV> ? FileBody<SV>[K] : undefined;
+} | {
+    [K in keyof (ExclusiveSchemaCatchall<SV> & ExclusiveRequestBodyBase<SV>)]?: K extends keyof MultipartForm<SV> ? MultipartForm<SV>[K] : undefined;
+} | {
+    [K in keyof (ExclusiveSchemaCatchall<SV> & ExclusiveRequestBodyBase<SV>)]?: K extends keyof UrlEncodedForm<SV> ? UrlEncodedForm<SV>[K] : undefined;
+} | {
+    [K in keyof (ExclusiveSchemaCatchall<SV> & ExclusiveRequestBodyBase<SV>)]?: K extends keyof UnknownBody<SV> ? UnknownBody<SV>[K] : undefined;
+};
 type TypedBody<SV extends AnySchemaValidator> = JsonBody<SV> | TextBody<SV> | FileBody<SV> | MultipartForm<SV> | UrlEncodedForm<SV> | UnknownBody<SV>;
-type Body<SV extends AnySchemaValidator> = TypedBody<SV> | BodyObject<SV> | SV['_ValidSchemaObject'] | SV['_SchemaCatchall'];
+type Body<SV extends AnySchemaValidator> = TypedRequestBody<SV> | (ExclusiveRequestBodyBase<SV> & SV['_ValidSchemaObject']) | (ExclusiveRequestBodyBase<SV> & UnboxedObjectSchema<SV>) | (ExclusiveRequestBodyBase<SV> & SV['string']) | (ExclusiveRequestBodyBase<SV> & SV['number']) | (ExclusiveRequestBodyBase<SV> & SV['boolean']) | (ExclusiveRequestBodyBase<SV> & SV['date']) | (ExclusiveRequestBodyBase<SV> & SV['array']) | (ExclusiveRequestBodyBase<SV> & SV['file']);
 type BasicAuthMethods = {
     readonly basic: {
         readonly login: (username: string, password: string) => boolean;
@@ -237,15 +253,15 @@ type RoleSet = {
 /**
  * Type representing the authentication methods.
  */
-type SchemaAuthMethods<SV extends AnySchemaValidator, ParamsSchema extends ParamsObject<SV>, ReqBody extends Body<SV>, QuerySchema extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, BaseRequest> = AuthMethodsBase & (({
-    readonly mapPermissions: ExpressLikeSchemaAuthMapper<SV, ParamsSchema, ReqBody, QuerySchema, ReqHeaders, BaseRequest>;
+type SchemaAuthMethods<SV extends AnySchemaValidator, ParamsSchema extends ParamsObject<SV>, ReqBody extends Body<SV>, QuerySchema extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, VersionedApi extends VersionSchema<SV, Method>, BaseRequest> = AuthMethodsBase & (({
+    readonly mapPermissions: ExpressLikeSchemaAuthMapper<SV, ParamsSchema, ReqBody, QuerySchema, ReqHeaders, VersionedApi, BaseRequest>;
 } & PermissionSet) | ({
-    readonly mapRoles: ExpressLikeSchemaAuthMapper<SV, ParamsSchema, ReqBody, QuerySchema, ReqHeaders, BaseRequest>;
+    readonly mapRoles: ExpressLikeSchemaAuthMapper<SV, ParamsSchema, ReqBody, QuerySchema, ReqHeaders, VersionedApi, BaseRequest>;
 } & RoleSet));
-type AuthMethods<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends ParsedQs, ReqHeaders extends Record<string, string>, BaseRequest> = AuthMethodsBase & (({
-    readonly mapPermissions: ExpressLikeAuthMapper<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>;
+type AuthMethods<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends Record<string, unknown>, ReqHeaders extends Record<string, string>, VersionedReqs extends VersionedRequests, BaseRequest> = AuthMethodsBase & (({
+    readonly mapPermissions: ExpressLikeAuthMapper<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedReqs, BaseRequest>;
 } & PermissionSet) | ({
-    readonly mapRoles: ExpressLikeAuthMapper<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>;
+    readonly mapRoles: ExpressLikeAuthMapper<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedReqs, BaseRequest>;
 } & RoleSet));
 /**
  * Type representing a mapped schema.
@@ -283,11 +299,9 @@ type ResponseCompiledSchema = {
     headers?: unknown;
     responses: Record<number, unknown>;
 };
-type BasePathParamHttpContractDetails<SV extends AnySchemaValidator, Name extends string = string, Path extends `/${string}` = `/${string}`, ParamsSchema extends ParamsObject<SV> = ParamsObject<SV>, ResponseSchemas extends ResponsesObject<SV> = ResponsesObject<SV>, QuerySchema extends QueryObject<SV> = QueryObject<SV>, ReqHeaders extends HeadersObject<SV> = HeadersObject<SV>, ResHeaders extends HeadersObject<SV> = HeadersObject<SV>> = {
-    /** Name of the contract */
-    readonly name: StringWithoutSlash<Name>;
-    /** Summary of the contract */
-    readonly summary: string;
+type BasePathParamHttpContractDetailsIO<SV extends AnySchemaValidator, BodySchema extends Body<SV> | undefined = Body<SV>, ResponseSchemas extends ResponsesObject<SV> = ResponsesObject<SV>, QuerySchema extends QueryObject<SV> | undefined = QueryObject<SV>, ReqHeaders extends HeadersObject<SV> | undefined = HeadersObject<SV>, ResHeaders extends HeadersObject<SV> | undefined = HeadersObject<SV>> = {
+    /** Optional body for the contract */
+    readonly body?: BodySchema;
     /** Response schemas for the contract */
     readonly responses: ResponseSchemas;
     /** Optional request headers for the contract */
@@ -296,6 +310,15 @@ type BasePathParamHttpContractDetails<SV extends AnySchemaValidator, Name extend
     readonly responseHeaders?: ResHeaders;
     /** Optional query schemas for the contract */
     readonly query?: QuerySchema;
+};
+type VersionedBasePathParamHttpContractDetailsIO<SV extends AnySchemaValidator, VersionedApi extends VersionSchema<SV, PathParamMethod>> = {
+    readonly versions: VersionedApi;
+};
+type BasePathParamHttpContractDetails<SV extends AnySchemaValidator, Name extends string = string, Path extends `/${string}` = `/${string}`, ParamsSchema extends ParamsObject<SV> = ParamsObject<SV>> = {
+    /** Name of the contract */
+    readonly name: StringWithoutSlash<Name>;
+    /** Summary of the contract */
+    readonly summary: string;
     /** Options for the contract */
     readonly options?: {
         readonly requestValidation: 'error' | 'warning' | 'none';
@@ -318,10 +341,20 @@ type BasePathParamHttpContractDetails<SV extends AnySchemaValidator, Name extend
  * @template ResponseSchemas - A type for response schemas, defaulting to ResponsesObject.
  * @template QuerySchema - A type for query schemas, defaulting to QueryObject.
  */
-type PathParamHttpContractDetails<SV extends AnySchemaValidator, Name extends string = string, Path extends `/${string}` = `/${string}`, ParamsSchema extends ParamsObject<SV> = ParamsObject<SV>, ResponseSchemas extends ResponsesObject<SV> = ResponsesObject<SV>, BodySchema extends Body<SV> = Body<SV>, QuerySchema extends QueryObject<SV> = QueryObject<SV>, ReqHeaders extends HeadersObject<SV> = HeadersObject<SV>, ResHeaders extends HeadersObject<SV> = HeadersObject<SV>, BaseRequest = unknown, Auth extends SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, BaseRequest> = SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, BaseRequest>> = BasePathParamHttpContractDetails<SV, Name, Path, ParamsSchema, ResponseSchemas, QuerySchema, ReqHeaders, ResHeaders> & {
+type PathParamHttpContractDetails<SV extends AnySchemaValidator, Name extends string = string, Path extends `/${string}` = `/${string}`, ParamsSchema extends ParamsObject<SV> = ParamsObject<SV>, ResponseSchemas extends ResponsesObject<SV> = ResponsesObject<SV>, BodySchema extends Body<SV> = Body<SV>, QuerySchema extends QueryObject<SV> = QueryObject<SV>, ReqHeaders extends HeadersObject<SV> = HeadersObject<SV>, ResHeaders extends HeadersObject<SV> = HeadersObject<SV>, VersionedApi extends VersionSchema<SV, Method> = VersionSchema<SV, PathParamMethod>, BaseRequest = unknown, Auth extends SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, VersionedApi, BaseRequest> = SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, VersionedApi, BaseRequest>> = BasePathParamHttpContractDetails<SV, Name, Path, ParamsSchema> & ((BasePathParamHttpContractDetailsIO<SV, never, ResponseSchemas, QuerySchema, ReqHeaders, ResHeaders> & {
+    readonly versions?: never;
+}) | (VersionedBasePathParamHttpContractDetailsIO<SV, VersionedApi> & {
+    readonly query?: never;
+    readonly requestHeaders?: never;
+    readonly responseHeaders?: never;
+    readonly responses?: never;
+})) & {
     /** Optional authentication details for the contract */
     readonly auth?: Auth;
 };
+type VersionedHttpContractDetailsIO<SV extends AnySchemaValidator, VersionedApi extends VersionSchema<SV, HttpMethod>> = {
+    readonly versions: VersionedApi;
+};
 /**
  * Interface representing HTTP contract details.
  *
@@ -331,28 +364,15 @@ type PathParamHttpContractDetails<SV extends AnySchemaValidator, Name extends st
  * @template BodySchema - A type for the body schema, defaulting to Body.
  * @template QuerySchema - A type for query schemas, defaulting to QueryObject.
  */
-type HttpContractDetails<SV extends AnySchemaValidator, Name extends string = string, Path extends `/${string}` = `/${string}`, ParamsSchema extends ParamsObject<SV> = ParamsObject<SV>, ResponseSchemas extends ResponsesObject<SV> = ResponsesObject<SV>, BodySchema extends Body<SV> = Body<SV>, QuerySchema extends QueryObject<SV> = QueryObject<SV>, ReqHeaders extends HeadersObject<SV> = HeadersObject<SV>, ResHeaders extends HeadersObject<SV> = HeadersObject<SV>, BaseRequest = unknown, Auth extends SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, BaseRequest> = SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, BaseRequest>> = BasePathParamHttpContractDetails<SV, Name, Path, ParamsSchema, ResponseSchemas, QuerySchema, ReqHeaders, ResHeaders> & (BodySchema extends SV['_SchemaCatchall'] ? {
-    /** Required body schema for body-based methods for the contract */
-    readonly body: BodySchema;
-} : BodySchema extends JsonBody<SV> ? {
-    /** Required body schema for body-based methods for the contract */
-    readonly body: ExclusiveRecord<BodySchema, TypedBody<SV>>;
-} : BodySchema extends TextBody<SV> ? {
-    /** Required body schema for body-based methods for the contract */
-    readonly body: ExclusiveRecord<BodySchema, TypedBody<SV>>;
-} : BodySchema extends MultipartForm<SV> ? {
-    /** Required body schema for body-based methods for the contract */
-    readonly body: ExclusiveRecord<BodySchema, TypedBody<SV>>;
-} : BodySchema extends UrlEncodedForm<SV> ? {
-    /** Required body schema for body-based methods for the contract */
-    readonly body: ExclusiveRecord<BodySchema, TypedBody<SV>>;
-} : BodySchema extends FileBody<SV> ? {
-    /** Required body schema for body-based methods for the contract */
-    readonly body: ExclusiveRecord<BodySchema, TypedBody<SV>>;
-} : {
-    /** Required body schema for body-based methods for the contract */
-    readonly body: BodySchema;
-}) & {
+type HttpContractDetails<SV extends AnySchemaValidator, Name extends string = string, Path extends `/${string}` = `/${string}`, ParamsSchema extends ParamsObject<SV> = ParamsObject<SV>, ResponseSchemas extends ResponsesObject<SV> = ResponsesObject<SV>, BodySchema extends Body<SV> = Body<SV>, QuerySchema extends QueryObject<SV> = QueryObject<SV>, ReqHeaders extends HeadersObject<SV> = HeadersObject<SV>, ResHeaders extends HeadersObject<SV> = HeadersObject<SV>, VersionedApi extends VersionSchema<SV, Method> = VersionSchema<SV, HttpMethod>, BaseRequest = unknown, Auth extends SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, VersionedApi, BaseRequest> = SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, VersionedApi, BaseRequest>> = BasePathParamHttpContractDetails<SV, Name, Path, ParamsSchema> & ((BasePathParamHttpContractDetailsIO<SV, BodySchema, ResponseSchemas, QuerySchema, ReqHeaders, ResHeaders> & {
+    readonly versions?: never;
+}) | (VersionedHttpContractDetailsIO<SV, VersionedApi> & {
+    readonly query?: never;
+    readonly requestHeaders?: never;
+    readonly responseHeaders?: never;
+    readonly body?: never;
+    readonly responses?: never;
+})) & {
     readonly auth?: Auth;
 };
 /**
@@ -365,11 +385,12 @@ type HttpContractDetails<SV extends AnySchemaValidator, Name extends string = st
  * @template ReqHeaders - A type for request headers, defaulting to HeadersObject.
  * @template ResHeaders - A type for response headers, defaulting to HeadersObject.
  */
-type MiddlewareContractDetails<SV extends AnySchemaValidator, Name extends string = string, Path extends `/${string}` = `/${string}`, ParamsSchema extends ParamsObject<SV> = ParamsObject<SV>, ResponseSchemas extends ResponsesObject<SV> = ResponsesObject<SV>, BodySchema extends Body<SV> = Body<SV>, QuerySchema extends QueryObject<SV> = QueryObject<SV>, ReqHeaders extends HeadersObject<SV> = HeadersObject<SV>, ResHeaders extends HeadersObject<SV> = HeadersObject<SV>, BaseRequest = unknown, Auth extends SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, BaseRequest> = SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, BaseRequest>> = Omit<Partial<HttpContractDetails<SV, Name, Path, ParamsSchema, ResponseSchemas, BodySchema, QuerySchema, ReqHeaders, ResHeaders, BaseRequest, Auth>>, 'responses'>;
+type MiddlewareContractDetails<SV extends AnySchemaValidator, Name extends string = string, Path extends `/${string}` = `/${string}`, ParamsSchema extends ParamsObject<SV> = ParamsObject<SV>, ResponseSchemas extends ResponsesObject<SV> = ResponsesObject<SV>, BodySchema extends Body<SV> = Body<SV>, QuerySchema extends QueryObject<SV> = QueryObject<SV>, ReqHeaders extends HeadersObject<SV> = HeadersObject<SV>, ResHeaders extends HeadersObject<SV> = HeadersObject<SV>, VersionedApi extends VersionSchema<SV, Method> = VersionSchema<SV, 'middleware'>, BaseRequest = unknown, Auth extends SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, VersionedApi, BaseRequest> = SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, VersionedApi, BaseRequest>> = Omit<Partial<HttpContractDetails<SV, Name, Path, ParamsSchema, ResponseSchemas, BodySchema, QuerySchema, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth>>, 'responses'>;
+type VersionSchema<SV extends AnySchemaValidator, ContractMethod extends Method> = Record<string, BasePathParamHttpContractDetailsIO<SV, ContractMethod extends PathParamMethod ? never : Body<SV>, ResponsesObject<SV>, QueryObject<SV>, HeadersObject<SV>, HeadersObject<SV>>>;
 /**
  * Utility for different Contract Detail types
  */
-type ContractDetails<SV extends AnySchemaValidator, Name extends string, ContractMethod extends Method, Path extends `/${string}`, ParamsSchema extends ParamsObject<SV>, ResponseSchemas extends ResponsesObject<SV>, BodySchema extends Body<SV>, QuerySchema extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, BaseRequest, Auth extends SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, BaseRequest>> = ContractMethod extends PathParamMethod ? PathParamHttpContractDetails<SV, Name, Path, ParamsSchema, ResponseSchemas, BodySchema, QuerySchema, ReqHeaders, ResHeaders, BaseRequest, Auth> : ContractMethod extends HttpMethod ? HttpContractDetails<SV, Name, Path, ParamsSchema, ResponseSchemas, BodySchema, QuerySchema, ReqHeaders, ResHeaders, BaseRequest, Auth> : ContractMethod extends 'middleware' ? MiddlewareContractDetails<SV, Name, Path, ParamsSchema, ResponseSchemas, BodySchema, QuerySchema, ReqHeaders, ResHeaders, BaseRequest, Auth> : never;
+type ContractDetails<SV extends AnySchemaValidator, Name extends string, ContractMethod extends Method, Path extends `/${string}`, ParamsSchema extends ParamsObject<SV>, ResponseSchemas extends ResponsesObject<SV>, BodySchema extends Body<SV>, QuerySchema extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, ResHeaders extends HeadersObject<SV>, VersionedApi extends VersionSchema<SV, ContractMethod>, BaseRequest, Auth extends SchemaAuthMethods<SV, ParamsSchema, BodySchema, QuerySchema, ReqHeaders, VersionedApi, BaseRequest>> = ContractMethod extends PathParamMethod ? PathParamHttpContractDetails<SV, Name, Path, ParamsSchema, ResponseSchemas, BodySchema, QuerySchema, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth> : ContractMethod extends HttpMethod ? HttpContractDetails<SV, Name, Path, ParamsSchema, ResponseSchemas, BodySchema, QuerySchema, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth> : ContractMethod extends 'middleware' ? MiddlewareContractDetails<SV, Name, Path, ParamsSchema, ResponseSchemas, BodySchema, QuerySchema, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, Auth> : never;
 
 /**
  * Interface representing the context of a request.
@@ -409,9 +430,11 @@ interface ForklaunchBaseRequest<P extends ParamsDictionary, ReqBody extends Reco
  * @template ReqQuery - A type for the request query, defaulting to ParsedQs.
  * @template Headers - A type for the request headers, defaulting to IncomingHttpHeaders.
  */
-interface ForklaunchRequest<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends ParsedQs, ReqHeaders extends Record<string, string>> {
+interface ForklaunchRequest<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends Record<string, unknown>, ReqHeaders extends Record<string, unknown>, Version extends string> {
     /** Context of the request */
     context: Prettify<RequestContext>;
+    /** API Version of the request */
+    version: Version;
     /** Request parameters */
     params: P;
     /** Request headers */
@@ -429,11 +452,15 @@ interface ForklaunchRequest<SV extends AnySchemaValidator, P extends ParamsDicti
     /** Request path */
     path: string;
     /** Request schema, compiled */
-    requestSchema: unknown;
+    requestSchema: unknown | Record<string, unknown>;
     /** Original path */
     originalPath: string;
     /** OpenTelemetry Collector */
     openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
+    /** Session */
+    session: JWTPayload;
+    /** Parsed versions */
+    _parsedVersions: string[] | number;
 }
 /**
  * Represents the types of data that can be sent in a response.
@@ -486,7 +513,7 @@ type ToNumber<T extends string | number | symbol> = T extends number ? T : T ext
  * @template ResBodyMap - A type for the response body, defaulting to common status code responses.
  * @template StatusCode - A type for the status code, defaulting to number.
  */
-interface ForklaunchResponse<BaseResponse, ResBodyMap extends Record<number, unknown>, ResHeaders extends Record<string, string>, LocalsObj extends Record<string, unknown>> {
+interface ForklaunchResponse<BaseResponse, ResBodyMap extends Record<number, unknown>, ResHeaders extends Record<string, unknown>, LocalsObj extends Record<string, unknown>, Version extends string> {
     /** Data of the response body */
     bodyData: unknown;
     /** Status code of the response */
@@ -556,32 +583,52 @@ interface ForklaunchResponse<BaseResponse, ResBodyMap extends Record<number, unk
     /** Cors */
     cors: boolean;
     /** Response schema, compiled */
-    responseSchemas: ResponseCompiledSchema;
+    responseSchemas: ResponseCompiledSchema | Record<string, ResponseCompiledSchema>;
     /** Whether the metric has been recorded */
     metricRecorded: boolean;
     /** Whether the response has been sent */
     sent: boolean;
+    /** Versioned responses */
+    version: Version;
 }
 /**
  * Type representing the next function in a middleware.
  * @param {unknown} [err] - Optional error parameter.
  */
 type ForklaunchNextFunction = (err?: unknown) => void;
+type VersionedRequests = Record<string, {
+    requestHeaders?: Record<string, unknown>;
+    body?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+}>;
+type ResolvedForklaunchRequestBase<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends Record<string, unknown>, ReqHeaders extends Record<string, unknown>, Version extends string, BaseRequest> = unknown extends BaseRequest ? ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, Version> : Omit<BaseRequest, keyof ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, Version>> & ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, Version>;
 /**
  * Type representing the resolved forklaunch request from a base request type.
  * @template SV - A type that extends AnySchemaValidator.
  * @template P - A type for request parameters, defaulting to ParamsDictionary.
  * @template ReqBody - A type for the request body, defaulting to Record<string, unknown>.
  * @template ReqQuery - A type for the request query, defaulting to ParsedQs.
- * @template ReqHeaders - A type for the request headers, defaulting to Record<string, string>.
+ * @template ReqHeaders - A type for the request headers, defaulting to Record<string, unknown>.
  * @template BaseRequest - A type for the base request.
  */
-type ResolvedForklaunchRequest<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends ParsedQs, ReqHeaders extends Record<string, string>, BaseRequest> = unknown extends BaseRequest ? ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders> : {
-    [key in keyof BaseRequest]: key extends keyof ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders> ? ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders>[key] : key extends keyof BaseRequest ? BaseRequest[key] : never;
-};
+type ResolvedForklaunchRequest<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends Record<string, unknown>, ReqHeaders extends Record<string, string>, VersionedReqs extends VersionedRequests, BaseRequest> = VersionedRequests extends VersionedReqs ? ResolvedForklaunchRequestBase<SV, P, ReqBody, ReqQuery, ReqHeaders, never, BaseRequest> : {
+    [K in keyof VersionedReqs]: ResolvedForklaunchRequestBase<SV, P, VersionedReqs[K]['body'] extends Record<string, unknown> ? VersionedReqs[K]['body'] : Record<string, unknown>, VersionedReqs[K]['query'] extends Record<string, unknown> ? VersionedReqs[K]['query'] : ParsedQs, VersionedReqs[K]['requestHeaders'] extends Record<string, unknown> ? VersionedReqs[K]['requestHeaders'] : Record<string, string>, K extends string ? K : never, BaseRequest>;
+}[keyof VersionedReqs];
 type ResolvedForklaunchAuthRequest<P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends ParsedQs, ReqHeaders extends Record<string, string>, BaseRequest> = unknown extends BaseRequest ? ForklaunchBaseRequest<P, ReqBody, ReqQuery, ReqHeaders> : {
     [key in keyof BaseRequest]: key extends keyof ForklaunchBaseRequest<P, ReqBody, ReqQuery, ReqHeaders> ? ForklaunchBaseRequest<P, ReqBody, ReqQuery, ReqHeaders>[key] : key extends keyof BaseRequest ? BaseRequest[key] : never;
 };
+type VersionedResponses = Record<string, {
+    responseHeaders?: Record<string, unknown>;
+    responses: Record<number, unknown>;
+}>;
+type ResolvedForklaunchResponseBase<ResBodyMap extends Record<number, unknown>, ResHeaders extends Record<string, unknown>, LocalsObj extends Record<string, unknown>, Version extends string, BaseResponse> = unknown extends BaseResponse ? ForklaunchResponse<BaseResponse, ResBodyMap, ResHeaders, LocalsObj, Version> : (string extends Version ? unknown : {
+    version?: Version;
+}) & {
+    [K in keyof BaseResponse | keyof ForklaunchResponse<BaseResponse, ResBodyMap, ResHeaders, LocalsObj, Version>]: K extends keyof ForklaunchResponse<BaseResponse, ResBodyMap, ResHeaders, LocalsObj, Version> ? ForklaunchResponse<BaseResponse, ResBodyMap, ResHeaders, LocalsObj, Version>[K] : K extends keyof BaseResponse ? BaseResponse[K] : never;
+};
+type ResolvedForklaunchResponse<ResBodyMap extends Record<number, unknown>, ResHeaders extends Record<string, string>, LocalsObj extends Record<string, unknown>, VersionedResps extends VersionedResponses, BaseResponse> = VersionedResponses extends VersionedResps ? ResolvedForklaunchResponseBase<ResBodyMap, ResHeaders, LocalsObj, never, BaseResponse> : {
+    [K in keyof VersionedResps]: ResolvedForklaunchResponseBase<VersionedResps[K]['responses'], VersionedResps[K]['responseHeaders'] extends Record<string, unknown> ? VersionedResps[K]['responseHeaders'] : Record<string, string>, LocalsObj, K extends string ? K : never, BaseResponse>;
+}[keyof VersionedResps];
 /**
  * Represents a middleware handler with schema validation.
  *
@@ -593,10 +640,8 @@ type ResolvedForklaunchAuthRequest<P extends ParamsDictionary, ReqBody extends R
  * @template LocalsObj - A type for local variables, defaulting to an empty object.
  * @template StatusCode - A type for the status code, defaulting to number.
  */
-interface ExpressLikeHandler<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, string>, LocalsObj extends Record<string, unknown>, BaseRequest, BaseResponse, NextFunction> {
-    (req: ResolvedForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>, res: unknown extends BaseResponse ? ForklaunchResponse<BaseResponse, ResBodyMap, ResHeaders, LocalsObj> : {
-        [key in keyof BaseResponse]: key extends keyof ForklaunchResponse<BaseResponse, ResBodyMap, ResHeaders, LocalsObj> ? ForklaunchResponse<BaseResponse, ResBodyMap, ResHeaders, LocalsObj>[key] : key extends keyof BaseResponse ? BaseResponse[key] : never;
-    }, next: NextFunction): unknown;
+interface ExpressLikeHandler<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, string>, LocalsObj extends Record<string, unknown>, VersionedReqs extends VersionedRequests, VersionedResps extends VersionedResponses, BaseRequest, BaseResponse, NextFunction> {
+    (req: ResolvedForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedReqs, BaseRequest>, res: ResolvedForklaunchResponse<ResBodyMap, ResHeaders, LocalsObj, VersionedResps, BaseResponse>, next: NextFunction): unknown;
 }
 type MapParamsSchema<SV extends AnySchemaValidator, P extends ParamsObject<SV>> = MapSchema<SV, P> extends infer Params ? unknown extends Params ? ParamsDictionary : Params : ParamsDictionary;
 type ExtractContentType<SV extends AnySchemaValidator, T extends ResponseBody<SV> | unknown> = T extends {
@@ -611,6 +656,22 @@ type MapReqBodySchema<SV extends AnySchemaValidator, ReqBody extends Body<SV>> =
 type MapReqQuerySchema<SV extends AnySchemaValidator, ReqQuery extends QueryObject<SV>> = MapSchema<SV, ReqQuery> extends infer Query ? unknown extends Query ? ParsedQs : Query : ParsedQs;
 type MapReqHeadersSchema<SV extends AnySchemaValidator, ReqHeaders extends HeadersObject<SV>> = MapSchema<SV, ReqHeaders> extends infer RequestHeaders ? unknown extends RequestHeaders ? Record<string, string> : RequestHeaders : Record<string, string>;
 type MapResHeadersSchema<SV extends AnySchemaValidator, ResHeaders extends HeadersObject<SV>> = MapSchema<SV, ResHeaders> extends infer ResponseHeaders ? unknown extends ResponseHeaders ? ForklaunchResHeaders : ResponseHeaders : ForklaunchResHeaders;
+type MapVersionedReqsSchema<SV extends AnySchemaValidator, VersionedReqs extends VersionSchema<SV, Method>> = {
+    [K in keyof VersionedReqs]: (VersionedReqs[K]['requestHeaders'] extends HeadersObject<SV> ? {
+        requestHeaders: MapReqHeadersSchema<SV, VersionedReqs[K]['requestHeaders']>;
+    } : unknown) & (VersionedReqs[K]['body'] extends Body<SV> ? {
+        body: MapReqBodySchema<SV, VersionedReqs[K]['body']>;
+    } : unknown) & (VersionedReqs[K]['query'] extends QueryObject<SV> ? {
+        query: MapReqQuerySchema<SV, VersionedReqs[K]['query']>;
+    } : unknown);
+} extends infer MappedVersionedReqs ? MappedVersionedReqs extends VersionedRequests ? MappedVersionedReqs : VersionedRequests : VersionedRequests;
+type MapVersionedRespsSchema<SV extends AnySchemaValidator, VersionedResps extends VersionSchema<SV, Method>> = {
+    [K in keyof VersionedResps]: (VersionedResps[K]['responseHeaders'] extends HeadersObject<SV> ? {
+        responseHeaders: MapResHeadersSchema<SV, VersionedResps[K]['responseHeaders']>;
+    } : unknown) & (VersionedResps[K]['responses'] extends ResponsesObject<SV> ? {
+        responses: MapResBodyMapSchema<SV, VersionedResps[K]['responses']>;
+    } : unknown);
+} extends infer MappedVersionedResps ? MappedVersionedResps extends VersionedResponses ? MappedVersionedResps : VersionedResponses : VersionedResponses;
 /**
  * Represents a schema middleware handler with typed parameters, responses, body, and query.
  *
@@ -621,7 +682,7 @@ type MapResHeadersSchema<SV extends AnySchemaValidator, ResHeaders extends Heade
  * @template ReqQuery - A type for the request query, defaulting to QueryObject.
  * @template LocalsObj - A type for local variables, defaulting to an empty object.
  */
-type ExpressLikeSchemaHandler<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>, BaseRequest, BaseResponse, NextFunction> = ExpressLikeHandler<SV, MapParamsSchema<SV, P>, MapResBodyMapSchema<SV, ResBodyMap>, MapReqBodySchema<SV, ReqBody>, MapReqQuerySchema<SV, ReqQuery>, MapReqHeadersSchema<SV, ReqHeaders>, MapResHeadersSchema<SV, ResHeaders>, LocalsObj, BaseRequest, BaseResponse, NextFunction>;
+type ExpressLikeSchemaHandler<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, Method>, BaseRequest, BaseResponse, NextFunction> = ExpressLikeHandler<SV, MapParamsSchema<SV, P>, MapResBodyMapSchema<SV, ResBodyMap>, MapReqBodySchema<SV, ReqBody>, MapReqQuerySchema<SV, ReqQuery>, MapReqHeadersSchema<SV, ReqHeaders>, MapResHeadersSchema<SV, ResHeaders>, LocalsObj, MapVersionedReqsSchema<SV, VersionedApi>, MapVersionedRespsSchema<SV, VersionedApi>, BaseRequest, BaseResponse, NextFunction>;
 /**
  * Represents a function that maps an authenticated request with schema validation
  * to a set of authorization strings, with request properties automatically inferred from the schema.
@@ -635,17 +696,15 @@ type ExpressLikeSchemaHandler<SV extends AnySchemaValidator, P extends ParamsObj
  * @param {ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders>} req - The request object with schema validation.
  * @returns {Set<string> | Promise<Set<string>>} - A set of authorization strings or a promise that resolves to it.
  */
-type ExpressLikeSchemaAuthMapper<SV extends AnySchemaValidator, P extends ParamsObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, BaseRequest> = ExpressLikeAuthMapper<SV, P extends infer UnmappedParams ? UnmappedParams extends ParamsObject<SV> ? MapParamsSchema<SV, UnmappedParams> : never : never, ReqBody extends infer UnmappedReqBody ? UnmappedReqBody extends Body<SV> ? MapReqBodySchema<SV, UnmappedReqBody> : never : never, ReqQuery extends infer UnmappedReqQuery ? UnmappedReqQuery extends QueryObject<SV> ? MapReqQuerySchema<SV, UnmappedReqQuery> : never : never, ReqHeaders extends infer UnmappedReqHeaders ? UnmappedReqHeaders extends HeadersObject<SV> ? MapReqHeadersSchema<SV, UnmappedReqHeaders> : never : never, BaseRequest>;
-type ExpressLikeAuthMapper<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends ParsedQs, ReqHeaders extends Record<string, string>, BaseRequest> = (payload: JWTPayload, req?: ResolvedForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>) => Set<string> | Promise<Set<string>>;
+type ExpressLikeSchemaAuthMapper<SV extends AnySchemaValidator, P extends ParamsObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, VersionedReqs extends VersionSchema<SV, Method>, BaseRequest> = ExpressLikeAuthMapper<SV, P extends infer UnmappedParams ? UnmappedParams extends ParamsObject<SV> ? MapParamsSchema<SV, UnmappedParams> : never : never, ReqBody extends infer UnmappedReqBody ? UnmappedReqBody extends Body<SV> ? MapReqBodySchema<SV, UnmappedReqBody> : never : never, ReqQuery extends infer UnmappedReqQuery ? UnmappedReqQuery extends QueryObject<SV> ? MapReqQuerySchema<SV, UnmappedReqQuery> : never : never, ReqHeaders extends infer UnmappedReqHeaders ? UnmappedReqHeaders extends HeadersObject<SV> ? MapReqHeadersSchema<SV, UnmappedReqHeaders> : never : never, VersionedReqs extends infer UnmappedVersionedReqs ? UnmappedVersionedReqs extends VersionSchema<SV, Method> ? MapVersionedReqsSchema<SV, UnmappedVersionedReqs> : never : never, BaseRequest>;
+type ExpressLikeAuthMapper<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends Record<string, unknown>, ReqHeaders extends Record<string, string>, VersionedReqs extends VersionedRequests, BaseRequest> = (payload: JWTPayload, req?: ResolvedForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedReqs, BaseRequest>) => Set<string> | Promise<Set<string>>;
 type TokenPrefix<Auth extends AuthMethodsBase> = undefined extends Auth['tokenPrefix'] ? Auth extends BasicAuthMethods ? 'Basic ' : 'Bearer ' : `${Auth['tokenPrefix']} `;
 type AuthHeaders<Auth extends AuthMethodsBase> = undefined extends Auth['headerName'] ? {
     authorization: `${TokenPrefix<Auth>}${string}`;
 } : {
     [K in NonNullable<Auth['headerName']>]: `${TokenPrefix<Auth>}${string}`;
 };
-type LiveTypeFunctionRequestInit<SV extends AnySchemaValidator, P extends ParamsObject<SV>, ReqBody extends Body<SV>, ReqQuery extends QueryObject<SV>, ReqHeaders extends HeadersObject<SV>, Auth extends AuthMethodsBase> = MakePropertyOptionalIfChildrenOptional<(ParamsObject<SV> extends P ? unknown : {
-    params: MapSchema<SV, P>;
-}) & (Body<SV> extends ReqBody ? unknown : {
+type LiveTypeFunctionRequestInit<SV extends AnySchemaValidator, P extends ParamsObject<SV>, ReqBody extends Body<SV> | undefined, ReqQuery extends QueryObject<SV> | undefined, ReqHeaders extends HeadersObject<SV> | undefined, Auth extends AuthMethodsBase> = MakePropertyOptionalIfChildrenOptional<(Body<SV> extends ReqBody ? unknown : {
     body: MapSchema<SV, ReqBody>;
 }) & (QueryObject<SV> extends ReqQuery ? unknown : {
     query: MapSchema<SV, ReqQuery>;
@@ -655,6 +714,8 @@ type LiveTypeFunctionRequestInit<SV extends AnySchemaValidator, P extends Params
     headers: MapSchema<SV, ReqHeaders>;
 } : {
     headers: MapSchema<SV, ReqHeaders> & AuthHeaders<Auth>;
+}) & (ParamsObject<SV> extends P ? unknown : {
+    params: MapSchema<SV, P>;
 })>;
 /**
  * Represents a live type function for the SDK.
@@ -669,7 +730,7 @@ type LiveTypeFunctionRequestInit<SV extends AnySchemaValidator, P extends Params
  * @template ResHeaders - A type for the response headers.
  *
  */
-type LiveTypeFunction<SV extends AnySchemaValidator, Route 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>, ContractMethod extends Method, Auth extends AuthMethodsBase> = (route: SanitizePathSlashes<Route>, ...reqInit: Prettify<Omit<RequestInit, 'method' | 'body' | 'query' | 'headers' | 'params'> & {
+type LiveTypeFunction<SV extends AnySchemaValidator, Route 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>, ContractMethod extends Method, VersionedApi extends VersionSchema<SV, ContractMethod>, Auth extends AuthMethodsBase> = string extends keyof VersionedApi ? (route: SanitizePathSlashes<Route>, ...reqInit: Prettify<Omit<RequestInit, 'method' | 'body' | 'query' | 'headers' | 'params'> & {
     method: Uppercase<ContractMethod>;
 } & LiveTypeFunctionRequestInit<SV, P, ReqBody, ReqQuery, ReqHeaders, Auth>> extends infer ReqInit ? ReqInit extends {
     body: unknown;
@@ -679,7 +740,19 @@ type LiveTypeFunction<SV extends AnySchemaValidator, Route extends string, P ext
     query: unknown;
 } | {
     headers: unknown;
-} ? [reqInit: ReqInit] : [reqInit?: ReqInit] : never) => Promise<Prettify<SdkResponse<SV, ResponsesObject<SV> extends ResBodyMap ? Record<number, unknown> : ResBodyMap, ForklaunchResHeaders extends ResHeaders ? unknown : MapSchema<SV, ResHeaders>>>>;
+} ? [reqInit: ReqInit] : [reqInit?: ReqInit] : never) => Promise<Prettify<SdkResponse<SV, ResponsesObject<SV> extends ResBodyMap ? Record<number, unknown> : ResBodyMap, ForklaunchResHeaders extends ResHeaders ? unknown : MapSchema<SV, ResHeaders>>>> : {
+    [K in keyof VersionedApi]: (...reqInit: Prettify<Omit<RequestInit, 'method' | 'body' | 'query' | 'headers' | 'params'> & LiveTypeFunctionRequestInit<SV, P, VersionedApi[K]['body'] extends Body<SV> ? VersionedApi[K]['body'] : Body<SV>, VersionedApi[K]['query'] extends QueryObject<SV> ? VersionedApi[K]['query'] : QueryObject<SV>, VersionedApi[K]['requestHeaders'] extends HeadersObject<SV> ? VersionedApi[K]['requestHeaders'] : HeadersObject<SV>, Auth>> & {
+        version: K;
+    } extends infer ReqInit ? ReqInit extends {
+        body: unknown;
+    } | {
+        params: unknown;
+    } | {
+        query: unknown;
+    } | {
+        headers: unknown;
+    } ? [reqInit: ReqInit] : [reqInit?: ReqInit] : never) => Promise<Prettify<SdkResponse<SV, ResponsesObject<SV> extends VersionedApi[K]['responses'] ? Record<number, unknown> : VersionedApi[K]['responses'], ForklaunchResHeaders extends VersionedApi[K]['responseHeaders'] ? unknown : MapSchema<SV, VersionedApi[K]['responseHeaders']>>>>;
+};
 /**
  * Represents a live type function for the SDK.
  *
@@ -692,7 +765,7 @@ type LiveTypeFunction<SV extends AnySchemaValidator, Route extends string, P ext
  * @template ResHeaders - A type for the response headers.
  *
  */
-type LiveSdkFunction<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>, Auth extends AuthMethodsBase> = (...reqInit: Prettify<Omit<RequestInit, 'method' | 'body' | 'query' | 'headers' | 'params'> & LiveTypeFunctionRequestInit<SV, P, ReqBody, ReqQuery, ReqHeaders, Auth>> extends infer ReqInit ? ReqInit extends {
+type LiveSdkFunction<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>, VersionedApi extends VersionSchema<SV, Method>, Auth extends AuthMethodsBase> = string extends keyof VersionedApi ? (...reqInit: Prettify<Omit<RequestInit, 'method' | 'body' | 'query' | 'headers' | 'params'> & LiveTypeFunctionRequestInit<SV, P, ReqBody, ReqQuery, ReqHeaders, Auth>> extends infer ReqInit ? ReqInit extends {
     body: unknown;
 } | {
     params: unknown;
@@ -700,14 +773,24 @@ type LiveSdkFunction<SV extends AnySchemaValidator, P extends ParamsObject<SV>,
     query: unknown;
 } | {
     headers: unknown;
-} ? [reqInit: ReqInit] : [reqInit?: ReqInit] : never) => Promise<Prettify<SdkResponse<SV, ResponsesObject<SV> extends ResBodyMap ? Record<number, unknown> : ResBodyMap, ForklaunchResHeaders extends ResHeaders ? unknown : MapSchema<SV, ResHeaders>>>>;
+} ? [reqInit: ReqInit] : [reqInit?: ReqInit] : never) => Promise<Prettify<SdkResponse<SV, ResponsesObject<SV> extends ResBodyMap ? Record<number, unknown> : ResBodyMap, ForklaunchResHeaders extends ResHeaders ? unknown : MapSchema<SV, ResHeaders>>>> : {
+    [K in keyof VersionedApi]: (...reqInit: Prettify<Omit<RequestInit, 'method' | 'body' | 'query' | 'headers' | 'params'> & LiveTypeFunctionRequestInit<SV, P, VersionedApi[K]['body'] extends Body<SV> ? VersionedApi[K]['body'] : Body<SV>, VersionedApi[K]['query'] extends QueryObject<SV> ? VersionedApi[K]['query'] : QueryObject<SV>, VersionedApi[K]['requestHeaders'] extends HeadersObject<SV> ? VersionedApi[K]['requestHeaders'] : HeadersObject<SV>, Auth>> extends infer ReqInit ? ReqInit extends {
+        body: unknown;
+    } | {
+        params: unknown;
+    } | {
+        query: unknown;
+    } | {
+        headers: unknown;
+    } ? [reqInit: ReqInit] : [reqInit?: ReqInit] : never) => Promise<Prettify<SdkResponse<SV, ResponsesObject<SV> extends VersionedApi[K]['responses'] ? Record<number, unknown> : VersionedApi[K]['responses'], ForklaunchResHeaders extends VersionedApi[K]['responseHeaders'] ? unknown : MapSchema<SV, VersionedApi[K]['responseHeaders']>>>>;
+};
 /**
  * Represents a basic SDK Response object.
  *
  * @template ResBodyMap - A type for the response body.
  * @template ResHeaders - A type for the response headers.
  */
-type SdkResponse<SV extends AnySchemaValidator, ResBodyMap extends Record<number, unknown>, ResHeaders extends Record<string, string> | unknown> = Prettify<({
+type SdkResponse<SV extends AnySchemaValidator, ResBodyMap extends Record<number, unknown>, ResHeaders extends Record<string, unknown> | unknown> = ({
     [K in keyof ForklaunchResErrors]: {
         code: K;
         contentType: 'text/plain';
@@ -721,7 +804,7 @@ type SdkResponse<SV extends AnySchemaValidator, ResBodyMap extends Record<number
     } & (unknown extends ResHeaders ? unknown : {
         headers: ResHeaders;
     });
-})[keyof (ForklaunchResErrors & ResBodyMap)]>;
+})[keyof (ForklaunchResErrors & ResBodyMap)];
 /**
  * Represents the default error types for responses.
  */
@@ -777,11 +860,13 @@ interface ForklaunchRouter<SV extends AnySchemaValidator> {
     /** Nested routers */
     routers: ForklaunchRouter<SV>[];
     /** Nested route map */
-    fetchMap: Record<string, unknown>;
+    _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>;
 }
 /**
  * Interface representing a Forklaunch route.
@@ -792,133 +877,134 @@ 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 | RegExp | (string | RegExp)[];
+    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, 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>, BaseRequest, BaseResponse, NextFunction> = ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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>, BaseRequest, BaseResponse, NextFunction, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>> = {
+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> = ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, 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, BaseRequest, Auth>;
-    handlers: ContractDetailsExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[];
+    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>[];
 };
-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>, BaseRequest, BaseResponse, NextFunction, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>> = {
+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;
-    contractDetails: ContractDetails<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[];
+    _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, BaseRequest, BaseResponse, NextFunction>[];
 };
 
 interface LiveTypeRouteDefinition<SV extends AnySchemaValidator, BasePath extends `/${string}`, ContractMethod extends Method, RouterHandler, Internal extends ExpressLikeRouter<RouterHandler, Internal>, BaseRequest, BaseResponse, NextFunction, ChainableRouter extends {
-    fetchMap: object;
+    _fetchMap: object;
     sdk: object;
 }> {
-    <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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(path: PathMatch<SuppliedPath, Path>, typedHandler: TypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth>): ChainableRouter & {
-        fetchMap: Prettify<ChainableRouter['fetchMap'] & Record<SanitizePathSlashes<`${BasePath}${Path}`>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, Auth>>>;
-        sdk: Prettify<ChainableRouter['sdk'] & Record<PrettyCamelCase<Name>, LiveSdkFunction<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, 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>, VersionedApi extends VersionSchema<SV, ContractMethod>, 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>>>;
     };
-    <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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(path: PathMatch<SuppliedPath, Path>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>, ...middlewareAndTypedHandler: [
-        ...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[],
-        TypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, 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>, VersionedApi extends VersionSchema<SV, ContractMethod>, 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, BaseRequest, BaseResponse, NextFunction>, ...middlewareAndTypedHandler: [
+        ...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, 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'] & Record<SanitizePathSlashes<`${BasePath}${Path}`>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, Auth>>>;
-        sdk: Prettify<ChainableRouter['sdk'] & Record<PrettyCamelCase<Name>, LiveSdkFunction<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Auth>>>;
+        _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}`, 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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(path: Path, contractDetails: ContractDetails<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]): ChainableRouter & {
-        fetchMap: Prettify<ChainableRouter['fetchMap'] & Record<SanitizePathSlashes<`${BasePath}${Path}`>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, Auth>>>;
-        sdk: Prettify<ChainableRouter['sdk'] & Record<PrettyCamelCase<Name>, LiveSdkFunction<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Auth>>>;
+    <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, ContractMethod>, 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, 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>>>;
     };
 }
 interface TypedMiddlewareDefinition<ChainableRouter, SV extends AnySchemaValidator, BaseRequest, BaseResponse, NextFunction, RouterHandler> {
     (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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(path: PathMatch<SuppliedPath, Path>, typedHandler: TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(typedHandler: TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(path: PathMatch<SuppliedPath, Path>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>, ...middlewareAndTypedHandler: [
-        ...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[],
-        TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, 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>, 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;
+    <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, BaseRequest, BaseResponse, NextFunction>, ...middlewareAndTypedHandler: [
+        ...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, 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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>, ...middlewareAndTypedHandler: [
-        ...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[],
-        TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth>
+    <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, BaseRequest, BaseResponse, NextFunction>, ...middlewareAndTypedHandler: [
+        ...ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, 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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(path: Path, contractDetails: ContractDetails<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>, ...middlewares: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(contractDetails: ContractDetails<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>, ...middlewares: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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'>, 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, BaseRequest, BaseResponse, NextFunction>, ...middlewares: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, 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'>, 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, BaseRequest, BaseResponse, NextFunction>, ...middlewares: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction>[]): ChainableRouter;
 }
 interface TypedNestableMiddlewareDefinition<ChainableRouter extends {
-    fetchMap: object;
+    _fetchMap: object;
     basePath: `/${string}`;
     sdk: Record<string, unknown>;
 }, RouterHandler, Internal extends ExpressLikeRouter<RouterHandler, Internal>, SV extends AnySchemaValidator, BaseRequest, BaseResponse, NextFunction> extends TypedMiddlewareDefinition<ChainableRouter, SV, 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];
+        _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];
+        _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];
+        _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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(path: `/${string}` extends Router['basePath'] ? Path : PathMatch<Path, Router['basePath']>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewareAndTypedHandler: [
-        ...(ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction> | Router)[],
-        TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth>
+    <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'>, Router extends ConstrainedForklaunchRouter<SV, RouterHandler>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(path: `/${string}` extends Router['basePath'] ? Path : PathMatch<Path, Router['basePath']>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewareAndTypedHandler: [
+        ...(ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, 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];
+        _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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewareAndTypedHandler: [
-        ...(ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction> | Router)[],
-        TypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth>
+    <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'>, Router extends ConstrainedForklaunchRouter<SV, RouterHandler>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>(middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewareAndTypedHandler: [
+        ...(ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, 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];
+        _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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(path: `/${string}` extends Router['basePath'] ? Path : PathMatch<Path, Router['basePath']>, contractDetails: ContractDetails<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewares: (ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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];
+    <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, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewares: (ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, 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>, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(contractDetails: ContractDetails<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, middleware: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewares: (ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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];
+    <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, BaseRequest, BaseResponse, NextFunction> | Router, ...middlewares: (ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, 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']>;
         }>;
     };
 }
-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>, BaseRequest, BaseResponse, NextFunction, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>> = ContractDetails<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth> | ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction> | TypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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>, BaseRequest, BaseResponse, NextFunction, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>> = ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction> | TypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth>;
+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, 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, 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, Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>> = ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, 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.
@@ -982,7 +1068,7 @@ type MiddlewareOrMiddlewareWithTypedHandler<SV extends AnySchemaValidator, Name
  * });
  * ```
  **/
-type FetchFunction<FetchMap> = <Path extends keyof FetchMap>(path: Path, ...reqInit: FetchMap[Path] extends TypeSafeFunction ? Parameters<FetchMap[Path]>[1] extends {
+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;
@@ -990,210 +1076,288 @@ type FetchFunction<FetchMap> = <Path extends keyof FetchMap>(path: Path, ...reqI
     params: unknown;
 } | {
     headers: unknown;
-} ? [reqInit: Parameters<FetchMap[Path]>[1]] : [reqInit?: Parameters<FetchMap[Path]>[1]] : [reqInit?: never]) => Promise<FetchMap[Path] extends TypeSafeFunction ? ReturnType<FetchMap[Path]> : never>;
+} | {
+    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>;
 /**
- * Creates a router SDK by combining the router's SDK with its fetch functionality.
- * This type merges the router's SDK interface with its fetch methods to create
- * a complete router client.
+ * Represents the structure of a SDK router.
  *
- * @template TRoute - A route object that must contain both `sdk` and `fetch` properties
- * @param TRoute.sdk - The SDK interface/methods for the route
- * @param TRoute.fetch - The fetch functionality for the route
+ * @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.
  *
- * @returns A prettified object combining the SDK and fetch properties
+ * @template SV - The schema validator type that constrains the router structure
+ * @param SV - Must extend AnySchemaValidator to ensure type safety
  *
  * @example
  * ```typescript
- * type UserRoute = {
- *   sdk: { getUser: () => Promise<User>; createUser: (data: UserData) => Promise<User> };
- *   fetch: { get: (path: string) => Promise<Response> };
+ * 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 UserRouter = SdkRouter<UserRoute>;
- * // Result: {
- * //   getUser: () => Promise<User>;
- * //   createUser: (data: UserData) => Promise<User>;
- * //   fetch: { get: (path: string) => Promise<Response> };
- * // }
  * ```
  */
-type SdkRouter<TRoute extends {
-    sdk: unknown;
-    fetch: unknown;
-}> = Prettify<TRoute['sdk'] & {
-    fetch: TRoute['fetch'];
-}>;
+type RouterMap<SV extends AnySchemaValidator> = {
+    [K: string]: SdkRouter | RouterMap<SV>;
+};
 /**
- * Creates a complete SDK client from a record of route definitions.
- * Each route in the input is transformed into an SdkRouter, creating a comprehensive
- * client SDK with all routes and their associated fetch functionality.
+ * Tail-recursive type that extracts SDK interfaces from a RouterMap structure.
+ * This version uses an accumulator pattern to avoid deep recursion and improve performance.
+ * Traverses the nested router map and collects all SDK interfaces into a flat structure.
  *
- * @template Input - A record where each key represents a route name and each value
- *                   contains the route's SDK, fetch methods, optional SDK name, and base path
- * @param Input[K].sdk - The SDK interface for route K
- * @param Input[K].fetch - The fetch functionality for route K
- * @param Input[K].sdkName - Optional custom name for the SDK (defaults to camelCase basePath)
- * @param Input[K].basePath - The base URL path for the route (used for SDK naming if sdkName not provided)
+ * @template SV - The schema validator type
+ * @template T - The RouterMap to extract SDKs from
+ * @template Acc - The accumulator type for collecting SDK interfaces (defaults to empty object)
+ * @param SV - Must extend AnySchemaValidator
+ * @param T - Must extend RouterMap<SV>
+ * @param Acc - The accumulated SDK interfaces so far
  *
- * @returns A prettified object where each route becomes an SdkRouter
+ * @returns A mapped type where each key corresponds to the original router structure,
+ *         but values are the extracted SDK interfaces instead of the full router configuration
  *
  * @example
  * ```typescript
- * type Routes = {
- *   users: {
- *     sdk: { getUser: () => Promise<User> };
- *     fetch: { get: (path: string) => Promise<Response> };
- *     basePath: '/api/users';
- *   };
- *   posts: {
- *     sdk: { getPost: () => Promise<Post> };
- *     fetch: { get: (path: string) => Promise<Response> };
- *     basePath: '/api/posts';
- *     sdkName: 'articles';
- *   };
- * };
- *
- * type Client = SdkClient<Routes>;
- * // Result: {
- * //   users: { getUser: () => Promise<User>; fetch: {...} };
- * //   posts: { getPost: () => Promise<Post>; fetch: {...} };
- * // }
+ * // Given a RouterMap with nested structure
+ * type ExtractedSdk = MapToSdk<ZodValidator, typeof routerMap>;
+ * // Results in: { api: { users: { getUser: () => Promise<{}> }, posts: { getPosts: () => Promise<[]> } } }
  * ```
  */
-type SdkClient<Input extends Record<string, {
-    sdk: unknown;
-    fetch: unknown;
-    sdkName?: string;
-    basePath: string;
-}>> = Prettify<{
-    [K in keyof Input]: Prettify<SdkRouter<Input[K]>>;
-}>;
+type MapToSdk<SV extends AnySchemaValidator, T extends RouterMap<SV>, Acc extends Record<string, unknown> = Record<string, never>> = {
+    [K in keyof T]: T[K] extends {
+        sdk: infer S;
+    } ? S : T[K] extends RouterMap<SV> ? MapToSdk<SV, T[K], Acc> : never;
+};
 /**
- * Validates and unpacks SDK client input by ensuring that each key in the input record
- * corresponds to either the route's custom `sdkName` or the PrettyCamelCase version
- * of its `basePath`. This type provides compile-time validation for SDK client configuration.
+ * 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 Input - A record of route definitions to validate
- * @param Input[K].sdk - The SDK interface for route K
- * @param Input[K].fetch - The fetch functionality for route K
- * @param Input[K].sdkName - Optional custom SDK name that should match the key K
- * @param Input[K].basePath - Base path that when converted to PrettyCamelCase should match key K
+ * @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 The original Input type if valid, or 'Invalid SDK Client Input' if validation fails
+ * @returns An intersection type containing all fetch map interfaces from the router structure,
+ *         flattened into a single type for unified fetch functionality
  *
  * @example
  * ```typescript
- * // Valid input - key matches basePath in camelCase
- * type ValidInput = {
- *   apiUsers: {
- *     sdk: UserSdk;
- *     fetch: FetchMethods;
- *     basePath: '/api/users'; // PrettyCamelCase becomes 'apiUsers'
- *   };
- * };
- * type Result1 = UnpackSdkClientInput<ValidInput>; // Returns ValidInput
- *
- * // Valid input - key matches custom sdkName
- * type ValidInput2 = {
- *   userService: {
- *     sdk: UserSdk;
- *     fetch: FetchMethods;
- *     sdkName: 'userService';
- *     basePath: '/api/users';
- *   };
- * };
- * type Result2 = UnpackSdkClientInput<ValidInput2>; // Returns ValidInput2
- *
- * // Invalid input - key doesn't match either sdkName or camelCase basePath
- * type InvalidInput = {
- *   wrongKey: {
- *     sdk: UserSdk;
- *     fetch: FetchMethods;
- *     basePath: '/api/users'; // Should be 'apiUsers'
- *   };
+ * // 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: infer F;
+    } ? F extends Record<string, unknown> ? F : 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.
+ *
+ * @template SV - The schema validator type that constrains the contract details
+ *
+ * @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 } }
+ *     }
+ *   },
+ *   getUser: {
+ *     _path: '/users/:id',
+ *     _method: 'get',
+ *     contractDetails: {
+ *       name: 'getUser',
+ *       params: { id: string },
+ *       responses: { 200: { id: string, name: string } }
+ *     }
+ *   }
  * };
- * type Result3 = UnpackSdkClientInput<InvalidInput>; // Returns 'Invalid SDK Client Input'
  * ```
  */
-type UnpackSdkClientInput<Input extends Record<string, {
-    sdk: unknown;
-    fetch: unknown;
-    sdkName?: string;
-    basePath: string;
-}>> = Prettify<{
-    [K in keyof Input]: K extends Input[K]['sdkName'] ? Input[K] : K extends PrettyCamelCase<Input[K]['basePath']> ? Input[K] : unknown;
-} extends Input ? Prettify<Input> : 'Invalid SDK Client Input'>;
+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;
+    };
+};
+type MapControllerToSdk<SV extends AnySchemaValidator, T extends Record<string, SdkHandler>> = {
+    [K in keyof T]: LiveSdkFunction<SV, T[K]['contractDetails']['params'] extends infer Params | undefined ? Params extends ParamsObject<SV> ? Params : ParamsObject<SV> : ParamsObject<SV>, T[K]['contractDetails']['responses'] extends infer Responses | undefined ? Responses extends ResponsesObject<SV> ? Responses : ResponsesObject<SV> : ResponsesObject<SV>, T[K]['contractDetails']['body'] extends infer B | undefined ? B extends Body<SV> ? B : Body<SV> : Body<SV>, T[K]['contractDetails']['query'] extends infer Q | undefined ? Q extends QueryObject<SV> ? Q : QueryObject<SV> : QueryObject<SV>, T[K]['contractDetails']['requestHeaders'] extends infer RequestHeaders | undefined ? RequestHeaders extends HeadersObject<SV> ? RequestHeaders : HeadersObject<SV> : HeadersObject<SV>, T[K]['contractDetails']['responseHeaders'] extends infer ResponseHeaders | undefined ? ResponseHeaders extends HeadersObject<SV> ? ResponseHeaders : HeadersObject<SV> : HeadersObject<SV>, T[K]['contractDetails']['versions'] extends infer Versions | undefined ? Versions extends VersionSchema<SV, Method> ? Versions : VersionSchema<SV, Method> : VersionSchema<SV, Method>, T[K]['contractDetails']['auth'] extends infer Auth | undefined ? Auth extends AuthMethodsBase ? Auth : AuthMethodsBase : AuthMethodsBase>;
+};
 /**
- * Type alias for valid SDK client input configuration.
- * This type serves as a constraint to ensure that input to SDK client functions
- * conforms to the expected structure with required sdk, fetch, and basePath properties,
- * plus an optional sdkName property.
+ * Extracts and constructs a LiveTypeFunction from an SdkHandler object.
+ * This type utility takes a controller entry and transforms it into a type-safe
+ * function that can be used for making HTTP requests with full type safety.
  *
- * @template Input - A record of route definitions that must conform to the SDK client structure
- * @param Input[K].sdk - The SDK interface containing route-specific methods
- * @param Input[K].fetch - The fetch functionality for making HTTP requests
- * @param Input[K].sdkName - Optional custom name for the SDK (if not provided, uses camelCase basePath)
- * @param Input[K].basePath - Required base URL path for the route
+ * @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
  *
- * @returns The input type unchanged, serving as a validation constraint
+ * @returns A LiveTypeFunction with properly typed parameters and return values
+ *          based on the entry's contract details
  *
  * @example
  * ```typescript
- * // Use as a constraint in function parameters
- * function createSdkClient<T extends ValidSdkClientInput<T>>(input: T): SdkClient<T> {
- *   // Function implementation
- * }
+ * type UserCreateFunction = ExtractLiveTypeFn<
+ *   { _path: '/users', _method: 'post', contractDetails: { body: { name: string } } },
+ *   SchemaValidator,
+ *   '/api/v1'
+ * >;
+ * // Results in: (path: '/api/v1/users', options: { body: { name: string } }) => Promise<...>
+ * ```
+ */
+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>;
+/**
+ * Transforms a controller object into a fetch map structure that provides
+ * type-safe access to HTTP endpoints. This type creates a discriminated union
+ * where each path maps to its specific HTTP methods, ensuring that different
+ * methods for the same path are properly discriminated rather than unioned.
  *
- * // Valid usage
- * const validInput = {
- *   users: {
- *     sdk: { getUser: () => Promise.resolve({}) },
- *     fetch: { get: (path: string) => fetch(path) },
- *     basePath: '/api/users'
- *   }
- * } satisfies ValidSdkClientInput<UnpackSdkClientInput<typeof validInput>>;
+ * @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
+ *
+ * @returns A fetch map structure where:
+ *          - Keys are full paths (basePath + entry path)
+ *          - Values are records mapping HTTP methods to their corresponding LiveTypeFunctions
+ *          - Each method is properly discriminated with its own contract details
+ *
+ * @example
+ * ```typescript
+ * const controller = {
+ *   createUser: { _path: '/users', _method: 'post', contractDetails: { body: { name: string } } },
+ *   getUser: { _path: '/users/:id', _method: 'get', contractDetails: { params: { id: string } } },
+ *   updateUser: { _path: '/users/:id', _method: 'put', contractDetails: { body: { name: string } } }
+ * } as const;
+ *
+ * type FetchMap = ToFetchMap<typeof controller, SchemaValidator, '/api/v1'>;
+ * // Results in:
+ * // {
+ * //   '/api/v1/users': {
+ * //     POST: LiveTypeFunction<...>, // from createUser
+ * //   },
+ * //   '/api/v1/users/:id': {
+ * //     GET: LiveTypeFunction<...>,  // from getUser
+ * //     PUT: LiveTypeFunction<...>   // from updateUser
+ * //   }
+ * // }
  * ```
  */
-type ValidSdkClientInput<Input extends Record<string, {
-    sdk: unknown;
-    fetch: unknown;
-    sdkName?: string;
-    basePath: string;
-}>> = Input;
+type ToFetchMap<T extends Record<string, SdkHandler>, SV extends AnySchemaValidator, RouterBasePath extends `/${string}`> = {
+    [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>;
+    };
+};
 
 /**
  * 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, FetchMap extends Record<string, unknown> = EmptyObject, Sdk extends Record<string, unknown> = EmptyObject, SdkName extends string = PrettyCamelCase<BasePath>> implements ConstrainedForklaunchRouter<SV, RouterHandler> {
+declare class ForklaunchExpressLikeRouter<SV extends AnySchemaValidator, BasePath extends `/${string}`, RouterHandler, Internal extends ExpressLikeRouter<RouterHandler, Internal>, BaseRequest, BaseResponse, NextFunction, 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 sdkName?: SdkName | undefined;
     requestHandler: RouterHandler;
     routers: ForklaunchRouter<SV>[];
     routes: ForklaunchRoute<SV>[];
-    fetchMap: FetchMap;
+    _fetchMap: FetchMap;
     sdk: Sdk;
-    constructor(basePath: BasePath, schemaValidator: SV, internal: Internal, postEnrichMiddleware: RouterHandler[], openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, sdkName?: SdkName | undefined);
+    sdkPaths: Record<string, string>;
+    constructor(basePath: BasePath, schemaValidator: SV, internal: Internal, postEnrichMiddleware: RouterHandler[], openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>);
     /**
      * 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.
+     * @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.
+     * @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>, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(method: ContractMethod, path: Path, registrationMethod: PathBasedHandler<RouterHandler>, contractDetailsOrMiddlewareOrTypedHandler: ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth>, ...middlewareOrMiddlewareAndTypedHandler: MiddlewareOrMiddlewareWithTypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth>[]): this & {
-        fetchMap: Prettify<FetchMap & Record<SanitizePathSlashes<`${BasePath}${Path}`>, LiveTypeFunction<SV, SanitizePathSlashes<`${BasePath}${Path}`>, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, ContractMethod, Auth>>>;
-        sdk: Prettify<Sdk & Record<PrettyCamelCase<Name extends string ? Name : SanitizePathSlashes<`${BasePath}${Path}`>>, LiveSdkFunction<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, Auth>>>;
+    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>, const VersionedApi extends VersionSchema<SV, ContractMethod>, const 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, Auth>, ...middlewareOrMiddlewareAndTypedHandler: MiddlewareOrMiddlewareWithTypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, 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>, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(registrationMethod: PathOrMiddlewareBasedHandler<RouterHandler>, pathOrContractDetailsOrMiddlewareOrTypedHandler: Path | ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth> | RouterHandler, contractDetailsOrMiddlewareOrTypedHandler?: ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth> | RouterHandler, ...middlewareOrMiddlewareWithTypedHandler: (MiddlewareOrMiddlewareWithTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth> | RouterHandler)[]): this;
+    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>, const VersionedApi extends VersionSchema<SV, 'middleware'>, const 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, Auth> | RouterHandler, contractDetailsOrMiddlewareOrTypedHandler?: ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth> | RouterHandler, ...middlewareOrMiddlewareWithTypedHandler: (MiddlewareOrMiddlewareWithTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, 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>, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(registrationMethod: NestableRouterBasedHandler<RouterHandler, Internal>, pathOrContractDetailsOrMiddlewareOrTypedHandler: Path | ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth> | ConstrainedForklaunchRouter<SV, RouterHandler>, contractDetailsOrMiddlewareOrTypedHandler?: ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth> | ConstrainedForklaunchRouter<SV, RouterHandler>, ...middlewareOrMiddlewareWithTypedHandler: (MiddlewareOrMiddlewareWithTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth> | ConstrainedForklaunchRouter<SV, RouterHandler>)[]): this;
+    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>, const VersionedApi extends VersionSchema<SV, 'middleware'>, const 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, Auth> | ConstrainedForklaunchRouter<SV, RouterHandler>, contractDetailsOrMiddlewareOrTypedHandler?: ContractDetailsOrMiddlewareOrTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth> | ConstrainedForklaunchRouter<SV, RouterHandler>, ...middlewareOrMiddlewareWithTypedHandler: (MiddlewareOrMiddlewareWithTypedHandler<SV, Name, 'middleware', Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, VersionedApi, BaseRequest, BaseResponse, NextFunction, Auth> | ConstrainedForklaunchRouter<SV, RouterHandler>)[]): this;
     use: TypedNestableMiddlewareDefinition<this, RouterHandler, Internal, SV, BaseRequest, BaseResponse, NextFunction>;
     all: TypedMiddlewareDefinition<this, SV, BaseRequest, BaseResponse, NextFunction, RouterHandler>;
     connect: TypedMiddlewareDefinition<this, SV, BaseRequest, BaseResponse, NextFunction, RouterHandler>;
@@ -1319,14 +1483,13 @@ declare class ForklaunchExpressLikeRouter<SV extends AnySchemaValidator, BasePat
  * @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, FetchMap extends Record<string, unknown> = EmptyObject, Sdk extends Record<string, unknown> = EmptyObject, SdkName extends string = 'sdk'> extends ForklaunchExpressLikeRouter<SV, '/', RouterHandler, Server, BaseRequest, BaseResponse, NextFunction, FetchMap, Sdk, SdkName> {
+declare abstract class ForklaunchExpressLikeApplication<SV extends AnySchemaValidator, Server extends ExpressLikeRouter<RouterHandler, Server>, RouterHandler, BaseRequest, BaseResponse, NextFunction, FetchMap extends Record<string, unknown> = EmptyObject, Sdk extends Record<string, unknown> = EmptyObject> extends ForklaunchExpressLikeRouter<SV, '/', RouterHandler, Server, BaseRequest, BaseResponse, NextFunction, FetchMap, Sdk> {
     readonly schemaValidator: SV;
     readonly internal: Server;
     readonly postEnrichMiddleware: RouterHandler[];
     readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
     readonly appOptions?: {
         cors?: CorsOptions;
-        sdkName?: SdkName;
     } | undefined;
     /**
      * Creates an instance of the Application class.
@@ -1335,7 +1498,6 @@ declare abstract class ForklaunchExpressLikeApplication<SV extends AnySchemaVali
      */
     constructor(schemaValidator: SV, internal: Server, postEnrichMiddleware: RouterHandler[], openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, appOptions?: {
         cors?: CorsOptions;
-        sdkName?: SdkName;
     } | undefined);
     abstract listen(...args: unknown[]): void;
 }
@@ -1348,7 +1510,7 @@ declare abstract class ForklaunchExpressLikeApplication<SV extends AnySchemaVali
  * @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, string>
+ * @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
  *
@@ -1360,7 +1522,7 @@ declare abstract class ForklaunchExpressLikeApplication<SV extends AnySchemaVali
  * }
  * ```
  */
-declare function isForklaunchRequest<SV extends AnySchemaValidator, P extends ParamsDictionary, ReqBody extends Record<string, unknown>, ReqQuery extends ParsedQs, ReqHeaders extends Record<string, string>>(request: unknown): request is ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders>;
+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>(request: unknown): request is ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, Extract<keyof VersionedReqs, string>>;
 
 /**
  * Type guard that checks if an object is a Forklaunch router.
@@ -1381,30 +1543,30 @@ declare function isForklaunchRequest<SV extends AnySchemaValidator, P extends Pa
  */
 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>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: PathParamHttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "delete", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth>;
+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, 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>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: PathParamHttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "get", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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, 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>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: PathParamHttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "head", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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, 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>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: MiddlewareContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]) => {
+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, BaseRequest, BaseResponse, NextFunction>[]) => {
     _typedHandler: true;
     _path: Path;
-    contractDetails: ContractDetails<SV, Name, "middleware", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>;
-    handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[];
+    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, 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>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: PathParamHttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "options", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction, Auth>;
+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, 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>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: HttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "patch", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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, 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>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: HttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "post", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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, 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>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: HttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "put", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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, 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>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(_schemaValidator: SV, path: Path, contractDetails: PathParamHttpContractDetails<SV, Name, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]) => ExpressLikeTypedHandler<SV, Name, "trace", Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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, 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>, BaseRequest>(_schemaValidator: SV, _contractDetails: ContractDetails<SV, Name, Method, `/${string}`, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>, authHandler: ExpressLikeSchemaAuthMapper<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>): ExpressLikeSchemaAuthMapper<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>;
+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>, BaseRequest>(_schemaValidator: SV, _contractDetails: ContractDetails<SV, Name, Method, `/${string}`, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, VersionedApi, BaseRequest, SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>>, authHandler: ExpressLikeSchemaAuthMapper<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>): ExpressLikeSchemaAuthMapper<SV, P, ReqBody, ReqQuery, ReqHeaders, VersionedApi, BaseRequest>;
 
 /**
  * Router class that sets up routes and middleware for an Express router, for use with controller/routes pattern.
@@ -1413,8 +1575,8 @@ declare function typedAuthHandler<SV extends AnySchemaValidator, Name extends st
  * @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>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(_schemaValidator: SV, _path: Path | undefined, _contractMethod: ContractMethod, contractDetails: ContractDetails<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]): ExpressLikeTypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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>, BaseRequest, BaseResponse, NextFunction, const Auth extends SchemaAuthMethods<SV, P, ReqBody, ReqQuery, ReqHeaders, BaseRequest>>(_schemaValidator: SV, _contractMethod: ContractMethod, contractDetails: ContractDetails<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, BaseRequest, Auth>, ...handlers: ExpressLikeSchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, BaseRequest, BaseResponse, NextFunction>[]): ExpressLikeTypedHandler<SV, Name, ContractMethod, Path, P, ResBodyMap, ReqBody, ReqQuery, ReqHeaders, ResHeaders, LocalsObj, 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, _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, 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, 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
@@ -1527,8 +1689,9 @@ declare function generateMcpServer<T extends Record<string, unknown> | undefined
  *
  * @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, string>, LocalsObj extends Record<string, unknown>>(instance: unknown, req: ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders>, res: ForklaunchResponse<unknown, ResBodyMap, ForklaunchResHeaders & ResHeaders, LocalsObj>, 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 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>(instance: unknown, req: ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, Extract<keyof VersionedReqs, string>>, 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.
  *
@@ -1538,10 +1701,10 @@ declare function enrichExpressLikeSend<SV extends AnySchemaValidator, P extends
  * @param {ForklaunchRouter<SV>[]} routers - The routers to include in the Swagger document.
  * @returns {OpenAPIObject} - The generated Swagger document.
  */
-declare function generateSwaggerDocument<SV extends AnySchemaValidator>(schemaValidator: SV, protocol: 'http' | 'https', host: string, port: string | number, routers: ForklaunchRouter<SV>[], otherServers?: {
+declare function generateOpenApiSpecs<SV extends AnySchemaValidator>(schemaValidator: SV, protocol: 'http' | 'https', host: string, port: string | number, routers: ForklaunchRouter<SV>[], otherServers?: {
     url: string;
     description: string;
-}[]): OpenAPIObject;
+}[]): Record<string | symbol, OpenAPIObject>;
 
 /**
  * Discriminates the body type from the given contract details and returns information
@@ -1584,6 +1747,136 @@ declare function discriminateResponseBodies<SV extends AnySchemaValidator>(schem
     schema: SV["_ValidSchemaObject"];
 }>;
 
+/**
+ * Creates a complete SDK client from a RouterMap configuration.
+ * This is the main entry point for creating type-safe SDK clients that combine
+ * both SDK interfaces and fetch functionality from router configurations.
+ *
+ * @template SV - The schema validator type that constrains the router structure
+ * @template T - The RouterMap type to create the SDK client from
+ * @param schemaValidator - The schema validator instance used for validation and type constraints
+ * @param routerMap - The router map containing the complete API configuration
+ *
+ * @returns An object containing both the SDK interface and fetch function:
+ *          - `sdk`: The extracted SDK interfaces for direct method calls
+ *          - `fetch`: The unified fetch function for making HTTP requests
+ *
+ * @example
+ * ```typescript
+ * const routerMap = {
+ *   api: {
+ *     users: {
+ *       sdk: { getUser: (id: string) => Promise.resolve({ id, name: 'John' }) },
+ *       _fetchMap: { getUser: { get: (id: string) => fetch(`/api/users/${id}`) } }
+ *     },
+ *     posts: {
+ *       sdk: { getPosts: () => Promise.resolve([]) },
+ *       _fetchMap: { getPosts: { get: () => fetch('/api/posts') } }
+ *     }
+ *   }
+ * };
+ *
+ * const client = sdkClient(zodValidator, routerMap);
+ *
+ * // Use SDK methods directly
+ * const user = await client.sdk.api.users.getUser('123');
+ *
+ * // Use fetch function for custom requests
+ * const response = await client.fetch('getUser', { params: { id: '123' } });
+ * ```
+ */
+declare function sdkClient<SV extends AnySchemaValidator, T extends RouterMap<SV>>(schemaValidator: SV, routerMap: T): {
+    _finalizedSdk: true;
+    sdk: MapToSdk<SV, T>;
+    fetch: FetchFunction<MapToFetch<SV, T>>;
+};
+
+/**
+ * Creates a type-safe SDK router by mapping controller definitions to router SDK functions.
+ * This function takes a controller object with contract details and maps each controller method
+ * to the corresponding SDK function from the router, ensuring type safety throughout the process.
+ * The function now uses `const` template parameters for better type inference and includes
+ * a comprehensive fetch map for enhanced type safety.
+ *
+ * @template SV - The schema validator type that constrains the router and controller structure
+ * @template T - The controller type containing contract details for each endpoint (const parameter)
+ * @template Router - The router type that provides SDK functions, fetch, and _fetchMap capabilities (const parameter)
+ * @param SV - Must extend AnySchemaValidator to ensure type safety
+ * @param T - Must be a const record where each key maps to a controller method with contract details
+ * @param Router - Must be a const object with optional sdk, fetch, and _fetchMap properties
+ *
+ * @param schemaValidator - The schema validator instance used for validation and type constraints
+ * @param controller - The controller object containing contract details for each endpoint
+ * @param router - The router instance that provides SDK functions, fetch, and _fetchMap capabilities
+ *
+ * @returns An object containing:
+ *          - `sdk`: Type-safe SDK functions mapped from controller methods using LiveSdkFunction
+ *          - `fetch`: The router's fetch function cast to FetchFunction with proper typing
+ *          - `_fetchMap`: A comprehensive fetch map with LiveTypeFunction for each endpoint and method
+ *
+ * @example
+ * ```typescript
+ * const controller = {
+ *   createAgent: {
+ *     _path: '/agents',
+ *     _method: 'POST',
+ *     contractDetails: {
+ *       name: 'createAgent',
+ *       body: { name: 'string', organizationId: 'string' },
+ *       responses: { 200: { id: 'string', name: 'string' } }
+ *     }
+ *   },
+ *   getAgent: {
+ *     _path: '/agents/:id',
+ *     _method: 'GET',
+ *     contractDetails: {
+ *       name: 'getAgent',
+ *       params: { id: 'string' },
+ *       responses: { 200: { id: 'string', name: 'string' } }
+ *     }
+ *   }
+ * } as const;
+ *
+ * const router = {
+ *   sdk: { createAgent: () => Promise.resolve({}), getAgent: () => Promise.resolve({}) },
+ *   fetch: (path: string, options: any) => fetch(path, options),
+ *   _fetchMap: { '/agents': { POST: () => fetch('/agents', { method: 'POST' }) } }
+ * } as const;
+ *
+ * const sdkRouter = sdkRouter(zodValidator, controller, router);
+ *
+ * // Use SDK functions with full type safety
+ * const agent = await sdkRouter.sdk.createAgent({
+ *   body: { name: 'My Agent', organizationId: 'org123' }
+ * });
+ *
+ * const agentData = await sdkRouter.sdk.getAgent({
+ *   params: { id: 'agent123' }
+ * });
+ *
+ * // Use fetch function with enhanced type safety
+ * const response = await sdkRouter.fetch('/agents', {
+ *   method: 'POST',
+ *   body: { name: 'Custom Agent', organizationId: 'org456' }
+ * });
+ *
+ * // Access the fetch map for advanced usage
+ * const _fetchMap = sdkRouter._fetchMap;
+ * ```
+ */
+declare function sdkRouter<SV extends AnySchemaValidator, const T extends Record<string, SdkHandler>, const Router extends {
+    sdk?: unknown;
+    fetch?: unknown;
+    _fetchMap?: unknown;
+    basePath?: string;
+    sdkPaths: Record<string, string>;
+}>(schemaValidator: SV, controller: T, router: Router): {
+    sdk: MapControllerToSdk<SV, T>;
+    fetch: FetchFunction<ToFetchMap<T, SV, Router["basePath"] extends `/${string}` ? Router["basePath"] : "/">>;
+    _fetchMap: ToFetchMap<T, SV, Router["basePath"] extends `/${string}` ? Router["basePath"] : "/">;
+    sdkPaths: Router["sdkPaths"];
+};
+
 declare const ATTR_API_NAME = "api.name";
 declare const ATTR_CORRELATION_ID = "correlation.id";
 
@@ -1615,7 +1908,7 @@ declare class PinoLogger {
 }
 declare function logger(level: LevelWithSilentOrString, meta?: AnyValueMap): PinoLogger;
 
-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, string>, LocalsObj extends Record<string, unknown>>(req: ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders>, res: ForklaunchResponse<unknown, ResBodyMap, ResHeaders, LocalsObj>): void;
+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>(req: ForklaunchRequest<SV, P, ReqBody, ReqQuery, ReqHeaders, Extract<keyof VersionedReqs, string>>, res: ForklaunchResponse<unknown, ResBodyMap, ResHeaders, LocalsObj, Extract<keyof VersionedReqs, string>>): void;
 
 type DocsConfiguration = ({
     type: 'scalar';
@@ -1623,4 +1916,4 @@ type DocsConfiguration = ({
     type: 'swagger';
 };
 
-export { ATTR_API_NAME, ATTR_CORRELATION_ID, type AuthMethods, type AuthMethodsBase, type BasicAuthMethods, type Body, type BodyObject, type ConstrainedForklaunchRouter, type ContractDetails, type ContractDetailsExpressLikeSchemaHandler, type ContractDetailsOrMiddlewareOrTypedHandler, type DocsConfiguration, type ErrorContainer, type ExpressLikeAuthMapper, type ExpressLikeHandler, type ExpressLikeRouter, type ExpressLikeSchemaAuthMapper, type ExpressLikeSchemaHandler, type ExpressLikeTypedHandler, type ExtractBody, type ExtractContentType, type ExtractResponseBody, type ExtractedParamsObject, type FetchFunction, type FileBody, type ForklaunchBaseRequest, ForklaunchExpressLikeApplication, ForklaunchExpressLikeRouter, type ForklaunchNextFunction, type ForklaunchRequest, type ForklaunchResErrors, type ForklaunchResHeaders, type ForklaunchResponse, type ForklaunchRoute, type ForklaunchRouter, type ForklaunchSendableData, type ForklaunchStatusResponse, HTTPStatuses, type HeadersObject, type HttpContractDetails, type HttpMethod, type JsonBody, type JwtAuthMethods, type LiveSdkFunction, type LiveTypeFunction, type LiveTypeFunctionRequestInit, type LiveTypeRouteDefinition, type LogFn, type LoggerMeta, type MapParamsSchema, type MapReqBodySchema, type MapReqHeadersSchema, type MapReqQuerySchema, type MapResBodyMapSchema, type MapResHeadersSchema, type MapSchema, type Method, type MetricType, type MetricsDefinition, type MiddlewareContractDetails, type MiddlewareOrMiddlewareWithTypedHandler, type MultipartForm, type NestableRouterBasedHandler, type NumberOnlyObject, OpenTelemetryCollector, type ParamsDictionary, type ParamsObject, type PathBasedHandler, type PathMatch, type PathOrMiddlewareBasedHandler, type PathParamHttpContractDetails, type PathParamMethod, type QueryObject, type RawTypedResponseBody, type RequestContext, type ResolvedForklaunchAuthRequest, type ResolvedForklaunchRequest, type ResponseBody, type ResponseCompiledSchema, type ResponseShape, type ResponsesObject, type SchemaAuthMethods, type SdkClient, type SdkRouter, type ServerSentEventBody, type StatusCode, type StringOnlyObject, type TelemetryOptions, type TextBody, type TypedBody, type TypedHandler, type TypedMiddlewareDefinition, type TypedNestableMiddlewareDefinition, type TypedResponseBody, type UnknownBody, type UnknownResponseBody, type UnpackSdkClientInput, type UrlEncodedForm, type ValidSdkClientInput, delete_, discriminateBody, discriminateResponseBodies, enrichExpressLikeSend, evaluateTelemetryOptions, generateMcpServer, generateSwaggerDocument, get, getCodeForStatus, head, httpRequestsTotalCounter, httpServerDurationHistogram, isClientError, isForklaunchRequest, isForklaunchRouter, isInformational, isRedirection, isServerError, isSuccessful, isValidStatusCode, logger, meta, metricsDefinitions, middleware, options, patch, post, put, recordMetric, trace, typedAuthHandler, typedHandler };
+export { ATTR_API_NAME, ATTR_CORRELATION_ID, type AuthMethods, type AuthMethodsBase, type BasicAuthMethods, type Body, type BodyObject, type ConstrainedForklaunchRouter, type ContractDetails, type ContractDetailsExpressLikeSchemaHandler, type ContractDetailsOrMiddlewareOrTypedHandler, type DocsConfiguration, type ErrorContainer, type ExpressLikeAuthMapper, type ExpressLikeHandler, type ExpressLikeRouter, type ExpressLikeSchemaAuthMapper, type ExpressLikeSchemaHandler, type ExpressLikeTypedHandler, type ExtractBody, type ExtractContentType, type ExtractLiveTypeFn, type ExtractResponseBody, type ExtractedParamsObject, type FetchFunction, type FileBody, type ForklaunchBaseRequest, ForklaunchExpressLikeApplication, ForklaunchExpressLikeRouter, type ForklaunchNextFunction, type ForklaunchRequest, type ForklaunchResErrors, type ForklaunchResHeaders, type ForklaunchResponse, type ForklaunchRoute, type ForklaunchRouter, type ForklaunchSendableData, type ForklaunchStatusResponse, HTTPStatuses, type HeadersObject, type HttpContractDetails, type HttpMethod, type JsonBody, type JwtAuthMethods, type LiveSdkFunction, type LiveTypeFunction, type LiveTypeFunctionRequestInit, type LiveTypeRouteDefinition, type LogFn, type LoggerMeta, type MapControllerToSdk, type MapParamsSchema, type MapReqBodySchema, type MapReqHeadersSchema, type MapReqQuerySchema, type MapResBodyMapSchema, type MapResHeadersSchema, type MapSchema, type MapToFetch, type MapToSdk, type MapVersionedReqsSchema, type MapVersionedRespsSchema, type Method, type MetricType, type MetricsDefinition, type MiddlewareContractDetails, type MiddlewareOrMiddlewareWithTypedHandler, type MultipartForm, type NestableRouterBasedHandler, type NumberOnlyObject, OPENAPI_DEFAULT_VERSION, OpenTelemetryCollector, type ParamsDictionary, type ParamsObject, type PathBasedHandler, type PathMatch, type PathOrMiddlewareBasedHandler, type PathParamHttpContractDetails, type PathParamMethod, type QueryObject, type RawTypedResponseBody, type RequestContext, type ResolvedForklaunchAuthRequest, type ResolvedForklaunchRequest, type ResolvedForklaunchResponse, type ResponseBody, type ResponseCompiledSchema, type ResponseShape, type ResponsesObject, type RouterMap, type SchemaAuthMethods, type SdkHandler, type SdkRouter, type ServerSentEventBody, type StatusCode, type StringOnlyObject, type TelemetryOptions, type TextBody, type ToFetchMap, type TypedBody, type TypedHandler, type TypedMiddlewareDefinition, type TypedNestableMiddlewareDefinition, type TypedRequestBody, type TypedResponseBody, type UnknownBody, type UnknownResponseBody, type UrlEncodedForm, type VersionSchema, type VersionedRequests, type VersionedResponses, delete_, discriminateBody, discriminateResponseBodies, enrichExpressLikeSend, evaluateTelemetryOptions, generateMcpServer, generateOpenApiSpecs, get, getCodeForStatus, head, httpRequestsTotalCounter, httpServerDurationHistogram, isClientError, isForklaunchRequest, isForklaunchRouter, isInformational, isRedirection, isServerError, isSuccessful, isValidStatusCode, logger, meta, metricsDefinitions, middleware, options, patch, post, put, recordMetric, sdkClient, sdkRouter, trace, typedAuthHandler, typedHandler };