@orpc/server 0.46.0 → 1.0.0-beta.1

package/dist/index.mjs

@@ -1,14 +1,15 @@
-import { mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, mergeTags, isContractProcedure } from '@orpc/contract';
+import { mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, mergeTags, isContractProcedure, getContractRouter } from '@orpc/contract';
 export { ValidationError, eventIterator, type } from '@orpc/contract';
-import { P as Procedure, d as addMiddleware, c as createProcedureClient, f as adaptRouter, h as flatLazy, l as lazy, s as setRouterContract, i as isProcedure, j as isLazy, k as createLazyProcedureFormAnyLazy, g as getRouterChild } from './shared/server.V6zT5iYQ.mjs';
-export { L as LAZY_LOADER_SYMBOL, a as convertPathToHttpPath, q as createAccessibleLazyRouter, b as createContractedProcedure, n as deepSetLazyRouterPrefix, r as eachAllContractProcedure, e as eachContractProcedure, o as getLazyRouterPrefix, m as getRouterContract, p as middlewareOutputFn, u as unlazy } from './shared/server.V6zT5iYQ.mjs';
+import { P as Procedure, d as addMiddleware, c as createProcedureClient, e as enhanceRouter, l as lazy, s as setHiddenRouterContract, i as isProcedure, f as isLazy, h as createAssertedLazyProcedure, g as getRouter } from './shared/server.BtxZnWJ9.mjs';
+export { L as LAZY_SYMBOL, q as call, w as createAccessibleLazyRouter, b as createContractedProcedure, j as createORPCErrorConstructorMap, r as getHiddenRouterContract, k as getLazyMeta, o as isStartWithMiddlewares, m as mergeCurrentContext, p as mergeMiddlewares, n as middlewareOutputFn, x as resolveContractProcedures, a as toHttpPath, t as traverseContractProcedures, u as unlazy, y as unlazyRouter, v as validateORPCError } from './shared/server.BtxZnWJ9.mjs';
 export { ORPCError, isDefinedError, safe } from '@orpc/client';
 export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
 export { getEventMeta, withEventMeta } from '@orpc/standard-server';
 
 const DEFAULT_CONFIG = {
   initialInputValidationIndex: 0,
-  initialOutputValidationIndex: 0
+  initialOutputValidationIndex: 0,
+  dedupeLeadingMiddlewares: true
 };
 function fallbackConfig(key, value) {
   if (value === void 0) {
@@ -18,7 +19,7 @@ function fallbackConfig(key, value) {
 }
 
 function decorateMiddleware(middleware) {
-  const decorated = middleware;
+  const decorated = (...args) => middleware(...args);
   decorated.mapInput = (mapInput) => {
     const mapped = decorateMiddleware(
       (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
@@ -73,9 +74,13 @@ class DecoratedProcedure extends Procedure {
    * Make this procedure callable (works like a function while still being a procedure).
    */
   callable(...rest) {
-    return Object.assign(createProcedureClient(this, ...rest), {
-      "~type": "Procedure",
-      "~orpc": this["~orpc"]
+    return new Proxy(createProcedureClient(this, ...rest), {
+      get: (target, key) => {
+        return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
+      },
+      has: (target, key) => {
+        return Reflect.has(this, key) || Reflect.has(target, key);
+      }
     });
   }
   /**
@@ -100,6 +105,7 @@ class Builder {
     return new Builder({
       ...this["~orpc"],
       config,
+      dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares),
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
       outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config.initialOutputValidationIndex) + outputValidationCount
     });
@@ -133,6 +139,12 @@ class Builder {
       route: initialRoute
     });
   }
+  $input(initialInputSchema) {
+    return new Builder({
+      ...this["~orpc"],
+      inputSchema: initialInputSchema
+    });
+  }
   middleware(middleware) {
     return decorateMiddleware(middleware);
   }
@@ -194,10 +206,10 @@ class Builder {
     });
   }
   router(router) {
-    return adaptRouter(router, this["~orpc"]);
+    return enhanceRouter(router, this["~orpc"]);
   }
   lazy(loader) {
-    return adaptRouter(flatLazy(lazy(loader)), this["~orpc"]);
+    return enhanceRouter(lazy(loader), this["~orpc"]);
   }
 }
 const os = new Builder({
@@ -205,17 +217,12 @@ const os = new Builder({
   route: {},
   meta: {},
   errorMap: {},
-  inputSchema: void 0,
-  outputSchema: void 0,
   inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
   outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
-  middlewares: []
+  middlewares: [],
+  dedupeLeadingMiddlewares: true
 });
 
-function mergeContext(context, other) {
-  return { ...context, ...other };
-}
-
 function implementerInternal(contract, config, middlewares) {
   if (isContractProcedure(contract)) {
     const impl2 = new Builder({
@@ -223,12 +230,16 @@ function implementerInternal(contract, config, middlewares) {
       config,
       middlewares,
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", config?.initialInputValidationIndex) + middlewares.length,
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config?.initialOutputValidationIndex) + middlewares.length
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config?.initialOutputValidationIndex) + middlewares.length,
+      dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
     });
     return impl2;
   }
   const impl = new Proxy(contract, {
     get: (target, key) => {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
       let method;
       if (key === "middleware") {
         method = (mid) => decorateMiddleware(mid);
@@ -242,23 +253,29 @@ function implementerInternal(contract, config, middlewares) {
         };
       } else if (key === "router") {
         method = (router) => {
-          const adapted = adaptRouter(router, {
+          const adapted = enhanceRouter(router, {
             middlewares,
-            errorMap: {}
+            errorMap: {},
+            prefix: void 0,
+            tags: void 0,
+            dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
           });
-          return setRouterContract(adapted, contract);
+          return setHiddenRouterContract(adapted, contract);
         };
       } else if (key === "lazy") {
         method = (loader) => {
-          const adapted = adaptRouter(flatLazy(lazy(loader)), {
+          const adapted = enhanceRouter(lazy(loader), {
             middlewares,
-            errorMap: {}
+            errorMap: {},
+            prefix: void 0,
+            tags: void 0,
+            dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
           });
-          return setRouterContract(adapted, contract);
+          return setHiddenRouterContract(adapted, contract);
         };
       }
-      const next = Reflect.get(target, key);
-      if (!next || typeof next !== "function" && typeof next !== "object") {
+      const next = getContractRouter(target, [key]);
+      if (!next) {
         return method ?? next;
       }
       const nextImpl = implementerInternal(next, config, middlewares);
@@ -285,42 +302,34 @@ function implement(contract, config = {}) {
         method = (config2) => implement(contract, config2);
       }
       const next = Reflect.get(target, key);
-      if (!next || typeof next !== "function" && typeof next !== "object") {
-        return method ?? next;
+      if (!method || !next || typeof next !== "function" && typeof next !== "object") {
+        return method || next;
       }
-      if (method) {
-        return new Proxy(method, {
-          get(_, key2) {
-            return Reflect.get(next, key2);
-          }
-        });
-      }
-      return next;
+      return new Proxy(method, {
+        get(_, key2) {
+          return Reflect.get(next, key2);
+        }
+      });
     }
   });
   return impl;
 }
 
-function call(procedure, input, ...rest) {
-  return createProcedureClient(procedure, ...rest)(input);
-}
-
-function createRouterClient(router, ...rest) {
+function createRouterClient(router, ...[options]) {
   if (isProcedure(router)) {
-    const caller = createProcedureClient(router, ...rest);
+    const caller = createProcedureClient(router, options);
     return caller;
   }
-  const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
+  const procedureCaller = isLazy(router) ? createProcedureClient(createAssertedLazyProcedure(router), options) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = getRouterChild(router, key);
+      const next = getRouter(router, [key]);
       if (!next) {
         return Reflect.get(target, key);
       }
-      const [options] = rest;
       return createRouterClient(next, {
         ...options,
         path: [...options?.path ?? [], key]
@@ -330,4 +339,4 @@ function createRouterClient(router, ...rest) {
   return recursive;
 }
 
-export { Builder, DecoratedProcedure, Procedure, adaptRouter, call, createLazyProcedureFormAnyLazy, createProcedureClient, createRouterClient, decorateMiddleware, fallbackConfig, flatLazy, getRouterChild, implement, implementerInternal, isLazy, isProcedure, lazy, mergeContext, os, setRouterContract };
+export { Builder, DecoratedProcedure, Procedure, addMiddleware, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getRouter, implement, implementerInternal, isLazy, isProcedure, lazy, os, setHiddenRouterContract };

package/dist/plugins/index.d.mts

@@ -1,31 +1,31 @@
-import { d as StandardHandlerInterceptorOptions, P as Plugin, a as StandardHandlerOptions } from '../shared/server.DJrh0Ceu.mjs';
-export { C as CompositePlugin } from '../shared/server.DJrh0Ceu.mjs';
+import { b as StandardHandlerInterceptorOptions, H as HandlerPlugin, a as StandardHandlerOptions } from '../shared/server.BeJithK4.mjs';
+export { C as CompositePlugin } from '../shared/server.BeJithK4.mjs';
 import { Value } from '@orpc/shared';
-import { C as Context } from '../shared/server.Cn9ybJtE.mjs';
+import { C as Context } from '../shared/server.BYTulgUc.mjs';
 import '@orpc/contract';
 import '@orpc/standard-server';
 import '@orpc/client';
 
 interface CORSOptions<TContext extends Context> {
-    origin?: Value<string | string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
-    timingOrigin?: Value<string | string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
-    allowMethods?: string[];
-    allowHeaders?: string[];
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
     maxAge?: number;
     credentials?: boolean;
-    exposeHeaders?: string[];
+    exposeHeaders?: readonly string[];
 }
-declare class CORSPlugin<TContext extends Context> implements Plugin<TContext> {
+declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
     private readonly options;
-    constructor(options?: Partial<CORSOptions<TContext>>);
+    constructor(options?: CORSOptions<TContext>);
     init(options: StandardHandlerOptions<TContext>): void;
 }
 
 interface ResponseHeadersPluginContext {
     resHeaders?: Headers;
 }
-declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements Plugin<TContext> {
+declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
     init(options: StandardHandlerOptions<TContext>): void;
 }
 
-export { type CORSOptions, CORSPlugin, Plugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };
+export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.d.ts

@@ -1,31 +1,31 @@
-import { d as StandardHandlerInterceptorOptions, P as Plugin, a as StandardHandlerOptions } from '../shared/server.B-ewprcf.js';
-export { C as CompositePlugin } from '../shared/server.B-ewprcf.js';
+import { b as StandardHandlerInterceptorOptions, H as HandlerPlugin, a as StandardHandlerOptions } from '../shared/server.B3Tm0IXY.js';
+export { C as CompositePlugin } from '../shared/server.B3Tm0IXY.js';
 import { Value } from '@orpc/shared';
-import { C as Context } from '../shared/server.Cn9ybJtE.js';
+import { C as Context } from '../shared/server.BYTulgUc.js';
 import '@orpc/contract';
 import '@orpc/standard-server';
 import '@orpc/client';
 
 interface CORSOptions<TContext extends Context> {
-    origin?: Value<string | string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
-    timingOrigin?: Value<string | string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
-    allowMethods?: string[];
-    allowHeaders?: string[];
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
     maxAge?: number;
     credentials?: boolean;
-    exposeHeaders?: string[];
+    exposeHeaders?: readonly string[];
 }
-declare class CORSPlugin<TContext extends Context> implements Plugin<TContext> {
+declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
     private readonly options;
-    constructor(options?: Partial<CORSOptions<TContext>>);
+    constructor(options?: CORSOptions<TContext>);
     init(options: StandardHandlerOptions<TContext>): void;
 }
 
 interface ResponseHeadersPluginContext {
     resHeaders?: Headers;
 }
-declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements Plugin<TContext> {
+declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
     init(options: StandardHandlerOptions<TContext>): void;
 }
 
-export { type CORSOptions, CORSPlugin, Plugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };
+export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.mjs

@@ -3,7 +3,7 @@ import { value } from '@orpc/shared';
 
 class CORSPlugin {
   options;
-  constructor(options) {
+  constructor(options = {}) {
     const defaults = {
       origin: (origin) => origin,
       allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]

package/dist/shared/{server.B-ewprcf.d.ts → server.B3Tm0IXY.d.ts}

@@ -1,12 +1,12 @@
-import { HTTPPath, Schema, Meta, SchemaOutput, ErrorFromErrorMap } from '@orpc/contract';
+import { HTTPPath, AnySchema, Meta, InferSchemaOutput, ErrorFromErrorMap } from '@orpc/contract';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
-import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.Cn9ybJtE.js';
+import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.BYTulgUc.js';
 import { ORPCError } from '@orpc/client';
 
 type StandardParams = Record<string, string>;
 type StandardMatchResult = {
-    path: string[];
+    path: readonly string[];
     procedure: AnyProcedure;
     params?: StandardParams;
 } | undefined;
@@ -27,9 +27,6 @@ type StandardHandleOptions<T extends Context> = {
 } : {
     context: T;
 });
-type WellStandardHandleOptions<T extends Context> = StandardHandleOptions<T> & {
-    context: T;
-};
 type StandardHandleResult = {
     matched: true;
     response: StandardResponse;
@@ -37,11 +34,12 @@ type StandardHandleResult = {
     matched: false;
     response: undefined;
 };
-type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
+type StandardHandlerInterceptorOptions<T extends Context> = StandardHandleOptions<T> & {
+    context: T;
     request: StandardLazyRequest;
 };
 interface StandardHandlerOptions<TContext extends Context> {
-    plugins?: Plugin<TContext>[];
+    plugins?: HandlerPlugin<TContext>[];
     /**
      * Interceptors at the request level, helpful when you want catch errors
      */
@@ -54,24 +52,24 @@ interface StandardHandlerOptions<TContext extends Context> {
      *
      * Interceptors for procedure client.
      */
-    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Schema, Record<never, never>, Meta>, SchemaOutput<Schema, unknown>, ErrorFromErrorMap<Record<never, never>>>[];
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, AnySchema, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
 }
 declare class StandardHandler<T extends Context> {
     private readonly matcher;
     private readonly codec;
     private readonly options;
     private readonly plugin;
-    constructor(router: Router<T, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<T>>);
+    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
     handle(request: StandardLazyRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
 }
 
-interface Plugin<TContext extends Context> {
+interface HandlerPlugin<TContext extends Context> {
     init?(options: StandardHandlerOptions<TContext>): void;
 }
-declare class CompositePlugin<TContext extends Context> implements Plugin<TContext> {
+declare class CompositePlugin<TContext extends Context> implements HandlerPlugin<TContext> {
     private readonly plugins;
-    constructor(plugins?: Plugin<TContext>[]);
+    constructor(plugins?: HandlerPlugin<TContext>[]);
     init(options: StandardHandlerOptions<TContext>): void;
 }
 
-export { CompositePlugin as C, type Plugin as P, type StandardHandleOptions as S, type WellStandardHandleOptions as W, type StandardHandlerOptions as a, type StandardMatcher as b, type StandardCodec as c, type StandardHandlerInterceptorOptions as d, type StandardParams as e, type StandardMatchResult as f, type StandardHandleResult as g, StandardHandler as h };
+export { CompositePlugin as C, type HandlerPlugin as H, type StandardHandleOptions as S, type StandardHandlerOptions as a, type StandardHandlerInterceptorOptions as b, type StandardCodec as c, type StandardParams as d, type StandardMatcher as e, type StandardMatchResult as f, type StandardHandleResult as g, StandardHandler as h };

package/dist/shared/server.BYTulgUc.d.mts

@@ -0,0 +1,144 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
+import { MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, HTTPPath, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
+
+type Context = Record<string, any>;
+type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
+type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
+type ContextExtendsGuard<T extends Context, U extends Context> = T extends U ? unknown : never;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
+type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
+};
+declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
+declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+
+declare const LAZY_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_SYMBOL]: {
+        loader: () => Promise<{
+            default: T;
+        }>;
+        meta: LazyMeta;
+    };
+}
+type Lazyable<T> = T | Lazy<T>;
+declare function lazy<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TCurrentContext;
+    input: TInput;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    __initialContext?: (type: TInitialContext) => unknown;
+    middlewares: readonly AnyMiddleware[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: ProcedureHandler<TCurrentContext, any, any, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TInContext;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    next: MiddlewareNextFn<TOutput>;
+    errors: TErrorConstructorMap;
+}
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: InferSchemaInput<TInputSchema>;
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+}
+/**
+ * Options for creating a procedure caller with comprehensive type safety
+ */
+type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: readonly string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
+} & (Record<never, never> extends TInitialContext ? {
+    context?: Value<TInitialContext, [clientContext: TClientContext]>;
+} : {
+    context: Value<TInitialContext, [clientContext: TClientContext]>;
+});
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+
+type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
+};
+type AnyRouter = Router<any, any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infer UInitialContext> ? UInitialContext : never;
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
+};
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any, any> ? UCurrentContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
+};
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
+};
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
+};
+
+export { type AnyProcedure as A, type MiddlewareOptions as B, type Context as C, middlewareOutputFn as D, type ProcedureHandlerOptions as E, type ProcedureDef as F, isProcedure as G, createProcedureClient as H, type InferRouterInitialContext as I, type InferRouterInitialContexts as J, type InferRouterCurrentContexts as K, type Lazyable as L, type Middleware as M, type InferRouterInputs as N, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type InferRouterOutputs as Q, type Router as R, type AnyRouter as a, Procedure as b, type ContextExtendsGuard as c, type MergedCurrentContext as d, type MergedInitialContext as e, type MapInputMiddleware as f, type CreateProcedureClientOptions as g, type ProcedureClient as h, type AnyMiddleware as i, type Lazy as j, type ProcedureHandler as k, type ORPCErrorConstructorMapItemOptions as l, mergeCurrentContext as m, type ORPCErrorConstructorMapItem as n, createORPCErrorConstructorMap as o, LAZY_SYMBOL as p, type LazyMeta as q, lazy as r, isLazy as s, getLazyMeta as t, unlazy as u, validateORPCError as v, type MiddlewareResult as w, type MiddlewareNextFnOptions as x, type MiddlewareNextFn as y, type MiddlewareOutputFn as z };