@temporary-name/server 1.9.3-alpha.1a5ff4923d25c9d83e80d717687ebc859f5312f2 → 1.9.3-alpha.205fb2d0874fa3b8bbf83112a63016937380442e

package/dist/index.d.ts

@@ -1,42 +1,62 @@
-import { Schemas, ErrorMap, Meta, ContractProcedure, MergedErrorMap, Route, AnySchema, MergedSchemas, InferHandlerInputs, InferSchemaInput, ContractRouter, ContractProcedureDef, InitialSchemas, AnyContractRouter, InferContractRouterErrorMap, InferContractRouterMeta, AnyContractProcedure, InferProcedureClientInputs, InferSchemaOutput, ErrorFromErrorMap, Schema } from '@temporary-name/contract';
-export { ContractProcedure, ContractProcedureDef, ContractRouter, ErrorMap, ErrorMapItem, InferSchemaInput, InferSchemaOutput, MergedErrorMap, Meta, OutputStructure, Route, Schema, ValidationError, eventIterator, validateORPCError } from '@temporary-name/contract';
-import { ClientContext, MaybeOptionalOptions, IntersectPick, HTTPPath, ClientOptions, ClientPromiseResult } from '@temporary-name/shared';
-export { AsyncIteratorClass, ClientContext, EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, HTTPMethod, HTTPPath, IntersectPick, ORPCError, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, isDefinedError, onError, onFinish, onStart, onSuccess, safe, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
-import { SchemaClass } from '@temporary-name/zod';
-import { C as Context, P as Procedure, a as CreateProcedureClientOptions, b as ProcedureClient, M as Middleware, O as ORPCErrorConstructorMap, c as MergedInitialContext, d as MergedCurrentContext, e as ProcedureHandler, E as EnhanceRouterOptions, R as Router, f as EnhancedRouter, g as MapInputMiddleware, A as AnyMiddleware, L as Lazy, h as AnyProcedure, i as Lazyable, j as AnyRouter, I as InferRouterInitialContext } from './shared/server.DecvGKtb.js';
-export { U as AccessibleLazyRouter, Z as ContractProcedureCallbackOptions, N as InferRouterCurrentContexts, K as InferRouterInitialContexts, Q as InferRouterInputs, S as InferRouterOutputs, o as LAZY_SYMBOL, p as LazyMeta, _ as LazyTraverseContractProceduresOptions, x as MiddlewareNextFn, w as MiddlewareNextFnOptions, z as MiddlewareOptions, y as MiddlewareOutputFn, v as MiddlewareResult, l as ORPCErrorConstructorMapItem, k as ORPCErrorConstructorMapItemOptions, H as ProcedureClientInterceptorOptions, F as ProcedureDef, D as ProcedureHandlerOptions, Y as TraverseContractProcedureCallbackOptions, X as TraverseContractProceduresOptions, a1 as UnlaziedRouter, V as createAccessibleLazyRouter, n as createORPCErrorConstructorMap, J as createProcedureClient, W as enhanceRouter, t as getLazyMeta, T as getRouter, s as isLazy, G as isProcedure, r as lazy, q as lazyInternal, m as mergeCurrentContext, B as middlewareOutputFn, a0 as resolveContractProcedures, $ as traverseContractProcedures, u as unlazy, a2 as unlazyRouter } from './shared/server.DecvGKtb.js';
+import * as z from '@temporary-name/zod';
+import { SchemaClass, core } from '@temporary-name/zod';
+export { z as baseZ };
+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, asyncIteratorToStream as eventIteratorToStream, 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, E as ErrorMap, V as ValidatedAuthContext, h as AuthConfig, B as BuildContextWithAuth, i as ProcedureHandler, j as InferHandlerInputs, k as InferSchemaInput, l as EnhanceRouterOptions, m as Router, n as EnhancedRouter, o as MapInputMiddleware, p as ContractDef, q as Schema, r as AnyMiddleware, s as Lazy, t as AnyProcedure, u as SchemaIssue } from './shared/server.B5ntjz_x.js';
+export { D as APIError, y as APIErrorConstructor, ak as AccessibleLazyRouter, a9 as AnyContractDef, ad as AnyRouter, F as BadRequestError, ap as ContractProcedureCallbackOptions, ac as ContractRouter, z as CustomAPIErrorConstructor, H as ForbiddenError, ag as InferRouterCurrentContexts, ae as InferRouterInitialContext, af as InferRouterInitialContexts, ah as InferRouterInputs, ai as InferRouterOutputs, ax as InitialSchemas, J as InternalServerError, X as LAZY_SYMBOL, Y as LazyMeta, aq as LazyTraverseContractProceduresOptions, a4 as MiddlewareNextFn, a6 as MiddlewareOptions, a5 as MiddlewareOutputFn, a3 as MiddlewareResult, N as NotFoundError, aa as ProcedureDef, a8 as ProcedureHandlerOptions, ao as TraverseContractProcedureCallbackOptions, an as TraverseContractProceduresOptions, av as TypeRest, G as UnauthorizedError, at as UnlaziedRouter, x as ValidationError, w as ValidationErrorOptions, al as createAccessibleLazyRouter, T as encodeError, am as enhanceRouter, a0 as getLazyMeta, aj as getRouter, aw as initialSchemas, O as isAPIErrorStatus, $ as isLazy, ab as isProcedure, _ as lazy, Z as lazyInternal, K as makeErrors, v as mergeCurrentContext, a2 as mergeMeta, a7 as middlewareOutputFn, as as resolveContractProcedures, Q as toAPIError, ar as traverseContractProcedures, a1 as unlazy, au as unlazyRouter } from './shared/server.B5ntjz_x.js';
+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.js';
+import { JSONSchema } from '@temporary-name/server/openapi';
 export { getEventMeta, withEventMeta } from '@temporary-name/standard-server';
 
-declare class DecoratedProcedure<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> extends Procedure<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta> {
+type ProcedureClient<TClientContext extends ClientContext, TSchemas extends Schemas> = Client<TClientContext, InferProcedureClientInputs<TSchemas>, InferSchemaOutput<TSchemas['outputSchema']>>;
+type CreateProcedureClientOptions<TInitialContext extends Context, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: readonly string[];
+} & (object extends TInitialContext ? {
+    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+} : {
+    context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+});
+/**
+ * Create Server-side client from a procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
+ */
+declare function createProcedureClient<TInitialContext extends Context, TSchemas extends Schemas, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TSchemas, TMeta>>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TClientContext>>): ProcedureClient<TClientContext, TSchemas>;
+
+declare class DecoratedProcedure<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TMeta extends Meta> extends Procedure<TInitialContext, TCurrentContext, TSchemas, TMeta> {
     /**
      * Make this procedure callable (works like a function while still being a procedure).
      *
      * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
      */
-    callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TSchemas['outputSchema'], TErrorMap, TMeta, TClientContext>>): DecoratedProcedure<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta> & ProcedureClient<TClientContext, TSchemas, TErrorMap>;
+    callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TClientContext>>): DecoratedProcedure<TInitialContext, TCurrentContext, TSchemas, TMeta> & ProcedureClient<TClientContext, TSchemas>;
 }
 
-declare class ProcedureBuilder<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta, TGateName extends string> extends ContractProcedure<TSchemas, TErrorMap, TMeta> {
+declare class ProcedureBuilder<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TMeta extends Meta, TGateName extends string> extends Contract<BuilderDef<TSchemas, TMeta>> {
     z: SchemaClass<TGateName>;
-    /**
-     * This property holds the defined options.
-     */
-    '~orpc': BuilderDef<TSchemas, TErrorMap, TMeta>;
-    constructor(def: BuilderDef<TSchemas, TErrorMap, TMeta>);
-    /**
-     * Adds type-safe custom errors to the contract.
-     * The provided errors are spared-merged with any existing errors in the contract.
-     *
-     * @see {@link https://orpc.unnoq.com/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
-     */
-    errors<U extends ErrorMap>(errors: U): ProcedureBuilder<TInitialContext, TCurrentContext, TSchemas, MergedErrorMap<TErrorMap, U>, TMeta, TGateName>;
+    constructor(def: BuilderDef<TSchemas, TMeta>);
     /**
      * Sets or updates the metadata for the contract.
      * The provided metadata is spared-merged with any existing metadata in the contract.
      *
      * @see {@link https://orpc.unnoq.com/docs/metadata Metadata Docs}
      */
-    meta(meta: TMeta): ProcedureBuilder<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta, TGateName>;
+    meta(meta: TMeta): ProcedureBuilder<TInitialContext, TCurrentContext, TSchemas, TMeta, TGateName>;
+    endpoint<U extends AnyShape[]>(strings: TemplateStringsArray, ...values: [...U]): ProcedureBuilder<TInitialContext, TCurrentContext, MergedSchemas<TSchemas, {
+        pathSchema: WrapShape<UnionToIntersection<U>>;
+    }>, TMeta, TGateName>;
+    endpoint<U extends AnySchema | AnyShape = core.$ZodType<Record<string, never>, Record<string, never>>>(endpoint: HTTPEndpoint$1, schema?: U): ProcedureBuilder<TInitialContext, TCurrentContext, MergedSchemas<TSchemas, {
+        pathSchema: WrapShape<U>;
+    }>, TMeta, TGateName>;
     /**
      * Sets or updates the route definition for the contract.
      * The provided route is spared-merged with any existing route in the contract.
@@ -45,24 +65,21 @@ declare class ProcedureBuilder<TInitialContext extends Context, TCurrentContext
      * @see {@link https://orpc.unnoq.com/docs/openapi/routing OpenAPI Routing Docs}
      * @see {@link https://orpc.unnoq.com/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
      */
-    route(route: Route): ProcedureBuilder<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta, TGateName>;
-    path<USchema extends AnySchema>(schema: USchema): ProcedureBuilder<TInitialContext, TCurrentContext, MergedSchemas<TSchemas, {
-        pathSchema: USchema;
-    }>, TErrorMap, TMeta, TGateName>;
-    query<USchema extends AnySchema>(schema: USchema): ProcedureBuilder<TInitialContext, TCurrentContext, MergedSchemas<TSchemas, {
-        querySchema: USchema;
-    }>, TErrorMap, TMeta, TGateName>;
-    body<USchema extends AnySchema>(schema: USchema): ProcedureBuilder<TInitialContext, TCurrentContext, MergedSchemas<TSchemas, {
-        bodySchema: USchema;
-    }>, TErrorMap, TMeta, TGateName>;
+    endpointOpts(route: Route): ProcedureBuilder<TInitialContext, TCurrentContext, TSchemas, TMeta, TGateName>;
+    query<U extends AnySchema | AnyShape>(schema: U): ProcedureBuilder<TInitialContext, TCurrentContext, MergedSchemas<TSchemas, {
+        querySchema: WrapShape<U>;
+    }>, TMeta, TGateName>;
+    body<U extends AnySchema | AnyShape>(schema: U): ProcedureBuilder<TInitialContext, TCurrentContext, MergedSchemas<TSchemas, {
+        bodySchema: WrapShape<U>;
+    }>, TMeta, TGateName>;
     /**
      * Defines the output validation schema.
      *
      * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Output Validation Docs}
      */
-    output<USchema extends AnySchema>(schema: USchema): ProcedureBuilder<TInitialContext, TCurrentContext, MergedSchemas<TSchemas, {
-        outputSchema: USchema;
-    }>, TErrorMap, TMeta, TGateName>;
+    output<U extends AnySchema | AnyShape>(schema: U): ProcedureBuilder<TInitialContext, TCurrentContext, MergedSchemas<TSchemas, {
+        outputSchema: WrapShape<U>;
+    }>, TMeta, TGateName>;
     /**
      * Uses a middleware to modify the context or improve the pipeline.
      *
@@ -70,18 +87,21 @@ declare class ProcedureBuilder<TInitialContext extends Context, TCurrentContext
      * @note The current context must be satisfy middleware dependent-context
      * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
      */
-    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, unknown, unknown, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ProcedureBuilder<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TSchemas, TErrorMap, TMeta, TGateName>;
+    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>;
+    useErrors(errorMap: ErrorMap): ProcedureBuilder<TInitialContext, TCurrentContext, 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, TErrorMap, TMeta, TInferredGateName>;
+    }>, TSchemas, TMeta, TInferredGateName>;
     /**
      * Defines the handler of the procedure.
      *
      * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
      */
-    handler(handler: ProcedureHandler<TCurrentContext, InferHandlerInputs<TSchemas>, InferSchemaInput<TSchemas['outputSchema']>, TErrorMap, TMeta>): DecoratedProcedure<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta>;
+    handler(handler: ProcedureHandler<TCurrentContext, InferHandlerInputs<TSchemas>, InferSchemaInput<TSchemas['outputSchema']>, TMeta>): DecoratedProcedure<TInitialContext, TCurrentContext, TSchemas, TMeta>;
 }
-declare class BuilderWithMiddlewares<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta, TGateName extends string> extends ProcedureBuilder<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta, TGateName> {
+declare class BuilderWithMiddlewares<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TMeta extends Meta, TGateName extends string> extends ProcedureBuilder<TInitialContext, TCurrentContext, TSchemas, TMeta, TGateName> {
     /**
      * Prefixes all procedures in the router.
      * The provided prefix is post-appended to any existing router prefix.
@@ -90,205 +110,327 @@ declare class BuilderWithMiddlewares<TInitialContext extends Context, TCurrentCo
      *
      * @see {@link https://orpc.unnoq.com/docs/openapi/routing#route-prefixes OpenAPI Route Prefixes Docs}
      */
-    prefix(prefix: HTTPPath): BuilderWithMiddlewares<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta, TGateName>;
+    prefix(prefix: HTTPPath): BuilderWithMiddlewares<TInitialContext, TCurrentContext, TSchemas, TMeta, TGateName>;
     /**
      * Adds tags to all procedures in the router.
      * This helpful when you want to group procedures together in the OpenAPI specification.
      *
      * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
      */
-    tag(...tags: string[]): RouterBuilder<TInitialContext, TCurrentContext, TErrorMap, TMeta>;
+    tag(...tags: string[]): RouterBuilder<TInitialContext, TCurrentContext, TMeta>;
     /**
      * Applies all of the previously defined options to the specified router.
      *
      * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
      */
-    router<U extends Router<ContractRouter<TMeta>, TCurrentContext>>(router: U): EnhancedRouter<U, TInitialContext, TCurrentContext, TErrorMap>;
+    router<U extends Router<TCurrentContext>>(router: U): EnhancedRouter<U, TInitialContext, TCurrentContext>;
 }
-interface RouterBuilder<TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> extends Pick<BuilderWithMiddlewares<TInitialContext, TCurrentContext, any, TErrorMap, TMeta, any>, 'prefix' | 'tag' | 'router'> {
+interface RouterBuilder<TInitialContext extends Context, TCurrentContext extends Context, TMeta extends Meta> extends Pick<BuilderWithMiddlewares<TInitialContext, TCurrentContext, any, TMeta, any>, 'prefix' | 'tag' | 'router'> {
     /**
      * This property holds the defined options.
      */
-    '~orpc': EnhanceRouterOptions<TErrorMap>;
+    '~orpc': EnhanceRouterOptions;
 }
 
-interface DecoratedMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> extends Middleware<TInContext, TOutContext, TInput, TOutput, TErrorConstructorMap, TMeta> {
+interface DecoratedMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TMeta extends Meta> extends Middleware<TInContext, TOutContext, TInput, TOutput, TMeta> {
     /**
      * Change the expected input type by providing a map function.
      */
-    mapInput<UInput>(map: MapInputMiddleware<UInput, TInput>): DecoratedMiddleware<TInContext, TOutContext, UInput, TOutput, TErrorConstructorMap, TMeta>;
-    /**
-     * Concatenates two middlewares.
-     *
-     * @info Pass second argument to map the input.
-     * @see {@link https://orpc.unnoq.com/docs/middleware#concatenation Middleware Concatenation Docs}
-     */
-    concat<UOutContext extends IntersectPick<MergedCurrentContext<TInContext, TOutContext>, UOutContext>, UInput extends TInput, UInContext extends Context = MergedCurrentContext<TInContext, TOutContext>>(middleware: Middleware<UInContext | MergedCurrentContext<TInContext, TOutContext>, UOutContext, UInput, TOutput, TErrorConstructorMap, TMeta>): DecoratedMiddleware<MergedInitialContext<TInContext, UInContext, MergedCurrentContext<TInContext, TOutContext>>, MergedCurrentContext<TOutContext, UOutContext>, UInput, TOutput, TErrorConstructorMap, TMeta>;
-    /**
-     * Concatenates two middlewares.
-     *
-     * @info Pass second argument to map the input.
-     * @see {@link https://orpc.unnoq.com/docs/middleware#concatenation Middleware Concatenation Docs}
-     */
-    concat<UOutContext extends IntersectPick<MergedCurrentContext<TInContext, TOutContext>, UOutContext>, UInput extends TInput, UMappedInput, UInContext extends Context = MergedCurrentContext<TInContext, TOutContext>>(middleware: Middleware<UInContext | MergedCurrentContext<TInContext, TOutContext>, UOutContext, UMappedInput, TOutput, TErrorConstructorMap, TMeta>, mapInput: MapInputMiddleware<UInput, UMappedInput>): DecoratedMiddleware<MergedInitialContext<TInContext, UInContext, MergedCurrentContext<TInContext, TOutContext>>, MergedCurrentContext<TOutContext, UOutContext>, UInput, TOutput, TErrorConstructorMap, TMeta>;
+    mapInput<UInput>(map: MapInputMiddleware<UInput, TInput>): DecoratedMiddleware<TInContext, TOutContext, UInput, TOutput, TMeta>;
 }
-declare function decorateMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta>(middleware: Middleware<TInContext, TOutContext, TInput, TOutput, TErrorConstructorMap, TMeta>): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, TErrorConstructorMap, TMeta>;
+declare function decorateMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TMeta extends Meta>(middleware: Middleware<TInContext, TOutContext, TInput, TOutput, TMeta>): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, TMeta>;
 
-interface BuilderDef<TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TSchemas, TErrorMap, TMeta>, EnhanceRouterOptions<TErrorMap> {
-    middlewares: readonly AnyMiddleware[];
-    inputValidationIndex: number;
-    outputValidationIndex: number;
+interface BuilderDef<TSchemas extends Schemas, TMeta extends Meta> extends ContractDef<TSchemas, TMeta>, EnhanceRouterOptions {
 }
-declare class Builder<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta, TGateName extends string> extends BuilderWithMiddlewares<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta, TGateName> {
+declare class Builder<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TMeta extends Meta, TGateName extends string> extends BuilderWithMiddlewares<TInitialContext, TCurrentContext, TSchemas, TMeta, TGateName> {
     /**
      * Set or override the initial context.
      *
      * @see {@link https://orpc.unnoq.com/docs/context Context Docs}
      */
-    $context<U extends Context>(): Builder<U, U, TSchemas, TErrorMap, TMeta, TGateName>;
+    $context<U extends Context>(): Builder<U, U, TSchemas, TMeta, TGateName>;
     /**
      * Creates a middleware.
      *
      * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
      */
     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, ORPCErrorConstructorMap<TErrorMap>, TMeta>): DecoratedMiddleware<TInitialContext, UOutContext, TInput, TOutput, any, TMeta>;
-}
-type ApiBuilder<TMeta extends Meta> = Builder<Record<never, never>, Record<never, never>, InitialSchemas, Record<never, never>, TMeta, never>;
-interface ApiBuilderOpts<TMeta extends Meta> {
-    meta?: TMeta;
+    middleware: Middleware<TInitialContext, UOutContext, TInput, TOutput, TMeta>): DecoratedMiddleware<TInitialContext, UOutContext, TInput, TOutput, 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>;
 
-/**
- * Like `DecoratedProcedure`, but removed all method that can change the contract.
- */
-interface ImplementedProcedure<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> extends Procedure<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta> {
-    /**
-     * Uses a middleware to modify the context or improve the pipeline.
-     *
-     * @info Supports both normal middleware and inline middleware implementations.
-     * @info Pass second argument to map the input.
-     * @note The current context must be satisfy middleware dependent-context
-     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
-     */
-    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, InferHandlerInputs<TSchemas>, InferSchemaInput<TSchemas['outputSchema']>, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ImplementedProcedure<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TSchemas, TErrorMap, TMeta>;
-    /**
-     * Uses a middleware to modify the context or improve the pipeline.
-     *
-     * @info Supports both normal middleware and inline middleware implementations.
-     * @info Pass second argument to map the input.
-     * @note The current context must be satisfy middleware dependent-context
-     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
-     */
-    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInput, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, UInput, InferSchemaInput<TSchemas['outputSchema']>, ORPCErrorConstructorMap<TErrorMap>, TMeta>, mapInput: MapInputMiddleware<InferHandlerInputs<TSchemas>, UInput>): ImplementedProcedure<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TSchemas, TErrorMap, TMeta>;
-    /**
-     * Make this procedure callable (works like a function while still being a procedure).
-     *
-     * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
-     */
-    callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TSchemas['outputSchema'], TErrorMap, TMeta, TClientContext>>): ImplementedProcedure<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta> & ProcedureClient<TClientContext, TSchemas, TErrorMap>;
+interface EventIteratorSchemaDetails {
+    yields: AnySchema;
+    returns?: AnySchema;
 }
 /**
- * Like `ProcedureBuilderWithoutHandler`, but removed all method that can change the contract.
+ * Define schema for an event iterator.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/event-iterator#validate-event-iterator Validate Event Iterator Docs}
  */
-interface ProcedureImplementer<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    '~orpc': BuilderDef<TSchemas, TErrorMap, TMeta>;
-    /**
-     * Uses a middleware to modify the context or improve the pipeline.
-     *
-     * @info Supports both normal middleware and inline middleware implementations.
-     * @info Pass second argument to map the input.
-     * @note The current context must be satisfy middleware dependent-context
-     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
-     */
-    'use'<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, InferHandlerInputs<TSchemas>, InferSchemaInput<TSchemas['outputSchema']>, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ProcedureImplementer<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TSchemas, TErrorMap, TMeta>;
-    /**
-     * Uses a middleware to modify the context or improve the pipeline.
-     *
-     * @info Supports both normal middleware and inline middleware implementations.
-     * @info Pass second argument to map the input.
-     * @note The current context must be satisfy middleware dependent-context
-     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
-     */
-    'use'<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInput, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, UInput, InferSchemaInput<TSchemas['outputSchema']>, ORPCErrorConstructorMap<TErrorMap>, TMeta>, mapInput: MapInputMiddleware<InferHandlerInputs<TSchemas>, UInput>): ProcedureImplementer<MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>, TSchemas, TErrorMap, TMeta>;
-    /**
-     * Defines the handler of the procedure.
-     *
-     * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
-     */
-    'handler'(handler: ProcedureHandler<TCurrentContext, InferHandlerInputs<TSchemas>, InferSchemaInput<TSchemas['outputSchema']>, TErrorMap, TMeta>): ImplementedProcedure<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta>;
-}
+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;
 
-interface RouterImplementerWithMiddlewares<T extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> {
-    /**
-     * Uses a middleware to modify the context or improve the pipeline.
-     *
-     * @info Supports both normal middleware and inline middleware implementations.
-     * @note The current context must be satisfy middleware dependent-context
-     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
-     */
-    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, unknown, unknown, ORPCErrorConstructorMap<InferContractRouterErrorMap<T>>, InferContractRouterMeta<T>>): ImplementerInternalWithMiddlewares<T, MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>>;
-    /**
-     * Applies all of the previously defined options to the specified router.
-     * And enforces the router match the contract.
-     *
-     * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
-     */
-    router<U extends Router<T, TCurrentContext>>(router: U): EnhancedRouter<U, TInitialContext, TCurrentContext, Record<never, never>>;
+type JsonSchema = Draft2020.JSONSchema | Draft2019.JSONSchema | Draft07.JSONSchema;
+declare enum JsonSchemaXNativeType {
+    BigInt = "bigint",
+    RegExp = "regexp",
+    Date = "date",
+    Url = "url",
+    Set = "set",
+    Map = "map"
 }
-type ImplementerInternalWithMiddlewares<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = TContract extends ContractProcedure<infer USchemas, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, USchemas, UErrorMap, UMeta> : RouterImplementerWithMiddlewares<TContract, TInitialContext, TCurrentContext> & {
-    [K in keyof TContract]: TContract[K] extends AnyContractRouter ? ImplementerInternalWithMiddlewares<TContract[K], TInitialContext, TCurrentContext> : never;
-};
 
-interface RouterImplementer<T extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> {
-    /**
-     * Creates a middleware.
-     *
-     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
-     */
-    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, ORPCErrorConstructorMap<InferContractRouterErrorMap<T>>, InferContractRouterMeta<T>>): DecoratedMiddleware<TInitialContext, UOutContext, TInput, TOutput, any, InferContractRouterMeta<T>>;
-    /**
-     * Uses a middleware to modify the context or improve the pipeline.
-     *
-     * @info Supports both normal middleware and inline middleware implementations.
-     * @note The current context must be satisfy middleware dependent-context
-     * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
-     */
-    use<UOutContext extends IntersectPick<TCurrentContext, UOutContext>, UInContext extends Context = TCurrentContext>(middleware: Middleware<UInContext | TCurrentContext, UOutContext, unknown, unknown, ORPCErrorConstructorMap<InferContractRouterErrorMap<T>>, InferContractRouterMeta<T>>): ImplementerInternalWithMiddlewares<T, MergedInitialContext<TInitialContext, UInContext, TCurrentContext>, MergedCurrentContext<TCurrentContext, UOutContext>>;
-    /**
-     * Applies all of the previously defined options to the specified router.
-     * And enforces the router match the contract.
-     *
-     * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
-     */
-    router<U extends Router<T, TCurrentContext>>(router: U): EnhancedRouter<U, TInitialContext, TCurrentContext, Record<never, never>>;
-    /**
-     * Create a lazy router
-     * And applies all of the previously defined options to the specified router.
-     * And enforces the router match the contract.
-     *
-     * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
-     */
-    lazyRoute<U extends Router<T, TCurrentContext>>(loader: () => Promise<{
-        default: U;
-    }>): EnhancedRouter<Lazy<U>, TInitialContext, TCurrentContext, Record<never, never>>;
+interface experimental_JsonSchemaCoerceOptions {
+    components?: Record<string, JsonSchema>;
+}
+declare class experimental_JsonSchemaCoercer {
+    #private;
+    coerce(schema: JsonSchema, value: unknown, options?: experimental_JsonSchemaCoerceOptions): unknown;
 }
-type ImplementerInternal<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = TContract extends ContractProcedure<infer USchemas, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, USchemas, UErrorMap, UMeta> : RouterImplementer<TContract, TInitialContext, TCurrentContext> & {
-    [K in keyof TContract]: TContract[K] extends AnyContractRouter ? ImplementerInternal<TContract[K], TInitialContext, TCurrentContext> : never;
-};
-declare function implementerInternal<T extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context>(contract: T, middlewares: AnyMiddleware[]): ImplementerInternal<T, TInitialContext, TCurrentContext>;
-type Implementer<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = {
-    /**
-     * Set or override the initial context.
-     *
-     * @see {@link https://orpc.unnoq.com/docs/context Context Docs}
-     */
-    $context<U extends Context>(): Implementer<TContract, U, U>;
-} & ImplementerInternal<TContract, TInitialContext, TCurrentContext>;
-declare function implement<T extends AnyContractRouter, TContext extends Context = Record<never, never>>(contract: T): Implementer<T, TContext, TContext>;
+
+/**
+ * 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: {
@@ -297,10 +439,6 @@ declare function mergeMiddlewares(first: readonly AnyMiddleware[], second: reado
 declare function addMiddleware(middlewares: readonly AnyMiddleware[], addition: AnyMiddleware): AnyMiddleware[];
 
 declare function createAssertedLazyProcedure(lazied: Lazy<any>): Lazy<AnyProcedure>;
-/**
- * Create a new procedure that ensure the contract is applied to the procedure.
- */
-declare function createContractedProcedure(procedure: AnyProcedure, contract: AnyContractProcedure): AnyProcedure;
 /**
  * Directly call a procedure without creating a client.
  *
@@ -311,20 +449,35 @@ declare function createContractedProcedure(procedure: AnyProcedure, contract: An
  * ```
  *
  */
-declare function call<TInitialContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta>(procedure: Lazyable<Procedure<TInitialContext, any, TSchemas, TErrorMap, TMeta>>, input: InferProcedureClientInputs<TSchemas>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TSchemas['outputSchema'], TErrorMap, TMeta, Record<never, never>> & Omit<ClientOptions<Record<never, never>>, 'context'>>): ClientPromiseResult<InferSchemaOutput<TSchemas['outputSchema']>, ErrorFromErrorMap<TErrorMap>>;
+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 = Record<never, never>> = TRouter extends Procedure<any, any, infer USchemas, infer UErrorMap, any> ? ProcedureClient<TClientContext, USchemas, UErrorMap> : {
-    [K in keyof TRouter]: TRouter[K] extends Lazyable<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : never;
-};
+declare function isSchemaIssue(issue: unknown): issue is SchemaIssue;
+
+type HTTPEndpoint = `${HTTPMethod} ${HTTPPath}`;
+declare const endpointRegex: RegExp;
 /**
- * Create Server-side client from a router.
- *
- * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
+ * @internal
  */
-declare function createRouterClient<T extends AnyRouter, TClientContext extends ClientContext>(router: Lazyable<T | undefined>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<InferRouterInitialContext<T>, Schema<unknown, unknown>, ErrorMap, Meta, TClientContext>>): RouterClient<T, TClientContext>;
-
-declare function setHiddenRouterContract<T extends Lazyable<AnyRouter>>(router: T, contract: AnyContractRouter): T;
-declare function getHiddenRouterContract(router: Lazyable<AnyRouter | AnyContractRouter>): AnyContractRouter | undefined;
+declare function isDevelopment(): boolean;
+/**
+ * @internal
+ */
+declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
+/**
+ * @internal
+ */
+declare function getDynamicParams(path: HTTPPath | undefined): {
+    raw: string;
+    name: string;
+}[] | undefined;
+/**
+ * @internal
+ */
+declare function parseEndpointDefinition(stringsOrEndpoint: TemplateStringsArray | HTTPEndpoint, values: AnyShape[] | [AnySchema | AnyShape] | []): {
+    method: HTTPMethod;
+    path: HTTPPath;
+    pathSchema: AnySchema;
+};
 
-export { AnyMiddleware, AnyProcedure, AnyRouter, Builder, BuilderWithMiddlewares, Context, CreateProcedureClientOptions, DecoratedProcedure, EnhanceRouterOptions, EnhancedRouter, InferRouterInitialContext, Lazy, Lazyable, MapInputMiddleware, MergedCurrentContext, MergedInitialContext, Middleware, ORPCErrorConstructorMap, Procedure, ProcedureBuilder, ProcedureClient, ProcedureHandler, Router, addMiddleware, call, createApiBuilder, createAssertedLazyProcedure, createContractedProcedure, createRouterClient, decorateMiddleware, getHiddenRouterContract, implement, implementerInternal, isStartWithMiddlewares, mergeMiddlewares, os, setHiddenRouterContract };
-export type { ApiBuilder, BuilderDef, DecoratedMiddleware, ImplementedProcedure, Implementer, ImplementerInternal, ImplementerInternalWithMiddlewares, ProcedureImplementer, RouterBuilder, RouterClient, RouterImplementer, RouterImplementerWithMiddlewares };
+export { AnyMiddleware, AnyProcedure, AnySchema, AnyShape, BuildContextWithAuth, Builder, BuilderWithMiddlewares, Context, Contract, ContractDef, DecoratedProcedure, EnhanceRouterOptions, EnhancedRouter, ErrorMap, 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, WrapShape, addMiddleware, baseApi, call, createAssertedLazyProcedure, createProcedureClient, decorateMiddleware, endpointRegex, eventIterator, experimental_JsonSchemaCoercer, getDynamicParams, getEventIteratorSchemaDetails, isDevelopment, isSchemaIssue, isStartWithMiddlewares, mergeMiddlewares, parseEndpointDefinition, standardizeHTTPPath };
+export type { BuilderDef, CreateProcedureClientOptions, DecoratedMiddleware, EventIteratorSchemaDetails, HTTPEndpoint, JsonSchema, ProcedureClient, RouterBuilder, experimental_JsonSchemaCoerceOptions };