@temporary-name/server 1.9.3-alpha.30822ad82102dcf9276d473ba372416778807e52 → 1.9.3-alpha.32780b2c7ad58cf8dcbc93a40f13494185223e6e

package/dist/shared/server.Kxw442A9.mjs

@@ -0,0 +1,247 @@
+import { isObject, NullProtoObj, isAsyncIteratorObject, isORPCErrorJson, createORPCErrorFromJson, toORPCError } from '@temporary-name/shared';
+import { mapEventIterator, ErrorEvent } from '@temporary-name/standard-server';
+
+function bracketNotationSerialize(data, segments = [], result = []) {
+  if (Array.isArray(data)) {
+    data.forEach((item, i) => {
+      bracketNotationSerialize(item, [...segments, i], result);
+    });
+  } else if (isObject(data)) {
+    for (const key in data) {
+      bracketNotationSerialize(data[key], [...segments, key], result);
+    }
+  } else {
+    result.push([stringifyPath(segments), data]);
+  }
+  return result;
+}
+function bracketNotationDeserialize(serialized, { maxArrayIndex = 9999 } = {}) {
+  if (serialized.length === 0) {
+    return {};
+  }
+  const arrayPushStyles = /* @__PURE__ */ new WeakSet();
+  const ref = { value: [] };
+  for (const [path, value] of serialized) {
+    const segments = parsePath(path);
+    let currentRef = ref;
+    let nextSegment = "value";
+    segments.forEach((segment, i) => {
+      if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
+        currentRef[nextSegment] = [];
+      }
+      if (i !== segments.length - 1) {
+        if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment, maxArrayIndex)) {
+          if (arrayPushStyles.has(currentRef[nextSegment])) {
+            arrayPushStyles.delete(currentRef[nextSegment]);
+            currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+          } else {
+            currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+          }
+        }
+      } else {
+        if (Array.isArray(currentRef[nextSegment])) {
+          if (segment === "") {
+            if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
+              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+            }
+          } else {
+            if (arrayPushStyles.has(currentRef[nextSegment])) {
+              arrayPushStyles.delete(currentRef[nextSegment]);
+              currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+            } else if (!isValidArrayIndex(segment, maxArrayIndex)) {
+              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+            }
+          }
+        }
+      }
+      currentRef = currentRef[nextSegment];
+      nextSegment = segment;
+    });
+    if (Array.isArray(currentRef) && nextSegment === "") {
+      arrayPushStyles.add(currentRef);
+      currentRef.push(value);
+    } else if (nextSegment in currentRef) {
+      if (Array.isArray(currentRef[nextSegment])) {
+        currentRef[nextSegment].push(value);
+      } else {
+        currentRef[nextSegment] = [currentRef[nextSegment], value];
+      }
+    } else {
+      currentRef[nextSegment] = value;
+    }
+  }
+  return ref.value;
+}
+function stringifyPath(segments) {
+  return segments.map((segment) => {
+    return segment.toString().replace(/[\\[\]]/g, (match) => {
+      switch (match) {
+        case "\\":
+          return "\\\\";
+        case "[":
+          return "\\[";
+        case "]":
+          return "\\]";
+        /* v8 ignore next 2 */
+        default:
+          return match;
+      }
+    });
+  }).reduce((result, segment, i) => {
+    if (i === 0) {
+      return segment;
+    }
+    return `${result}[${segment}]`;
+  }, "");
+}
+function parsePath(path) {
+  const segments = [];
+  let inBrackets = false;
+  let currentSegment = "";
+  let backslashCount = 0;
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    const nextChar = path[i + 1];
+    if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
+      if (nextChar === void 0) {
+        inBrackets = false;
+      }
+      segments.push(currentSegment);
+      currentSegment = "";
+      i++;
+    } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
+      inBrackets = true;
+      segments.push(currentSegment);
+      currentSegment = "";
+    } else if (char === "\\") {
+      backslashCount++;
+    } else {
+      currentSegment += "\\".repeat(backslashCount / 2) + char;
+      backslashCount = 0;
+    }
+  }
+  return inBrackets || segments.length === 0 ? [path] : segments;
+}
+function isValidArrayIndex(value, maxIndex) {
+  return /^0$|^[1-9]\d*$/.test(value) && Number(value) <= maxIndex;
+}
+function arrayToObject(array) {
+  const obj = new NullProtoObj();
+  array.forEach((item, i) => {
+    obj[i] = item;
+  });
+  return obj;
+}
+function pushStyleArrayToObject(array) {
+  const obj = new NullProtoObj();
+  obj[""] = array.length === 1 ? array[0] : array;
+  return obj;
+}
+
+function jsonSerialize(data, hasBlobRef = { value: false }) {
+  if (data instanceof Blob) {
+    hasBlobRef.value = true;
+    return [data, hasBlobRef.value];
+  }
+  if (data instanceof Set) {
+    return jsonSerialize(Array.from(data), hasBlobRef);
+  }
+  if (data instanceof Map) {
+    return jsonSerialize(Array.from(data.entries()), hasBlobRef);
+  }
+  if (Array.isArray(data)) {
+    const json = data.map((v) => v === void 0 ? null : jsonSerialize(v, hasBlobRef)[0]);
+    return [json, hasBlobRef.value];
+  }
+  if (isObject(data)) {
+    const json = {};
+    for (const k in data) {
+      if (k === "toJSON" && typeof data[k] === "function") {
+        continue;
+      }
+      json[k] = jsonSerialize(data[k], hasBlobRef)[0];
+    }
+    return [json, hasBlobRef.value];
+  }
+  if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
+    return [data.toString(), hasBlobRef.value];
+  }
+  if (data instanceof Date) {
+    return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+  }
+  if (Number.isNaN(data)) {
+    return [null, hasBlobRef.value];
+  }
+  return [data, hasBlobRef.value];
+}
+
+function serialize(data, options = {}) {
+  if (isAsyncIteratorObject(data) && !options.outputFormat) {
+    return mapEventIterator(data, {
+      value: async (value) => _serialize(value, { outputFormat: "plain" }),
+      error: async (e) => {
+        return new ErrorEvent({
+          data: _serialize(toORPCError(e).toJSON(), { outputFormat: "plain" }),
+          cause: e
+        });
+      }
+    });
+  }
+  return _serialize(data, options);
+}
+function _serialize(data, options) {
+  const [json, hasBlob] = jsonSerialize(data);
+  if (options.outputFormat === "plain") {
+    return json;
+  }
+  if (options.outputFormat === "URLSearchParams") {
+    const params = new URLSearchParams();
+    for (const [path, value] of bracketNotationSerialize(json)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        params.append(path, value.toString());
+      }
+    }
+    return params;
+  }
+  if (json instanceof Blob || json === void 0 || !hasBlob) {
+    return json;
+  }
+  const form = new FormData();
+  for (const [path, value] of bracketNotationSerialize(json)) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      form.append(path, value.toString());
+    } else if (value instanceof Blob) {
+      form.append(path, value);
+    }
+  }
+  return form;
+}
+function deserialize(data) {
+  if (data instanceof URLSearchParams || data instanceof FormData) {
+    return bracketNotationDeserialize(Array.from(data.entries()));
+  }
+  if (isAsyncIteratorObject(data)) {
+    return mapEventIterator(data, {
+      value: async (value) => value,
+      error: async (e) => {
+        if (e instanceof ErrorEvent && isORPCErrorJson(e.data)) {
+          return createORPCErrorFromJson(e.data, { cause: e });
+        }
+        return e;
+      }
+    });
+  }
+  return data;
+}
+
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function getDynamicParams(path) {
+  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
+    raw: v,
+    name: v.match(/\{\+?([^}]+)\}/)[1]
+  })) : void 0;
+}
+
+export { standardizeHTTPPath as a, bracketNotationDeserialize as b, deserialize as d, getDynamicParams as g, jsonSerialize as j, serialize as s };

package/dist/shared/{server.C1YnHvvf.d.ts → server.XpnxYU3D.d.mts}

@@ -1,5 +1,5 @@
-import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@temporary-name/contract';
-import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, HTTPPath, Promisable, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, Schemas, Meta, ContractProcedureDef, AnyContractRouter, ContractProcedure, InferProcedureClientInputs, InferSchemaOutput, EnhanceRouteOptions, MergedErrorMap, AnyContractProcedure, ContractRouter, AnySchema, ErrorFromErrorMap } from '@temporary-name/contract';
+import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, Promisable, HTTPPath, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
 
 type Context = Record<PropertyKey, any>;
 type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
@@ -13,46 +13,27 @@ type ORPCErrorConstructorMap<T extends ErrorMap> = {
 };
 declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
 
-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>;
-/**
- * Creates a lazy-loaded item.
- *
- * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazyRoute(...)` instead.
- */
-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> {
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput extends {
+    path: any;
+    query: any;
+    body: any;
+}, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     context: TCurrentContext;
     input: TInput;
     path: readonly string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    procedure: Procedure<Context, Context, Schemas, ErrorMap, TMeta>;
     signal?: AbortSignal;
     lastEventId: string | undefined;
     errors: TErrorConstructorMap;
 }
-interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+interface ProcedureHandler<TCurrentContext extends Context, TInput extends {
+    path: any;
+    query: any;
+    body: any;
+}, 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> {
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TSchemas, TErrorMap, TMeta> {
     __initialContext?: (type: TInitialContext) => unknown;
     middlewares: readonly AnyMiddleware[];
     inputValidationIndex: number;
@@ -64,14 +45,14 @@ interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends
  *
  * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
  */
-declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> {
     /**
      * This property holds the defined options.
      */
-    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta>);
 }
-type AnyProcedure = Procedure<any, any, any, any, any, any>;
+type AnyProcedure = Procedure<any, any, Schemas, any, any>;
 declare function isProcedure(item: unknown): item is AnyProcedure;
 
 type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
@@ -92,7 +73,7 @@ interface MiddlewareOutputFn<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>;
+    procedure: Procedure<Context, Context, Schemas, ErrorMap, TMeta>;
     signal?: AbortSignal;
     lastEventId: string | undefined;
     next: MiddlewareNextFn<TOutput>;
@@ -112,41 +93,13 @@ interface MapInputMiddleware<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, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    context: TInitialContext;
-    input: unknown;
-    errors: ORPCErrorConstructorMap<TErrorMap>;
-    path: readonly string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
-    signal?: AbortSignal;
-    lastEventId: string | undefined;
-}
-type CreateProcedureClientOptions<TInitialContext extends Context, 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, TErrorMap, TMeta>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>>[];
-} & (Record<never, never> 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, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
-
 /**
  * Represents a router, which defines a hierarchical structure of procedures.
  *
  * @info A procedure is a router too.
  * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#contract-router Contract Router Docs}
  */
-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> : {
+type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer USchemas, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, USchemas, UErrorMap, UMeta> : {
     [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
 };
 type AnyRouter = Router<any, any>;
@@ -157,7 +110,7 @@ type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infe
  * @info A procedure is a router too.
  * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
  */
-type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any> ? UInitialContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
 };
 /**
@@ -166,7 +119,7 @@ type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer
  * @info A procedure is a router too.
  * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
  */
-type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any, any> ? UCurrentContext : {
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any> ? UCurrentContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
 };
 /**
@@ -175,7 +128,7 @@ type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any,
  * @info A procedure is a router too.
  * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
  */
-type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any, any> ? InferProcedureClientInputs<USchemas> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
 };
 /**
@@ -184,9 +137,111 @@ type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infe
  * @info A procedure is a router too.
  * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
  */
-type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any, any> ? InferSchemaOutput<USchemas['outputSchema']> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 
-export { isProcedure as E, createProcedureClient as F, Procedure as b, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, lazy as q, isLazy as r, getLazyMeta as s, unlazy as u, middlewareOutputFn as z };
-export type { AnyRouter as A, ProcedureHandlerOptions as B, Context as C, ProcedureDef as D, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, Middleware as M, ORPCErrorConstructorMap as O, ProcedureClientInterceptorOptions as P, Router as R, AnyProcedure as a, MergedInitialContext as c, MergedCurrentContext as d, MapInputMiddleware as e, CreateProcedureClientOptions as f, ProcedureClient as g, AnyMiddleware as h, Lazy as i, ProcedureHandler as j, ORPCErrorConstructorMapItemOptions as k, ORPCErrorConstructorMapItem as l, LazyMeta as p, MiddlewareResult as t, MiddlewareNextFnOptions as v, MiddlewareNextFn as w, MiddlewareOutputFn as x, MiddlewareOptions as y };
+declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
+type AccessibleLazyRouter<T extends Lazyable<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : T extends AnyProcedure | undefined ? Lazy<T> : Lazy<T> & {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? AccessibleLazyRouter<T[K]> : never;
+};
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+type EnhancedRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext, TErrorMap>> : T extends (Procedure<infer UInitialContext, infer UCurrentContext, infer USchemas, infer UErrorMap, infer UMeta>) ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, USchemas, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? EnhancedRouter<T[K], TInitialContext, TCurrentContext, TErrorMap> : never;
+};
+interface EnhanceRouterOptions<TErrorMap extends ErrorMap> extends EnhanceRouteOptions {
+    middlewares: readonly AnyMiddleware[];
+    errorMap: TErrorMap;
+    dedupeLeadingMiddlewares: boolean;
+}
+declare function enhanceRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: EnhanceRouterOptions<TErrorMap>): EnhancedRouter<T, TInitialContext, TCurrentContext, TErrorMap>;
+interface TraverseContractProceduresOptions {
+    router: AnyContractRouter | AnyRouter;
+    path: readonly string[];
+}
+interface TraverseContractProcedureCallbackOptions {
+    contract: AnyContractProcedure | AnyProcedure;
+    path: readonly string[];
+}
+/**
+ * @deprecated Use `TraverseContractProcedureCallbackOptions` instead.
+ */
+type ContractProcedureCallbackOptions = TraverseContractProcedureCallbackOptions;
+interface LazyTraverseContractProceduresOptions {
+    router: Lazy<AnyRouter>;
+    path: readonly string[];
+}
+declare function traverseContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void, lazyOptions?: LazyTraverseContractProceduresOptions[]): LazyTraverseContractProceduresOptions[];
+declare function resolveContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void): Promise<void>;
+type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
+};
+declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
+
+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>;
+/**
+ * @internal
+ */
+declare function lazyInternal<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+/**
+ * Creates a lazy-loaded item.
+ *
+ * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazyRoute(...)` instead.
+ */
+declare function lazy<T extends Router<ContractRouter<{}>, any>>(prefix: HTTPPath, loader: () => Promise<{
+    default: T;
+}>): EnhancedRouter<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;
+}>;
+
+type ProcedureClient<TClientContext extends ClientContext, TSchemas extends Schemas, TErrorMap extends ErrorMap> = Client<TClientContext, InferProcedureClientInputs<TSchemas>, InferSchemaOutput<TSchemas['outputSchema']>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: {
+        path: unknown;
+        query: unknown;
+        body: unknown;
+    };
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, Schemas, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+}
+type CreateProcedureClientOptions<TInitialContext extends Context, 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, TErrorMap, TMeta>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>>[];
+} & (Record<never, never> 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, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TSchemas, TErrorMap, TMeta>>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TSchemas['outputSchema'], TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TSchemas, TErrorMap>;
+
+export { traverseContractProcedures as $, middlewareOutputFn as B, isProcedure as G, createProcedureClient as J, Procedure as P, getRouter as T, createAccessibleLazyRouter as V, enhanceRouter as W, resolveContractProcedures as a0, unlazyRouter as a2, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, lazyInternal as q, lazy as r, isLazy as s, getLazyMeta as t, unlazy as u };
+export type { AnyMiddleware as A, Context as C, ProcedureHandlerOptions as D, EnhanceRouterOptions as E, ProcedureDef as F, ProcedureClientInterceptorOptions as H, InferRouterInitialContext as I, InferRouterInitialContexts as K, Lazy as L, Middleware as M, InferRouterCurrentContexts as N, ORPCErrorConstructorMap as O, InferRouterInputs as Q, Router as R, InferRouterOutputs as S, AccessibleLazyRouter as U, TraverseContractProceduresOptions as X, TraverseContractProcedureCallbackOptions as Y, ContractProcedureCallbackOptions as Z, LazyTraverseContractProceduresOptions as _, CreateProcedureClientOptions as a, UnlaziedRouter as a1, ProcedureClient as b, MergedInitialContext as c, MergedCurrentContext as d, ProcedureHandler as e, EnhancedRouter as f, MapInputMiddleware as g, AnyProcedure as h, Lazyable as i, AnyRouter as j, ORPCErrorConstructorMapItemOptions as k, ORPCErrorConstructorMapItem as l, LazyMeta as p, MiddlewareResult as v, MiddlewareNextFnOptions as w, MiddlewareNextFn as x, MiddlewareOutputFn as y, MiddlewareOptions as z };