@orpc/server 0.0.0-next.68378b4 → 0.0.0-next.69674a7

package/dist/shared/{server.V6zT5iYQ.mjs → server.kPUGzsdw.mjs}

@@ -1,59 +1,24 @@
+import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
 import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
-import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, adaptRoute } from '@orpc/contract';
 import { value, intercept, toError } from '@orpc/shared';
 
-const LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
-function lazy(loader) {
+const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazy(loader, meta = {}) {
   return {
-    [LAZY_LOADER_SYMBOL]: loader
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
   };
 }
 function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_LOADER_SYMBOL in item && typeof item[LAZY_LOADER_SYMBOL] === "function";
-}
-function unlazy(lazied) {
-  return isLazy(lazied) ? lazied[LAZY_LOADER_SYMBOL]() : Promise.resolve({ default: lazied });
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
 }
-
-class Procedure {
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-}
-function isProcedure(item) {
-  if (item instanceof Procedure) {
-    return true;
-  }
-  return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
+function getLazyMeta(lazied) {
+  return lazied[LAZY_SYMBOL].meta;
 }
-
-function flatLazy(lazied) {
-  const flattenLoader = async () => {
-    let current = await unlazy(lazied);
-    while (true) {
-      if (!isLazy(current.default)) {
-        break;
-      }
-      current = await unlazy(current.default);
-    }
-    return current;
-  };
-  return lazy(flattenLoader);
-}
-function createLazyProcedureFormAnyLazy(lazied) {
-  const lazyProcedure = lazy(async () => {
-    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
-    if (!isProcedure(maybeProcedure)) {
-      throw new Error(`
-            Expected a lazy<procedure> but got lazy<unknown>.
-            This should be caught by TypeScript compilation.
-            Please report this issue if this makes you feel uncomfortable.
-        `);
-    }
-    return { default: maybeProcedure };
-  });
-  return lazyProcedure;
+function unlazy(lazied) {
+  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
 }
 
 function dedupeMiddlewares(compare, middlewares) {
@@ -74,6 +39,19 @@ function addMiddleware(middlewares, addition) {
   return [...middlewares, addition];
 }
 
+class Procedure {
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+}
+function isProcedure(item) {
+  if (item instanceof Procedure) {
+    return true;
+  }
+  return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
+}
+
 function createORPCErrorConstructorMap(errors) {
   const proxy = new Proxy(errors, {
     get(target, code) {
@@ -205,169 +183,162 @@ async function executeProcedureInternal(procedure, options) {
   return (await next({})).output;
 }
 
-const ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
-function setRouterContract(obj, contract) {
-  return new Proxy(obj, {
+const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
+function setHiddenRouterContract(router, contract) {
+  return new Proxy(router, {
     get(target, key) {
-      if (key === ROUTER_CONTRACT_SYMBOL) {
+      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
         return contract;
       }
       return Reflect.get(target, key);
     }
   });
 }
-function getRouterContract(obj) {
-  return obj[ROUTER_CONTRACT_SYMBOL];
+function getHiddenRouterContract(router) {
+  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
 }
-const LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
-function deepSetLazyRouterPrefix(router, prefix) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key !== LAZY_ROUTER_PREFIX_SYMBOL) {
-        const val = Reflect.get(target, key);
-        if (isLazy(val)) {
-          return deepSetLazyRouterPrefix(val, prefix);
-        }
-        return val;
-      }
-      return prefix;
+
+function getRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!current) {
+      return void 0;
     }
-  });
-}
-function getLazyRouterPrefix(obj) {
-  return obj[LAZY_ROUTER_PREFIX_SYMBOL];
+    if (isProcedure(current)) {
+      return void 0;
+    }
+    if (!isLazy(current)) {
+      current = current[segment];
+      continue;
+    }
+    const lazied = current;
+    const rest = path.slice(i);
+    return lazy(async () => {
+      const unwrapped = await unlazy(lazied);
+      const next = getRouter(unwrapped.default, rest);
+      return unlazy(next);
+    }, getLazyMeta(lazied));
+  }
+  return current;
 }
-
 function createAccessibleLazyRouter(lazied) {
-  const flattenLazy = flatLazy(lazied);
-  const recursive = new Proxy(flattenLazy, {
+  const recursive = new Proxy(lazied, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = getRouterChild(flattenLazy, key);
+      const next = getRouter(lazied, [key]);
       return createAccessibleLazyRouter(next);
     }
   });
   return recursive;
 }
-
-function adaptRouter(router, options) {
+function enhanceRouter(router, options) {
   if (isLazy(router)) {
-    const adapted2 = lazy(async () => {
-      const unlaziedRouter = (await unlazy(router)).default;
-      const adapted3 = adaptRouter(unlaziedRouter, options);
-      return { default: adapted3 };
+    const laziedMeta = getLazyMeta(router);
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+    const enhanced2 = lazy(async () => {
+      const { default: unlaziedRouter } = await unlazy(router);
+      const enhanced3 = enhanceRouter(unlaziedRouter, options);
+      return unlazy(enhanced3);
+    }, {
+      ...laziedMeta,
+      prefix: enhancedPrefix
     });
-    const accessible = createAccessibleLazyRouter(adapted2);
-    const currentPrefix = getLazyRouterPrefix(router);
-    const prefix = currentPrefix ? mergePrefix(options.prefix, currentPrefix) : options.prefix;
-    if (prefix) {
-      return deepSetLazyRouterPrefix(accessible, prefix);
-    }
+    const accessible = createAccessibleLazyRouter(enhanced2);
     return accessible;
   }
   if (isProcedure(router)) {
     const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares);
     const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
-    const adapted2 = new Procedure({
+    const enhanced2 = new Procedure({
       ...router["~orpc"],
-      route: adaptRoute(router["~orpc"].route, options),
+      route: enhanceRoute(router["~orpc"].route, options),
       errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
       middlewares: newMiddlewares,
       inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
       outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
     });
-    return adapted2;
+    return enhanced2;
   }
-  const adapted = {};
+  const enhanced = {};
   for (const key in router) {
-    adapted[key] = adaptRouter(router[key], options);
-  }
-  return adapted;
-}
-function getRouterChild(router, ...path) {
-  let current = router;
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i];
-    if (!current) {
-      return void 0;
-    }
-    if (isProcedure(current)) {
-      return void 0;
-    }
-    if (!isLazy(current)) {
-      current = current[segment];
-      continue;
-    }
-    const lazied = current;
-    const rest = path.slice(i);
-    const newLazy = lazy(async () => {
-      const unwrapped = await unlazy(lazied);
-      if (!unwrapped.default) {
-        return unwrapped;
-      }
-      const next = getRouterChild(unwrapped.default, ...rest);
-      return { default: next };
-    });
-    return flatLazy(newLazy);
+    enhanced[key] = enhanceRouter(router[key], options);
   }
-  return current;
+  return enhanced;
 }
-
-function eachContractProcedure(options, callback, laziedOptions = []) {
-  const hiddenContract = getRouterContract(options.router);
-  if (hiddenContract) {
-    return eachContractProcedure(
-      {
-        router: hiddenContract,
-        path: options.path
-      },
-      callback,
-      laziedOptions
-    );
+function traverseContractProcedures(options, callback, lazyOptions = []) {
+  let currentRouter = options.router;
+  const hiddenContract = getHiddenRouterContract(options.router);
+  if (hiddenContract !== void 0) {
+    currentRouter = hiddenContract;
   }
-  if (isLazy(options.router)) {
-    laziedOptions.push({
-      lazied: options.router,
+  if (isLazy(currentRouter)) {
+    lazyOptions.push({
+      router: currentRouter,
       path: options.path
     });
-  } else if (isContractProcedure(options.router)) {
+  } else if (isContractProcedure(currentRouter)) {
     callback({
-      contract: options.router,
+      contract: currentRouter,
       path: options.path
     });
   } else {
-    for (const key in options.router) {
-      eachContractProcedure(
+    for (const key in currentRouter) {
+      traverseContractProcedures(
         {
-          router: options.router[key],
+          router: currentRouter[key],
           path: [...options.path, key]
         },
         callback,
-        laziedOptions
+        lazyOptions
       );
     }
   }
-  return laziedOptions;
+  return lazyOptions;
 }
-async function eachAllContractProcedure(options, callback) {
+async function resolveContractProcedures(options, callback) {
   const pending = [options];
-  for (const item of pending) {
-    const lazies = eachContractProcedure(item, callback);
-    for (const lazy of lazies) {
-      const { default: router } = await unlazy(lazy.lazied);
+  for (const options2 of pending) {
+    const lazyOptions = traverseContractProcedures(options2, callback);
+    for (const options3 of lazyOptions) {
+      const { default: router } = await unlazy(options3.router);
       pending.push({
-        path: lazy.path,
-        router
+        router,
+        path: options3.path
       });
     }
   }
 }
-function convertPathToHttpPath(path) {
-  return `/${path.map(encodeURIComponent).join("/")}`;
+async function unlazyRouter(router) {
+  if (isProcedure(router)) {
+    return router;
+  }
+  const unlazied = {};
+  for (const key in router) {
+    const item = router[key];
+    const { default: unlaziedRouter } = await unlazy(item);
+    unlazied[key] = await unlazyRouter(unlaziedRouter);
+  }
+  return unlazied;
 }
-function createContractedProcedure(contract, procedure) {
+
+function createAssertedLazyProcedure(lazied) {
+  const lazyProcedure = lazy(async () => {
+    const { default: maybeProcedure } = await unlazy(lazied);
+    if (!isProcedure(maybeProcedure)) {
+      throw new Error(`
+            Expected a lazy<procedure> but got lazy<unknown>.
+            This should be caught by TypeScript compilation.
+            Please report this issue if this makes you feel uncomfortable.
+        `);
+    }
+    return { default: maybeProcedure };
+  }, getLazyMeta(lazied));
+  return lazyProcedure;
+}
+function createContractedProcedure(procedure, contract) {
   return new Procedure({
     ...procedure["~orpc"],
     errorMap: contract["~orpc"].errorMap,
@@ -375,5 +346,12 @@ function createContractedProcedure(contract, procedure) {
     meta: contract["~orpc"].meta
   });
 }
+function call(procedure, input, ...rest) {
+  return createProcedureClient(procedure, ...rest)(input);
+}
+
+function toHttpPath(path) {
+  return `/${path.map(encodeURIComponent).join("/")}`;
+}
 
-export { LAZY_LOADER_SYMBOL as L, Procedure as P, convertPathToHttpPath as a, createContractedProcedure as b, createProcedureClient as c, addMiddleware as d, eachContractProcedure as e, adaptRouter as f, getRouterChild as g, flatLazy as h, isProcedure as i, isLazy as j, createLazyProcedureFormAnyLazy as k, lazy as l, getRouterContract as m, deepSetLazyRouterPrefix as n, getLazyRouterPrefix as o, middlewareOutputFn as p, createAccessibleLazyRouter as q, eachAllContractProcedure as r, setRouterContract as s, unlazy as u };
+export { LAZY_SYMBOL as L, Procedure as P, toHttpPath as a, createContractedProcedure as b, createProcedureClient as c, addMiddleware as d, enhanceRouter as e, isLazy as f, getRouter as g, createAssertedLazyProcedure as h, isProcedure as i, getLazyMeta as j, call as k, lazy as l, middlewareOutputFn as m, getHiddenRouterContract as n, createAccessibleLazyRouter as o, unlazyRouter as p, resolveContractProcedures as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.68378b4",
+  "version": "0.0.0-next.69674a7",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -58,12 +58,12 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/client": "0.0.0-next.68378b4",
-    "@orpc/contract": "0.0.0-next.68378b4",
-    "@orpc/shared": "0.0.0-next.68378b4",
-    "@orpc/standard-server": "0.0.0-next.68378b4",
-    "@orpc/standard-server-fetch": "0.0.0-next.68378b4",
-    "@orpc/standard-server-node": "0.0.0-next.68378b4"
+    "@orpc/standard-server": "0.0.0-next.69674a7",
+    "@orpc/standard-server-fetch": "0.0.0-next.69674a7",
+    "@orpc/standard-server-node": "0.0.0-next.69674a7",
+    "@orpc/client": "0.0.0-next.69674a7",
+    "@orpc/shared": "0.0.0-next.69674a7",
+    "@orpc/contract": "0.0.0-next.69674a7"
   },
   "devDependencies": {
     "light-my-request": "^6.5.1"

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

@@ -1,158 +0,0 @@
-import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
-import { IsNever, MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
-import { ErrorMap, ErrorMapItem, SchemaInput, HTTPPath, Meta, Schema, ContractProcedureDef, SchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure, MergedErrorMap } from '@orpc/contract';
-
-type Context = Record<string, any>;
-type MergedContext<T extends Context, U extends Context> = T & U;
-declare function mergeContext<T extends Context, U extends Context>(context: T, other: U): MergedContext<T, U>;
-type ConflictContextGuard<T extends Context> = true extends IsNever<T> | {
-    [K in keyof T]: IsNever<T[K]>;
-}[keyof T] ? never : unknown;
-
-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, SchemaInput<UInputSchema>> : never : never;
-};
-
-declare const LAZY_LOADER_SYMBOL: unique symbol;
-interface LazyMeta {
-    prefix?: HTTPPath;
-}
-interface Lazy<T> {
-    [LAZY_LOADER_SYMBOL](): Promise<{
-        default: T;
-    }>;
-}
-type Lazyable<T> = T | Lazy<T>;
-interface LazyOptions {
-    prefix?: HTTPPath;
-}
-declare function lazy<T>(loader: () => Promise<{
-    default: T;
-}>): Lazy<T>;
-declare function isLazy(item: unknown): item is Lazy<any>;
-declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
-    default: T extends Lazy<infer U> ? U : T;
-}>;
-
-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<TInContext extends Context, TOutput> {
-    <U extends Context & Partial<TInContext> = 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: string[];
-    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
-    signal?: AbortSignal;
-    lastEventId: string | undefined;
-    next: MiddlewareNextFn<TInContext, 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>;
-
-interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
-    context: TCurrentContext;
-    input: TInput;
-    path: string[];
-    procedure: Procedure<Context, Context, Schema, Schema, unknown, 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 Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    __initialContext?: (type: TInitialContext) => unknown;
-    middlewares: AnyMiddleware[];
-    inputValidationIndex: number;
-    outputValidationIndex: number;
-    handler: ProcedureHandler<TCurrentContext, any, THandlerOutput, any, any>;
-}
-declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>;
-    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>);
-}
-type AnyProcedure = Procedure<any, any, any, any, any, any, any>;
-declare function isProcedure(item: unknown): item is AnyProcedure;
-
-type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
-interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    context: TInitialContext;
-    input: SchemaInput<TInputSchema>;
-    errors: ORPCErrorConstructorMap<TErrorMap>;
-    path: string[];
-    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
-    signal?: AbortSignal;
-    lastEventId: string | undefined;
-}
-/**
- * Options for creating a procedure caller with comprehensive type safety
- */
-type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
-    /**
-     * This is helpful for logging and analytics.
-     */
-    path?: string[];
-    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, SchemaOutput<TOutputSchema, THandlerOutput>, 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 Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
-
-type AccessibleLazyRouter<T extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : Lazy<T> & (T extends AnyProcedure | undefined ? unknown : {
-    [K in keyof T]: T[K] extends AnyRouter ? AccessibleLazyRouter<T[K]> : never;
-});
-declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
-
-type Router<TInitialContext extends Context, TContract extends AnyContractRouter> = Lazyable<TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, any, UErrorMap, UMeta> : {
-    [K in keyof TContract]: TContract[K] extends AnyContractRouter ? Router<TInitialContext, TContract[K]> : never;
-}>;
-type AnyRouter = Router<any, any>;
-type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer UInitialContext, any> ? UInitialContext : never;
-type InferRouterInitialContexts<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : T extends Procedure<infer UInitialContext, any, any, any, any, any, any> ? UInitialContext : {
-    [K in keyof T]: T[K] extends AnyRouter ? InferRouterInitialContexts<T[K]> : never;
-};
-type InferRouterCurrentContexts<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : T extends Procedure<any, infer UCurrentContext, any, any, any, any, any> ? UCurrentContext : {
-    [K in keyof T]: T[K] extends AnyRouter ? InferRouterCurrentContexts<T[K]> : never;
-};
-type InferRouterInputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterInputs<U> : T extends Procedure<any, any, infer UInputSchema, any, any, any, any> ? SchemaInput<UInputSchema> : {
-    [K in keyof T]: T[K] extends AnyRouter ? InferRouterInputs<T[K]> : never;
-};
-type InferRouterOutputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterOutputs<U> : T extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput, any, any> ? SchemaOutput<UOutputSchema, UFuncOutput> : {
-    [K in keyof T]: T[K] extends AnyRouter ? InferRouterOutputs<T[K]> : never;
-};
-type AdaptedRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap> = TRouter extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<AdaptedRouter<U, TInitialContext, TErrorMap>> : TRouter extends Procedure<any, infer UCurrentContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, UCurrentContext, UInputSchema, UOutputSchema, UFuncOutput, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
-    [K in keyof TRouter]: TRouter[K] extends AnyRouter ? AdaptedRouter<TRouter[K], TInitialContext, TErrorMap> : never;
-};
-interface AdaptRouterOptions<TErrorMap extends ErrorMap> {
-    middlewares: AnyMiddleware[];
-    tags?: readonly string[];
-    prefix?: HTTPPath;
-    errorMap: TErrorMap;
-}
-declare function adaptRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap>(router: TRouter, options: AdaptRouterOptions<TErrorMap>): AdaptedRouter<TRouter, TInitialContext, TErrorMap>;
-declare function getRouterChild<T extends AnyRouter | Lazy<undefined>>(router: T, ...path: string[]): T extends Lazy<any> ? Lazy<AnyProcedure> | Lazy<Record<string, AnyRouter>> | Lazy<undefined> : AnyRouter | Lazy<undefined> | undefined;
-
-export { type AnyProcedure as A, type ProcedureDef as B, type Context as C, isProcedure as D, createProcedureClient as E, type InferRouterInitialContexts as F, type InferRouterCurrentContexts as G, type InferRouterInputs as H, type InferRouterInitialContext as I, type InferRouterOutputs as J, adaptRouter as K, type Lazy as L, type Middleware as M, getRouterChild as N, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type AccessibleLazyRouter as Q, type Router as R, createAccessibleLazyRouter as S, type AnyRouter as a, Procedure as b, type ConflictContextGuard as c, type MergedContext as d, type MapInputMiddleware as e, type CreateProcedureClientOptions as f, type ProcedureClient as g, type ProcedureHandler as h, type AdaptRouterOptions as i, type AdaptedRouter as j, type AnyMiddleware as k, type Lazyable as l, mergeContext as m, LAZY_LOADER_SYMBOL as n, type LazyMeta as o, type LazyOptions as p, lazy as q, isLazy as r, type MiddlewareResult as s, type MiddlewareNextFnOptions as t, unlazy as u, type MiddlewareNextFn as v, type MiddlewareOutputFn as w, type MiddlewareOptions as x, middlewareOutputFn as y, type ProcedureHandlerOptions as z };