@temporary-name/server 1.9.3-alpha.beffd198e2d5853e3d12fa1517c8c9c06bbe6cee → 1.9.3-alpha.cd9bac3545348e08cfaddb66f59c70d314145115

package/dist/adapters/aws-lambda/index.d.mts

@@ -1,10 +1,10 @@
 import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@temporary-name/standard-server-aws-lambda';
-import { C as Context, m as Router } from '../../shared/server.BfraJHay.mjs';
-import { b as StandardHandlerOptions, F as FriendlyStandardHandleOptions } from '../../shared/server.CfPVwdtY.mjs';
+import { C as Context, l as Router } from '../../shared/server.zsKBRxsz.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.CunymBH3.mjs';
 import '@temporary-name/zod';
 
-interface AwsLambdaHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, SendStandardResponseOptions {
+interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
 }
 type AwsLambdaHandleResult = {
     matched: true;
@@ -20,7 +20,7 @@ type AwsLambdaHandleResult = {
 declare class AwsLambdaHandler<T extends Context> {
     private readonly sendStandardResponseOptions;
     private readonly standardHandler;
-    constructor(router: Router<T>, options?: AwsLambdaHandlerOptions<T>);
+    constructor(router: Router<T>, options?: AwsLambdaHandlerOptions);
     handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<AwsLambdaHandleResult>;
 }
 

package/dist/adapters/aws-lambda/index.d.ts

@@ -1,10 +1,10 @@
 import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@temporary-name/standard-server-aws-lambda';
-import { C as Context, m as Router } from '../../shared/server.BfraJHay.js';
-import { b as StandardHandlerOptions, F as FriendlyStandardHandleOptions } from '../../shared/server.B_TpRN8E.js';
+import { C as Context, l as Router } from '../../shared/server.zsKBRxsz.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.DGMnYd7G.js';
 import '@temporary-name/zod';
 
-interface AwsLambdaHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, SendStandardResponseOptions {
+interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
 }
 type AwsLambdaHandleResult = {
     matched: true;
@@ -20,7 +20,7 @@ type AwsLambdaHandleResult = {
 declare class AwsLambdaHandler<T extends Context> {
     private readonly sendStandardResponseOptions;
     private readonly standardHandler;
-    constructor(router: Router<T>, options?: AwsLambdaHandlerOptions<T>);
+    constructor(router: Router<T>, options?: AwsLambdaHandlerOptions);
     handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<AwsLambdaHandleResult>;
 }
 

package/dist/adapters/aws-lambda/index.mjs

@@ -1,19 +1,18 @@
 import { resolveMaybeOptionalOptions } from '@temporary-name/shared';
 import { toStandardLazyRequest, sendStandardResponse } from '@temporary-name/standard-server-aws-lambda';
-import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.CYa9puL2.mjs';
+import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.xNz5cP2B.mjs';
 import '@temporary-name/standard-server';
 import '@temporary-name/server';
 import 'rou3';
-import '../../shared/server.Cza0RB3u.mjs';
+import '../../shared/server.BCY45g2x.mjs';
 import '@temporary-name/zod';
-import '../../shared/server.ChOv1yG3.mjs';
-import '../../shared/server.CQIFwyhc.mjs';
+import '../../shared/server.BETu17rq.mjs';
 
 class AwsLambdaHandler {
   sendStandardResponseOptions;
   standardHandler;
   constructor(router, options = {}) {
-    this.standardHandler = new StandardHandler(router, options);
+    this.standardHandler = new StandardHandler(router);
     this.sendStandardResponseOptions = options;
   }
   async handle(event, responseStream, ...rest) {

package/dist/adapters/fetch/index.d.mts

@@ -1,7 +1,7 @@
 import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { ToFetchResponseOptions } from '@temporary-name/standard-server-fetch';
-import { C as Context, m as Router } from '../../shared/server.BfraJHay.mjs';
-import { b as StandardHandlerOptions, F as FriendlyStandardHandleOptions } from '../../shared/server.CfPVwdtY.mjs';
+import { C as Context, l as Router } from '../../shared/server.zsKBRxsz.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.CunymBH3.mjs';
 import '@temporary-name/zod';
 
 type FetchHandleResult = {
@@ -11,7 +11,7 @@ type FetchHandleResult = {
     matched: false;
     response: undefined;
 };
-interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions, StandardHandlerOptions<T> {
+interface FetchHandlerOptions extends ToFetchResponseOptions {
 }
 /**
  * OpenAPI Handler for Fetch Server
@@ -22,7 +22,7 @@ interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions,
 declare class FetchHandler<T extends Context> {
     private readonly toFetchResponseOptions;
     private readonly standardHandler;
-    constructor(router: Router<T>, options?: NoInfer<FetchHandlerOptions<T>>);
+    constructor(router: Router<T>, options?: NoInfer<FetchHandlerOptions>);
     handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
 }
 

package/dist/adapters/fetch/index.d.ts

@@ -1,7 +1,7 @@
 import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { ToFetchResponseOptions } from '@temporary-name/standard-server-fetch';
-import { C as Context, m as Router } from '../../shared/server.BfraJHay.js';
-import { b as StandardHandlerOptions, F as FriendlyStandardHandleOptions } from '../../shared/server.B_TpRN8E.js';
+import { C as Context, l as Router } from '../../shared/server.zsKBRxsz.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.DGMnYd7G.js';
 import '@temporary-name/zod';
 
 type FetchHandleResult = {
@@ -11,7 +11,7 @@ type FetchHandleResult = {
     matched: false;
     response: undefined;
 };
-interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions, StandardHandlerOptions<T> {
+interface FetchHandlerOptions extends ToFetchResponseOptions {
 }
 /**
  * OpenAPI Handler for Fetch Server
@@ -22,7 +22,7 @@ interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions,
 declare class FetchHandler<T extends Context> {
     private readonly toFetchResponseOptions;
     private readonly standardHandler;
-    constructor(router: Router<T>, options?: NoInfer<FetchHandlerOptions<T>>);
+    constructor(router: Router<T>, options?: NoInfer<FetchHandlerOptions>);
     handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
 }
 

package/dist/adapters/fetch/index.mjs

@@ -1,19 +1,18 @@
 import { resolveMaybeOptionalOptions } from '@temporary-name/shared';
 import { toStandardLazyRequest, toFetchResponse } from '@temporary-name/standard-server-fetch';
-import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.CYa9puL2.mjs';
+import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.xNz5cP2B.mjs';
 import '@temporary-name/standard-server';
 import '@temporary-name/server';
 import 'rou3';
-import '../../shared/server.Cza0RB3u.mjs';
+import '../../shared/server.BCY45g2x.mjs';
 import '@temporary-name/zod';
-import '../../shared/server.ChOv1yG3.mjs';
-import '../../shared/server.CQIFwyhc.mjs';
+import '../../shared/server.BETu17rq.mjs';
 
 class FetchHandler {
   toFetchResponseOptions;
   standardHandler;
   constructor(router, options = {}) {
-    this.standardHandler = new StandardHandler(router, options);
+    this.standardHandler = new StandardHandler(router);
     this.toFetchResponseOptions = options;
   }
   async handle(request, ...rest) {

package/dist/adapters/node/index.d.mts

@@ -1,7 +1,7 @@
 import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@temporary-name/standard-server-node';
-import { C as Context, m as Router } from '../../shared/server.BfraJHay.mjs';
-import { b as StandardHandlerOptions, F as FriendlyStandardHandleOptions } from '../../shared/server.CfPVwdtY.mjs';
+import { C as Context, l as Router } from '../../shared/server.zsKBRxsz.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.CunymBH3.mjs';
 import '@temporary-name/zod';
 
 type NodeHttpHandleResult = {
@@ -9,7 +9,7 @@ type NodeHttpHandleResult = {
 } | {
     matched: false;
 };
-interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions, StandardHandlerOptions<T> {
+interface NodeHttpHandlerOptions extends SendStandardResponseOptions {
 }
 /**
  * OpenAPI Handler for Node Server
@@ -17,10 +17,10 @@ interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponse
  * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
  * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
  */
-declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
+declare class NodeHttpHandler<T extends Context> {
     private readonly sendStandardResponseOptions;
     private readonly standardHandler;
-    constructor(router: Router<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    constructor(router: Router<T>, options?: NoInfer<NodeHttpHandlerOptions>);
     handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
 }
 

package/dist/adapters/node/index.d.ts

@@ -1,7 +1,7 @@
 import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@temporary-name/standard-server-node';
-import { C as Context, m as Router } from '../../shared/server.BfraJHay.js';
-import { b as StandardHandlerOptions, F as FriendlyStandardHandleOptions } from '../../shared/server.B_TpRN8E.js';
+import { C as Context, l as Router } from '../../shared/server.zsKBRxsz.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.DGMnYd7G.js';
 import '@temporary-name/zod';
 
 type NodeHttpHandleResult = {
@@ -9,7 +9,7 @@ type NodeHttpHandleResult = {
 } | {
     matched: false;
 };
-interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions, StandardHandlerOptions<T> {
+interface NodeHttpHandlerOptions extends SendStandardResponseOptions {
 }
 /**
  * OpenAPI Handler for Node Server
@@ -17,10 +17,10 @@ interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponse
  * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
  * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
  */
-declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
+declare class NodeHttpHandler<T extends Context> {
     private readonly sendStandardResponseOptions;
     private readonly standardHandler;
-    constructor(router: Router<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    constructor(router: Router<T>, options?: NoInfer<NodeHttpHandlerOptions>);
     handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
 }
 

package/dist/adapters/node/index.mjs

@@ -1,19 +1,18 @@
 import { resolveMaybeOptionalOptions } from '@temporary-name/shared';
 import { toStandardLazyRequest, sendStandardResponse } from '@temporary-name/standard-server-node';
-import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.CYa9puL2.mjs';
+import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.xNz5cP2B.mjs';
 import '@temporary-name/standard-server';
 import '@temporary-name/server';
 import 'rou3';
-import '../../shared/server.Cza0RB3u.mjs';
+import '../../shared/server.BCY45g2x.mjs';
 import '@temporary-name/zod';
-import '../../shared/server.ChOv1yG3.mjs';
-import '../../shared/server.CQIFwyhc.mjs';
+import '../../shared/server.BETu17rq.mjs';
 
 class NodeHttpHandler {
   sendStandardResponseOptions;
   standardHandler;
   constructor(router, options = {}) {
-    this.standardHandler = new StandardHandler(router, options);
+    this.standardHandler = new StandardHandler(router);
     this.sendStandardResponseOptions = options;
   }
   async handle(request, response, ...rest) {

package/dist/{adapters/standard → handler}/index.d.mts

@@ -1,7 +1,7 @@
-export { F as FriendlyStandardHandleOptions, S as StandardHandleOptions, a as StandardHandleResult, c as StandardHandler, b as StandardHandlerOptions, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server.CfPVwdtY.mjs';
+export { F as FriendlyStandardHandleOptions, S as StandardHandleOptions, a as StandardHandleResult, b as StandardHandler, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../shared/server.CunymBH3.mjs';
 import { AnyProcedure, AnyRouter } from '@temporary-name/server';
 import { StandardLazyRequest, StandardResponse, ORPCError, HTTPPath } from '@temporary-name/shared';
-import '../../shared/server.BfraJHay.mjs';
+import '../shared/server.zsKBRxsz.mjs';
 import '@temporary-name/zod';
 
 declare function decode(request: StandardLazyRequest, pathParams: Record<string, string> | undefined): Promise<{

package/dist/{adapters/standard → handler}/index.d.ts

@@ -1,7 +1,7 @@
-export { F as FriendlyStandardHandleOptions, S as StandardHandleOptions, a as StandardHandleResult, c as StandardHandler, b as StandardHandlerOptions, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server.B_TpRN8E.js';
+export { F as FriendlyStandardHandleOptions, S as StandardHandleOptions, a as StandardHandleResult, b as StandardHandler, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../shared/server.DGMnYd7G.js';
 import { AnyProcedure, AnyRouter } from '@temporary-name/server';
 import { StandardLazyRequest, StandardResponse, ORPCError, HTTPPath } from '@temporary-name/shared';
-import '../../shared/server.BfraJHay.js';
+import '../shared/server.zsKBRxsz.js';
 import '@temporary-name/zod';
 
 declare function decode(request: StandardLazyRequest, pathParams: Record<string, string> | undefined): Promise<{

package/dist/{adapters/standard → handler}/index.mjs

@@ -1,9 +1,8 @@
-export { S as StandardHandler, b as StandardOpenAPIMatcher, d as decode, c as decodeParams, e as encode, a as encodeError, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server.CYa9puL2.mjs';
+export { S as StandardHandler, b as StandardOpenAPIMatcher, d as decode, c as decodeParams, e as encode, a as encodeError, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../shared/server.xNz5cP2B.mjs';
 import '@temporary-name/shared';
-import '../../shared/server.Cza0RB3u.mjs';
+import '../shared/server.BCY45g2x.mjs';
 import '@temporary-name/standard-server';
 import '@temporary-name/zod';
-import '../../shared/server.ChOv1yG3.mjs';
-import '../../shared/server.CQIFwyhc.mjs';
+import '../shared/server.BETu17rq.mjs';
 import '@temporary-name/server';
 import 'rou3';

package/dist/index.d.mts

@@ -1,8 +1,16 @@
-import { ClientContext, Value, Promisable, Client, MaybeOptionalOptions, HTTPEndpoint as HTTPEndpoint$1, IntersectPick, OptionalIfEmpty, HTTPPath, AsyncIteratorClass, ClientOptions, HTTPMethod } from '@temporary-name/shared';
-export { AsyncIteratorClass, ClientContext, EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, HTTPMethod, HTTPPath, IntersectPick, ORPCError, asyncIteratorToStream as eventIteratorToStream, isDefinedError, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
+import * as z from '@temporary-name/zod';
 import { SchemaClass, core } from '@temporary-name/zod';
-import { C as Context, S as Schemas, I as InferProcedureClientInputs, a as InferSchemaOutput, M as Meta, L as Lazyable, P as Procedure, b as Contract, A as AnyShape, c as MergedSchemas, W as WrapShape, U as UnionToIntersection, d as AnySchema, R as Route, e as Middleware, f as MergedCurrentContext, g as MergedInitialContext, h as AuthType, V as ValidatedAuthContext, i as AuthConfig, B as BuildContextWithAuth, j as ProcedureHandler, k as InferHandlerInputs, l as InferSchemaInput, E as EnhanceRouterOptions, m as Router, n as EnhancedRouter, o as MapInputMiddleware, p as ContractDef, q as InitialSchemas, r as SchemaIssue, s as Schema, t as AnyMiddleware, u as Lazy, v as AnyProcedure, w as AnyRouter, x as InferRouterInitialContext } from './shared/server.BfraJHay.mjs';
-export { a8 as AccessibleLazyRouter, $ as AnyContractDef, ad as ContractProcedureCallbackOptions, a2 as ContractRouter, Z as DefaultProcedureHandlerOptions, a4 as InferRouterCurrentContexts, a3 as InferRouterInitialContexts, a5 as InferRouterInputs, a6 as InferRouterOutputs, z as LAZY_SYMBOL, D as LazyMeta, ae as LazyTraverseContractProceduresOptions, Q as MiddlewareNextFn, X as MiddlewareOptions, T as MiddlewareOutputFn, O as MiddlewareResult, a0 as ProcedureDef, _ as ProcedureHandlerOptions, ac as TraverseContractProcedureCallbackOptions, ab as TraverseContractProceduresOptions, aj as TypeRest, ah as UnlaziedRouter, a9 as createAccessibleLazyRouter, aa as enhanceRouter, J as getLazyMeta, a7 as getRouter, ak as initialSchemas, H as isLazy, a1 as isProcedure, G as lazy, F as lazyInternal, y as mergeCurrentContext, N as mergeMeta, Y as middlewareOutputFn, ag as resolveContractProcedures, af as traverseContractProcedures, K as unlazy, ai as unlazyRouter } from './shared/server.BfraJHay.mjs';
+import * as zod_v4_core from 'zod/v4/core';
+import { $input, $output } from 'zod/v4/core';
+import { ClientContext, Value, Promisable, Client, MaybeOptionalOptions, HTTPEndpoint as HTTPEndpoint$1, IntersectPick, HTTPPath, AsyncIteratorClass, ClientOptions, HTTPMethod } from '@temporary-name/shared';
+export { AsyncIteratorClass, ClientContext, EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, HTTPMethod, HTTPPath, IntersectPick, ORPCError, asyncIteratorToStream as eventIteratorToStream, isDefinedError, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
+import { C as Context, S as Schemas, I as InferProcedureClientInputs, a as InferSchemaOutput, M as Meta, L as Lazyable, P as Procedure, b as Contract, A as AnyShape, c as MergedSchemas, W as WrapShape, U as UnionToIntersection, d as AnySchema, R as Route, e as Middleware, f as MergedCurrentContext, g as MergedInitialContext, V as ValidatedAuthContext, h as AuthConfig, B as BuildContextWithAuth, i as ProcedureHandler, j as InferHandlerInputs, k as InferSchemaInput, E as EnhanceRouterOptions, l as Router, m as EnhancedRouter, n as MapInputMiddleware, o as ContractDef, p as SchemaIssue, q as Schema, r as AnyMiddleware, s as Lazy, t as AnyProcedure } from './shared/server.zsKBRxsz.mjs';
+export { a5 as AccessibleLazyRouter, T as AnyContractDef, _ as AnyRouter, aa as ContractProcedureCallbackOptions, Z as ContractRouter, a1 as InferRouterCurrentContexts, $ as InferRouterInitialContext, a0 as InferRouterInitialContexts, a2 as InferRouterInputs, a3 as InferRouterOutputs, ai as InitialSchemas, v as LAZY_SYMBOL, w as LazyMeta, ab as LazyTraverseContractProceduresOptions, J as MiddlewareNextFn, N as MiddlewareOptions, K as MiddlewareOutputFn, H as MiddlewareResult, X as ProcedureDef, Q as ProcedureHandlerOptions, a9 as TraverseContractProcedureCallbackOptions, a8 as TraverseContractProceduresOptions, ag as TypeRest, ae as UnlaziedRouter, a6 as createAccessibleLazyRouter, a7 as enhanceRouter, D as getLazyMeta, a4 as getRouter, ah as initialSchemas, z as isLazy, Y as isProcedure, y as lazy, x as lazyInternal, u as mergeCurrentContext, G as mergeMeta, O as middlewareOutputFn, ad as resolveContractProcedures, ac as traverseContractProcedures, F as unlazy, af as unlazyRouter } from './shared/server.zsKBRxsz.mjs';
+import * as Draft07 from '@temporary-name/interop/json-schema-typed/draft-07';
+import * as Draft2019 from '@temporary-name/interop/json-schema-typed/draft-2019-09';
+import * as Draft2020 from '@temporary-name/interop/json-schema-typed/draft-2020-12';
+export { a as ZodToJsonSchemaConverter, Z as ZodToJsonSchemaConverterOptions } from './shared/server.CjPiuQYH.mjs';
+import { JSONSchema } from '@temporary-name/server/openapi';
 export { getEventMeta, withEventMeta } from '@temporary-name/standard-server';
 
 type ProcedureClient<TClientContext extends ClientContext, TSchemas extends Schemas> = Client<TClientContext, InferProcedureClientInputs<TSchemas>, InferSchemaOutput<TSchemas['outputSchema']>>;
@@ -80,7 +88,7 @@ declare class ProcedureBuilder<TInitialContext extends Context, TCurrentContext
      */
     use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>>(middleware: Middleware<TCurrentContext, UOutContext, unknown, unknown, TMeta>): ProcedureBuilder<TInitialContext, MergedCurrentContext<TCurrentContext, UOutContext>, TSchemas, TMeta, TGateName>;
     use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext, UOutContext, unknown, unknown, TMeta>): ProcedureBuilder<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TSchemas, TMeta, TGateName>;
-    useAuth<const TAuthType extends AuthType & {}, TAuthContext extends ValidatedAuthContext = false>(type: TAuthType, ...rest: OptionalIfEmpty<AuthConfig<TAuthType, TAuthContext>>): ProcedureBuilder<TInitialContext, BuildContextWithAuth<TCurrentContext, TAuthContext>, TSchemas, TMeta, TGateName>;
+    useAuth<TAuthContext extends ValidatedAuthContext = false>(config: AuthConfig<TAuthContext, TCurrentContext, TMeta>): ProcedureBuilder<TInitialContext, BuildContextWithAuth<TCurrentContext, TAuthContext>, TSchemas, TMeta, TGateName>;
     useGating<const TInferredGateName extends string>(gates: TInferredGateName[], isGateEnabled: (gate: TInferredGateName, ctx: TCurrentContext) => boolean): BuilderWithMiddlewares<MergedInitialContext<TInitialContext, Context, TCurrentContext>, MergedCurrentContext<TCurrentContext, {
         isGateEnabled: typeof isGateEnabled;
     }>, TSchemas, TMeta, TInferredGateName>;
@@ -147,12 +155,12 @@ declare class Builder<TInitialContext extends Context, TCurrentContext extends C
     middleware<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, TInput, TOutput = any>(// = any here is important to make middleware can be used in any output by default
     middleware: Middleware<TInitialContext, UOutContext, TInput, TOutput, TMeta>): DecoratedMiddleware<TInitialContext, UOutContext, TInput, TOutput, TMeta>;
 }
-type ApiBuilder<TMeta extends Meta> = Builder<{}, {}, InitialSchemas, TMeta, never>;
-interface ApiBuilderOpts<TMeta extends Meta> {
-    meta?: TMeta;
-}
-declare function createApiBuilder<TMeta extends Meta = Record<never, never>>(opts?: ApiBuilderOpts<TMeta>): ApiBuilder<TMeta>;
-declare const os: ApiBuilder<Record<never, never>>;
+declare const baseApi: Builder<{}, {}, {
+    pathSchema: z.KrustyObject<{}, zod_v4_core.$strict, z.KrustyInternals<string>>;
+    querySchema: z.KrustyObject<{}, zod_v4_core.$strict, z.KrustyInternals<string>>;
+    bodySchema: z.KrustyObject<{}, zod_v4_core.$strict, z.KrustyInternals<string>>;
+    outputSchema: z.KrustyUnknown<z.KrustyInternals<string>>;
+}, Record<never, never>, never>;
 
 interface ValidationErrorOptions extends ErrorOptions {
     message: string;
@@ -185,6 +193,262 @@ interface EventIteratorSchemaDetails {
 declare function eventIterator<TYieldIn, TYieldOut, TReturnIn = unknown, TReturnOut = unknown>(yields: Schema<TYieldIn, TYieldOut>, returns?: Schema<TReturnIn, TReturnOut>): Schema<AsyncIteratorObject<TYieldIn, TReturnIn, void>, AsyncIteratorClass<TYieldOut, TReturnOut, void>>;
 declare function getEventIteratorSchemaDetails(schema: AnySchema | undefined): undefined | EventIteratorSchemaDetails;
 
+type JsonSchema = Draft2020.JSONSchema | Draft2019.JSONSchema | Draft07.JSONSchema;
+declare enum JsonSchemaXNativeType {
+    BigInt = "bigint",
+    RegExp = "regexp",
+    Date = "date",
+    Url = "url",
+    Set = "set",
+    Map = "map"
+}
+
+interface experimental_JsonSchemaCoerceOptions {
+    components?: Record<string, JsonSchema>;
+}
+declare class experimental_JsonSchemaCoercer {
+    #private;
+    coerce(schema: JsonSchema, value: unknown, options?: experimental_JsonSchemaCoerceOptions): unknown;
+}
+
+/**
+ * Zod registry for customizing generated JSON schema, can use both for .input and .output
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_REGISTRY } from '@temporary-name/zod/zod4'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.number(),
+ * })
+ *
+ * JSON_SCHEMA_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: 20 }],
+ * })
+ * ```
+ */
+declare const JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<{
+    $anchor?: string;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    $dynamicAnchor?: string;
+    $dynamicRef?: string;
+    $id?: string;
+    $ref?: string;
+    $schema?: string;
+    $vocabulary?: Record<string, string>;
+    additionalItems?: JSONSchema;
+    additionalProperties?: JSONSchema;
+    allOf?: (JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    anyOf?: (JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    const?: typeof $input | typeof $output | undefined;
+    contains?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    contentEncoding?: "7bit" | "8bit" | "base64" | "binary" | "ietf-token" | "quoted-printable" | "x-token";
+    contentMediaType?: string;
+    contentSchema?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    default?: typeof $input | typeof $output | undefined;
+    definitions?: Record<string, JSONSchema>;
+    dependencies?: Record<string, (string[] | readonly string[]) | JSONSchema>;
+    dependentRequired?: Record<string, string[] | readonly string[]>;
+    dependentSchemas?: Record<string, JSONSchema>;
+    deprecated?: boolean;
+    description?: string;
+    else?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    enum?: ((typeof $input | typeof $output)[] | readonly (typeof $input | typeof $output)[]) | undefined;
+    examples?: ((typeof $input | typeof $output)[] | readonly (typeof $input | typeof $output)[]) | undefined;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    format?: string;
+    if?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    items?: JSONSchema;
+    maxContains?: number;
+    maximum?: number;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    minContains?: number;
+    minimum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    multipleOf?: number;
+    not?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    oneOf?: (JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    pattern?: string;
+    patternProperties?: Record<string, JSONSchema>;
+    prefixItems?: (JSONSchema<any, JSONSchema.TypeValue>[] | readonly JSONSchema<any, JSONSchema.TypeValue>[]) | JSONSchema;
+    properties?: Record<string, JSONSchema>;
+    propertyNames?: JSONSchema;
+    readOnly?: boolean;
+    required?: string[] | readonly string[];
+    then?: JSONSchema<typeof $input | typeof $output, JSONSchema.TypeValue> | undefined;
+    title?: string;
+    type?: JSONSchema.TypeValue | undefined;
+    unevaluatedItems?: JSONSchema;
+    unevaluatedProperties?: JSONSchema;
+    uniqueItems?: boolean;
+    writeOnly?: boolean;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
+/**
+ * Zod registry for customizing generated JSON schema, only useful for .input
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_INPUT_REGISTRY } from '@temporary-name/zod/zod4'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.string().transform(v => Number(v)),
+ * })
+ *
+ * JSON_SCHEMA_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: "20" }],
+ * })
+ * ```
+ */
+declare const JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
+    $anchor?: string;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    $dynamicAnchor?: string;
+    $dynamicRef?: string;
+    $id?: string;
+    $ref?: string;
+    $schema?: string;
+    $vocabulary?: Record<string, string>;
+    additionalItems?: JSONSchema;
+    additionalProperties?: JSONSchema;
+    allOf?: (JSONSchema<typeof $input, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input, JSONSchema.TypeValue>[]) | undefined;
+    anyOf?: (JSONSchema<typeof $input, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input, JSONSchema.TypeValue>[]) | undefined;
+    const?: typeof $input | undefined;
+    contains?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    contentEncoding?: "7bit" | "8bit" | "base64" | "binary" | "ietf-token" | "quoted-printable" | "x-token";
+    contentMediaType?: string;
+    contentSchema?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    default?: typeof $input | undefined;
+    definitions?: Record<string, JSONSchema>;
+    dependencies?: Record<string, (string[] | readonly string[]) | JSONSchema>;
+    dependentRequired?: Record<string, string[] | readonly string[]>;
+    dependentSchemas?: Record<string, JSONSchema>;
+    deprecated?: boolean;
+    description?: string;
+    else?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    enum?: ((typeof $input)[] | readonly (typeof $input)[]) | undefined;
+    examples?: ((typeof $input)[] | readonly (typeof $input)[]) | undefined;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    format?: string;
+    if?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    items?: JSONSchema;
+    maxContains?: number;
+    maximum?: number;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    minContains?: number;
+    minimum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    multipleOf?: number;
+    not?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    oneOf?: (JSONSchema<typeof $input, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $input, JSONSchema.TypeValue>[]) | undefined;
+    pattern?: string;
+    patternProperties?: Record<string, JSONSchema>;
+    prefixItems?: (JSONSchema<any, JSONSchema.TypeValue>[] | readonly JSONSchema<any, JSONSchema.TypeValue>[]) | JSONSchema;
+    properties?: Record<string, JSONSchema>;
+    propertyNames?: JSONSchema;
+    readOnly?: boolean;
+    required?: string[] | readonly string[];
+    then?: JSONSchema<typeof $input, JSONSchema.TypeValue> | undefined;
+    title?: string;
+    type?: JSONSchema.TypeValue | undefined;
+    unevaluatedItems?: JSONSchema;
+    unevaluatedProperties?: JSONSchema;
+    uniqueItems?: boolean;
+    writeOnly?: boolean;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
+/**
+ * Zod registry for customizing generated JSON schema, only useful for .input
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_OUTPUT_REGISTRY } from '@temporary-name/zod/zod4'
+ *
+ * const user = z.object({
+ *   name: z.string(),
+ *   age: z.string().transform(v => Number(v)),
+ * })
+ *
+ * JSON_SCHEMA_OUTPUT_REGISTRY.add(user, {
+ *   examples: [{ name: 'John', age: 20 }],
+ * })
+ * ```
+ */
+declare const JSON_SCHEMA_OUTPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
+    $anchor?: string;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    $dynamicAnchor?: string;
+    $dynamicRef?: string;
+    $id?: string;
+    $ref?: string;
+    $schema?: string;
+    $vocabulary?: Record<string, string>;
+    additionalItems?: JSONSchema;
+    additionalProperties?: JSONSchema;
+    allOf?: (JSONSchema<typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    anyOf?: (JSONSchema<typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    const?: typeof $output | undefined;
+    contains?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    contentEncoding?: "7bit" | "8bit" | "base64" | "binary" | "ietf-token" | "quoted-printable" | "x-token";
+    contentMediaType?: string;
+    contentSchema?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    default?: typeof $output | undefined;
+    definitions?: Record<string, JSONSchema>;
+    dependencies?: Record<string, (string[] | readonly string[]) | JSONSchema>;
+    dependentRequired?: Record<string, string[] | readonly string[]>;
+    dependentSchemas?: Record<string, JSONSchema>;
+    deprecated?: boolean;
+    description?: string;
+    else?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    enum?: ((typeof $output)[] | readonly (typeof $output)[]) | undefined;
+    examples?: ((typeof $output)[] | readonly (typeof $output)[]) | undefined;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    format?: string;
+    if?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    items?: JSONSchema;
+    maxContains?: number;
+    maximum?: number;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    minContains?: number;
+    minimum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    multipleOf?: number;
+    not?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    oneOf?: (JSONSchema<typeof $output, JSONSchema.TypeValue>[] | readonly JSONSchema<typeof $output, JSONSchema.TypeValue>[]) | undefined;
+    pattern?: string;
+    patternProperties?: Record<string, JSONSchema>;
+    prefixItems?: (JSONSchema<any, JSONSchema.TypeValue>[] | readonly JSONSchema<any, JSONSchema.TypeValue>[]) | JSONSchema;
+    properties?: Record<string, JSONSchema>;
+    propertyNames?: JSONSchema;
+    readOnly?: boolean;
+    required?: string[] | readonly string[];
+    then?: JSONSchema<typeof $output, JSONSchema.TypeValue> | undefined;
+    title?: string;
+    type?: JSONSchema.TypeValue | undefined;
+    unevaluatedItems?: JSONSchema;
+    unevaluatedProperties?: JSONSchema;
+    uniqueItems?: boolean;
+    writeOnly?: boolean;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
+
 declare function isStartWithMiddlewares(middlewares: readonly AnyMiddleware[], compare: readonly AnyMiddleware[]): boolean;
 declare function mergeMiddlewares(first: readonly AnyMiddleware[], second: readonly AnyMiddleware[], options: {
     dedupeLeading: boolean;
@@ -204,16 +468,6 @@ declare function createAssertedLazyProcedure(lazied: Lazy<any>): Lazy<AnyProcedu
  */
 declare function call<TInitialContext extends Context, TSchemas extends Schemas, TMeta extends Meta>(procedure: Lazyable<Procedure<TInitialContext, any, TSchemas, TMeta>>, input: InferProcedureClientInputs<TSchemas>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, {}> & Omit<ClientOptions<{}>, 'context'>>): Promise<InferSchemaOutput<TSchemas['outputSchema']>>;
 
-type RouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext = {}> = TRouter extends Procedure<any, any, infer USchemas, any> ? ProcedureClient<TClientContext, USchemas> : {
-    [K in keyof TRouter]: TRouter[K] extends Lazyable<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : never;
-};
-/**
- * Create Server-side client from a router.
- *
- * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
- */
-declare function createRouterClient<T extends AnyRouter, TClientContext extends ClientContext>(router: Lazyable<T | undefined>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<InferRouterInitialContext<T>, TClientContext>>): RouterClient<T, TClientContext>;
-
 declare function isSchemaIssue(issue: unknown): issue is SchemaIssue;
 
 type HTTPEndpoint = `${HTTPMethod} ${HTTPPath}`;
@@ -238,5 +492,5 @@ declare function parseEndpointDefinition(stringsOrEndpoint: TemplateStringsArray
     pathSchema: AnySchema;
 };
 
-export { AnyMiddleware, AnyProcedure, AnyRouter, AnySchema, AnyShape, BuildContextWithAuth, Builder, BuilderWithMiddlewares, Context, Contract, ContractDef, DecoratedProcedure, EnhanceRouterOptions, EnhancedRouter, InferHandlerInputs, InferProcedureClientInputs, InferRouterInitialContext, InferSchemaInput, InferSchemaOutput, InitialSchemas, Lazy, Lazyable, MapInputMiddleware, MergedCurrentContext, MergedInitialContext, MergedSchemas, Meta, Middleware, Procedure, ProcedureBuilder, ProcedureHandler, Router, Schema, SchemaIssue, Schemas, UnionToIntersection, ValidationError, WrapShape, addMiddleware, call, createApiBuilder, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, endpointRegex, eventIterator, getDynamicParams, getEventIteratorSchemaDetails, isSchemaIssue, isStartWithMiddlewares, mergeMiddlewares, os, parseEndpointDefinition, standardizeHTTPPath };
-export type { ApiBuilder, BuilderDef, CreateProcedureClientOptions, DecoratedMiddleware, EventIteratorSchemaDetails, HTTPEndpoint, ProcedureClient, RouterBuilder, RouterClient, ValidationErrorOptions };
+export { AnyMiddleware, AnyProcedure, AnySchema, AnyShape, BuildContextWithAuth, Builder, BuilderWithMiddlewares, Context, Contract, ContractDef, DecoratedProcedure, EnhanceRouterOptions, EnhancedRouter, InferHandlerInputs, InferProcedureClientInputs, InferSchemaInput, InferSchemaOutput, JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, JsonSchemaXNativeType, Lazy, Lazyable, MapInputMiddleware, MergedCurrentContext, MergedInitialContext, MergedSchemas, Meta, Middleware, Procedure, ProcedureBuilder, ProcedureHandler, Router, Schema, SchemaIssue, Schemas, UnionToIntersection, ValidationError, WrapShape, addMiddleware, baseApi, call, createAssertedLazyProcedure, createProcedureClient, decorateMiddleware, endpointRegex, eventIterator, experimental_JsonSchemaCoercer, getDynamicParams, getEventIteratorSchemaDetails, isSchemaIssue, isStartWithMiddlewares, mergeMiddlewares, parseEndpointDefinition, standardizeHTTPPath };
+export type { BuilderDef, CreateProcedureClientOptions, DecoratedMiddleware, EventIteratorSchemaDetails, HTTPEndpoint, JsonSchema, ProcedureClient, RouterBuilder, ValidationErrorOptions, experimental_JsonSchemaCoerceOptions };