@orpc/server 0.0.0-next.eaf61c7 → 0.0.0-next.eb3d98a

package/dist/helpers/index.d.ts

@@ -0,0 +1,130 @@
+import { SerializeOptions, ParseOptions } from 'cookie';
+
+/**
+ * Encodes a Uint8Array to base64url format
+ * Base64url is URL-safe and doesn't use padding
+ *
+ * @example
+ * ```ts
+ * const text = "Hello World"
+ * const encoded = encodeBase64url(new TextEncoder().encode(text))
+ * const decoded = decodeBase64url(encoded)
+ * expect(new TextDecoder().decode(decoded)).toEqual(text)
+ * ```
+ */
+declare function encodeBase64url(data: Uint8Array): string;
+/**
+ * Decodes a base64url string to Uint8Array
+ * Returns undefined if the input is invalid
+ *
+ * @example
+ * ```ts
+ * const text = "Hello World"
+ * const encoded = encodeBase64url(new TextEncoder().encode(text))
+ * const decoded = decodeBase64url(encoded)
+ * expect(new TextDecoder().decode(decoded)).toEqual(text)
+ * ```
+ */
+declare function decodeBase64url(base64url: string | undefined | null): Uint8Array | undefined;
+
+interface SetCookieOptions extends SerializeOptions {
+    /**
+     * Specifies the value for the [`Path` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.4).
+     *
+     * @default '/'
+     */
+    path?: string;
+}
+/**
+ * Sets a cookie in the response headers,
+ *
+ * Does nothing if `headers` is `undefined`.
+ *
+ * @example
+ * ```ts
+ * const headers = new Headers()
+ *
+ * setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
+ *
+ * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; HttpOnly; Max-Age=3600')
+ * ```
+ *
+ */
+declare function setCookie(headers: Headers | undefined, name: string, value: string, options?: SetCookieOptions): void;
+interface GetCookieOptions extends ParseOptions {
+}
+/**
+ * Gets a cookie value from request headers
+ *
+ * Returns `undefined` if the cookie is not found or headers are `undefined`.
+ *
+ * @example
+ * ```ts
+ * const headers = new Headers({ 'Cookie': 'sessionId=abc123; theme=dark' })
+ *
+ * const sessionId = getCookie(headers, 'sessionId')
+ *
+ * expect(sessionId).toEqual('abc123')
+ * ```
+ */
+declare function getCookie(headers: Headers | undefined, name: string, options?: GetCookieOptions): string | undefined;
+
+/**
+ * Encrypts a string using AES-GCM with a secret key.
+ * The output is base64url encoded to be URL-safe.
+ *
+ * @example
+ * ```ts
+ * const encrypted = await encrypt("Hello, World!", "test-secret-key")
+ * const decrypted = await decrypt(encrypted, "test-secret-key")
+ * expect(decrypted).toBe("Hello, World!")
+ * ```
+ */
+declare function encrypt(value: string, secret: string): Promise<string>;
+/**
+ * Decrypts a base64url encoded string using AES-GCM with a secret key.
+ * Returns the original string if decryption is successful, or undefined if it fails.
+ *
+ * @example
+ * ```ts
+ * const encrypted = await encrypt("Hello, World!", "test-secret-key")
+ * const decrypted = await decrypt(encrypted, "test-secret-key")
+ * expect(decrypted).toBe("Hello, World!")
+ * ```
+ */
+declare function decrypt(encrypted: string | undefined | null, secret: string): Promise<string | undefined>;
+
+/**
+ * Signs a string value using HMAC-SHA256 with a secret key.
+ *
+ * This function creates a cryptographic signature that can be used to verify
+ * the integrity and authenticity of the data. The signature is appended to
+ * the original value, separated by a dot, using base64url encoding (no padding).
+ *
+ *
+ * @example
+ * ```ts
+ * const signedValue = await sign("user123", "my-secret-key")
+ * expect(signedValue).toEqual("user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA")
+ * ```
+ */
+declare function sign(value: string, secret: string): Promise<string>;
+/**
+ * Verifies and extracts the original value from a signed string.
+ *
+ * This function validates the signature of a previously signed value using the same
+ * secret key. If the signature is valid, it returns the original value. If the
+ * signature is invalid or the format is incorrect, it returns undefined.
+ *
+ *
+ * @example
+ * ```ts
+ * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
+ * const originalValue = await unsign(signedValue, "my-secret-key")
+ * expect(originalValue).toEqual("user123")
+ * ```
+ */
+declare function unsign(signedValue: string | undefined | null, secret: string): Promise<string | undefined>;
+
+export { decodeBase64url, decrypt, encodeBase64url, encrypt, getCookie, setCookie, sign, unsign };
+export type { GetCookieOptions, SetCookieOptions };

package/dist/helpers/index.mjs

@@ -0,0 +1,182 @@
+import { serialize, parse } from 'cookie';
+
+function encodeBase64url(data) {
+  const chunkSize = 8192;
+  let binaryString = "";
+  for (let i = 0; i < data.length; i += chunkSize) {
+    const chunk = data.subarray(i, i + chunkSize);
+    binaryString += String.fromCharCode(...chunk);
+  }
+  const base64 = btoa(binaryString);
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function decodeBase64url(base64url) {
+  try {
+    if (typeof base64url !== "string") {
+      return void 0;
+    }
+    let base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+    while (base64.length % 4) {
+      base64 += "=";
+    }
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+  } catch {
+    return void 0;
+  }
+}
+
+function setCookie(headers, name, value, options = {}) {
+  if (headers === void 0) {
+    return;
+  }
+  const cookieString = serialize(name, value, {
+    path: "/",
+    ...options
+  });
+  headers.append("Set-Cookie", cookieString);
+}
+function getCookie(headers, name, options = {}) {
+  if (headers === void 0) {
+    return void 0;
+  }
+  const cookieHeader = headers.get("cookie");
+  if (cookieHeader === null) {
+    return void 0;
+  }
+  return parse(cookieHeader, options)[name];
+}
+
+const PBKDF2_CONFIG = {
+  name: "PBKDF2",
+  iterations: 6e4,
+  // Recommended minimum iterations per current OWASP guidelines
+  hash: "SHA-256"
+};
+const AES_GCM_CONFIG = {
+  name: "AES-GCM",
+  length: 256
+};
+const CRYPTO_CONSTANTS = {
+  SALT_LENGTH: 16,
+  IV_LENGTH: 12
+};
+async function encrypt(value, secret) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const salt = crypto.getRandomValues(new Uint8Array(CRYPTO_CONSTANTS.SALT_LENGTH));
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    PBKDF2_CONFIG.name,
+    false,
+    ["deriveKey"]
+  );
+  const key = await crypto.subtle.deriveKey(
+    { ...PBKDF2_CONFIG, salt },
+    keyMaterial,
+    AES_GCM_CONFIG,
+    false,
+    ["encrypt"]
+  );
+  const iv = crypto.getRandomValues(new Uint8Array(CRYPTO_CONSTANTS.IV_LENGTH));
+  const encrypted = await crypto.subtle.encrypt(
+    { name: AES_GCM_CONFIG.name, iv },
+    key,
+    data
+  );
+  const result = new Uint8Array(salt.length + iv.length + encrypted.byteLength);
+  result.set(salt, 0);
+  result.set(iv, salt.length);
+  result.set(new Uint8Array(encrypted), salt.length + iv.length);
+  return encodeBase64url(result);
+}
+async function decrypt(encrypted, secret) {
+  try {
+    const data = decodeBase64url(encrypted);
+    if (data === void 0) {
+      return void 0;
+    }
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    const salt = data.slice(0, CRYPTO_CONSTANTS.SALT_LENGTH);
+    const iv = data.slice(CRYPTO_CONSTANTS.SALT_LENGTH, CRYPTO_CONSTANTS.SALT_LENGTH + CRYPTO_CONSTANTS.IV_LENGTH);
+    const encryptedData = data.slice(CRYPTO_CONSTANTS.SALT_LENGTH + CRYPTO_CONSTANTS.IV_LENGTH);
+    const keyMaterial = await crypto.subtle.importKey(
+      "raw",
+      encoder.encode(secret),
+      PBKDF2_CONFIG.name,
+      false,
+      ["deriveKey"]
+    );
+    const key = await crypto.subtle.deriveKey(
+      { ...PBKDF2_CONFIG, salt },
+      keyMaterial,
+      AES_GCM_CONFIG,
+      false,
+      ["decrypt"]
+    );
+    const decrypted = await crypto.subtle.decrypt(
+      { name: AES_GCM_CONFIG.name, iv },
+      key,
+      encryptedData
+    );
+    return decoder.decode(decrypted);
+  } catch {
+    return void 0;
+  }
+}
+
+const ALGORITHM = { name: "HMAC", hash: "SHA-256" };
+async function sign(value, secret) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    ALGORITHM,
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign(
+    ALGORITHM,
+    key,
+    encoder.encode(value)
+  );
+  return `${value}.${encodeBase64url(new Uint8Array(signature))}`;
+}
+async function unsign(signedValue, secret) {
+  if (typeof signedValue !== "string") {
+    return void 0;
+  }
+  const lastDotIndex = signedValue.lastIndexOf(".");
+  if (lastDotIndex === -1) {
+    return void 0;
+  }
+  const value = signedValue.slice(0, lastDotIndex);
+  const signatureBase64url = signedValue.slice(lastDotIndex + 1);
+  const signature = decodeBase64url(signatureBase64url);
+  if (signature === void 0) {
+    return void 0;
+  }
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    ALGORITHM,
+    false,
+    ["verify"]
+  );
+  const isValid = await crypto.subtle.verify(
+    ALGORITHM,
+    key,
+    signature,
+    encoder.encode(value)
+  );
+  return isValid ? value : void 0;
+}
+
+export { decodeBase64url, decrypt, encodeBase64url, encrypt, getCookie, setCookie, sign, unsign };

package/dist/hibernation/index.d.mts

@@ -1,8 +1,8 @@
 import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
-import { a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.Dq8xr7PQ.mjs';
+import { g as StandardHandlerPlugin, e as StandardHandlerOptions } from '../shared/server.gqRxT-yN.mjs';
 import { experimental_HibernationEventIterator } from '@orpc/standard-server';
 export { experimental_HibernationEventIterator, experimental_HibernationEventIteratorCallback } from '@orpc/standard-server';
-import { C as Context, R as Router } from '../shared/server.DD2C4ujN.mjs';
+import { C as Context, R as Router } from '../shared/server.CYNGeoCm.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@orpc/shared';
@@ -24,9 +24,9 @@ interface experimental_EncodeHibernationRPCEventOptions extends StandardRPCJsonS
  *
  * @see {@link https://orpc.unnoq.com/docs/plugins/hibernation Hibernation Plugin}
  */
-declare function experimental_encodeHibernationRPCEvent(id: number, payload: unknown, options?: experimental_EncodeHibernationRPCEventOptions): string;
+declare function experimental_encodeHibernationRPCEvent(id: string, payload: unknown, options?: experimental_EncodeHibernationRPCEventOptions): string;
 
-interface experimental_HibernationContext {
+interface experimental_HibernationPluginContext {
     iterator?: experimental_HibernationEventIterator<any>;
 }
 /**
@@ -35,10 +35,10 @@ interface experimental_HibernationContext {
  * @see {@link https://orpc.unnoq.com/docs/plugins/hibernation Hibernation Plugin}
  */
 declare class experimental_HibernationPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    readonly HIBERNATION_CONTEXT_SYMBOL: symbol;
+    readonly CONTEXT_SYMBOL: symbol;
     order: number;
     init(options: StandardHandlerOptions<T>, _router: Router<any, T>): void;
 }
 
 export { experimental_HibernationPlugin, experimental_encodeHibernationRPCEvent };
-export type { experimental_EncodeHibernationRPCEventOptions, experimental_HibernationContext };
+export type { experimental_EncodeHibernationRPCEventOptions, experimental_HibernationPluginContext };

package/dist/hibernation/index.d.ts

@@ -1,8 +1,8 @@
 import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
-import { a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.-ACo36I0.js';
+import { g as StandardHandlerPlugin, e as StandardHandlerOptions } from '../shared/server.Bmh5xd4n.js';
 import { experimental_HibernationEventIterator } from '@orpc/standard-server';
 export { experimental_HibernationEventIterator, experimental_HibernationEventIteratorCallback } from '@orpc/standard-server';
-import { C as Context, R as Router } from '../shared/server.DD2C4ujN.js';
+import { C as Context, R as Router } from '../shared/server.CYNGeoCm.js';
 import '@orpc/client';
 import '@orpc/contract';
 import '@orpc/shared';
@@ -24,9 +24,9 @@ interface experimental_EncodeHibernationRPCEventOptions extends StandardRPCJsonS
  *
  * @see {@link https://orpc.unnoq.com/docs/plugins/hibernation Hibernation Plugin}
  */
-declare function experimental_encodeHibernationRPCEvent(id: number, payload: unknown, options?: experimental_EncodeHibernationRPCEventOptions): string;
+declare function experimental_encodeHibernationRPCEvent(id: string, payload: unknown, options?: experimental_EncodeHibernationRPCEventOptions): string;
 
-interface experimental_HibernationContext {
+interface experimental_HibernationPluginContext {
     iterator?: experimental_HibernationEventIterator<any>;
 }
 /**
@@ -35,10 +35,10 @@ interface experimental_HibernationContext {
  * @see {@link https://orpc.unnoq.com/docs/plugins/hibernation Hibernation Plugin}
  */
 declare class experimental_HibernationPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    readonly HIBERNATION_CONTEXT_SYMBOL: symbol;
+    readonly CONTEXT_SYMBOL: symbol;
     order: number;
     init(options: StandardHandlerOptions<T>, _router: Router<any, T>): void;
 }
 
 export { experimental_HibernationPlugin, experimental_encodeHibernationRPCEvent };
-export type { experimental_EncodeHibernationRPCEventOptions, experimental_HibernationContext };
+export type { experimental_EncodeHibernationRPCEventOptions, experimental_HibernationPluginContext };

package/dist/hibernation/index.mjs

@@ -22,7 +22,7 @@ function experimental_encodeHibernationRPCEvent(id, payload, options = {}) {
 }
 
 class experimental_HibernationPlugin {
-  HIBERNATION_CONTEXT_SYMBOL = Symbol("HIBERNATION_CONTEXT");
+  CONTEXT_SYMBOL = Symbol("ORPC_HIBERNATION_CONTEXT");
   order = 2e6;
   // make sure execute after the batch plugin
   init(options, _router) {
@@ -33,7 +33,7 @@ class experimental_HibernationPlugin {
       const result = await options2.next({
         ...options2,
         context: {
-          [this.HIBERNATION_CONTEXT_SYMBOL]: hibernationContext,
+          [this.CONTEXT_SYMBOL]: hibernationContext,
           ...options2.context
         }
       });
@@ -49,7 +49,7 @@ class experimental_HibernationPlugin {
       };
     });
     options.clientInterceptors.unshift(async (options2) => {
-      const hibernationContext = options2.context[this.HIBERNATION_CONTEXT_SYMBOL];
+      const hibernationContext = options2.context[this.CONTEXT_SYMBOL];
       if (!hibernationContext) {
         throw new TypeError("[HibernationPlugin] Hibernation context has been corrupted or modified by another plugin or interceptor");
       }

package/dist/index.d.mts

@@ -1,11 +1,13 @@
-import { ORPCErrorJSON, ORPCError, Client, ClientContext, HTTPPath, HTTPMethod, ClientPromiseResult } from '@orpc/client';
+import { ORPCErrorJSON, ORPCError, Client, ClientContext, HTTPPath, HTTPMethod, ClientOptions, ClientPromiseResult } from '@orpc/client';
 export { ClientContext, HTTPMethod, HTTPPath, ORPCError, isDefinedError, safe } from '@orpc/client';
-import { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ErrorFromErrorMap, Meta, MergedErrorMap, Route, EnhanceRouteOptions, AnyContractRouter, AnyContractProcedure, Schema, ContractRouter, ContractProcedureDef, ContractProcedure, InferContractRouterErrorMap, InferContractRouterMeta } from '@orpc/contract';
+import { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ErrorFromErrorMap, Meta, MergedErrorMap, Route, Schema, ContractRouter, ContractProcedureDef, AnyContractRouter, ContractProcedure, InferContractRouterErrorMap, InferContractRouterMeta, AnyContractProcedure } from '@orpc/contract';
 export { ContractProcedure, ContractProcedureDef, ContractRouter, ErrorMap, ErrorMapItem, InferSchemaInput, InferSchemaOutput, InputStructure, MergedErrorMap, Meta, OutputStructure, Route, Schema, ValidationError, eventIterator, type } from '@orpc/contract';
 import { ThrowableError, IntersectPick, MaybeOptionalOptions } from '@orpc/shared';
-export { EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, IntersectPick, Registry, ThrowableError, onError, onFinish, onStart, onSuccess } from '@orpc/shared';
-import { C as Context, P as Procedure, M as Middleware, O as ORPCErrorConstructorMap, a as MergedInitialContext, b as MergedCurrentContext, c as MapInputMiddleware, d as CreateProcedureClientOptions, e as ProcedureClient, A as AnyMiddleware, L as Lazyable, f as AnyRouter, g as Lazy, h as AnyProcedure, i as ProcedureHandler, R as Router, I as InferRouterInitialContext } from './shared/server.DD2C4ujN.mjs';
-export { J as InferRouterCurrentContexts, H as InferRouterInitialContexts, K as InferRouterInputs, N as InferRouterOutputs, n as LAZY_SYMBOL, o as LazyMeta, w as MiddlewareNextFn, t as MiddlewareNextFnOptions, y as MiddlewareOptions, x as MiddlewareOutputFn, s as MiddlewareResult, k as ORPCErrorConstructorMapItem, j as ORPCErrorConstructorMapItemOptions, F as ProcedureClientInterceptorOptions, D as ProcedureDef, B as ProcedureHandlerOptions, l as createORPCErrorConstructorMap, G as createProcedureClient, r as getLazyMeta, q as isLazy, E as isProcedure, p as lazy, m as mergeCurrentContext, z as middlewareOutputFn, u as unlazy, v as validateORPCError } from './shared/server.DD2C4ujN.mjs';
+export { EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, IntersectPick, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
+import { C as Context, P as Procedure, e as Middleware, O as ORPCErrorConstructorMap, M as MergedInitialContext, f as MergedCurrentContext, g as MapInputMiddleware, h as CreateProcedureClientOptions, i as ProcedureClient, j as ProcedureHandler, R as Router, c as Lazy, a as AnyMiddleware, b as AnyRouter, A as AnyProcedure, L as Lazyable, I as InferRouterInitialContext } from './shared/server.CYNGeoCm.mjs';
+export { J as InferRouterCurrentContexts, H as InferRouterInitialContexts, K as InferRouterInputs, N as InferRouterOutputs, o as LAZY_SYMBOL, p as LazyMeta, x as MiddlewareNextFn, w as MiddlewareNextFnOptions, z as MiddlewareOptions, y as MiddlewareOutputFn, t as MiddlewareResult, l as ORPCErrorConstructorMapItem, k as ORPCErrorConstructorMapItemOptions, d as ProcedureClientInterceptorOptions, E as ProcedureDef, D as ProcedureHandlerOptions, n as createORPCErrorConstructorMap, G as createProcedureClient, s as getLazyMeta, r as isLazy, F as isProcedure, q as lazy, m as mergeCurrentContext, B as middlewareOutputFn, u as unlazy, v as validateORPCError } from './shared/server.CYNGeoCm.mjs';
+import { E as EnhanceRouterOptions, a as EnhancedRouter } from './shared/server.DhJj-1X9.mjs';
+export { A as AccessibleLazyRouter, C as ContractProcedureCallbackOptions, L as LazyTraverseContractProceduresOptions, T as TraverseContractProcedureCallbackOptions, b as TraverseContractProceduresOptions, U as UnlaziedRouter, c as createAccessibleLazyRouter, e as enhanceRouter, g as getRouter, r as resolveContractProcedures, t as traverseContractProcedures, u as unlazyRouter } from './shared/server.DhJj-1X9.mjs';
 export { getEventMeta, withEventMeta } from '@orpc/standard-server';
 
 type ActionableError<T> = T extends ORPCError<infer U, infer V> ? ORPCErrorJSON<U, V> & {
@@ -80,39 +82,6 @@ declare class DecoratedProcedure<TInitialContext extends Context, TCurrentContex
     actionable(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, Record<never, never>>>): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta> & ProcedureActionableClient<TInputSchema, TOutputSchema, TErrorMap>;
 }
 
-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 UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, UInputSchema, UOutputSchema, 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 ContractProcedureCallbackOptions {
-    contract: AnyContractProcedure;
-    path: readonly string[];
-}
-interface LazyTraverseContractProceduresOptions {
-    router: Lazy<AnyRouter>;
-    path: readonly string[];
-}
-declare function traverseContractProcedures(options: TraverseContractProceduresOptions, callback: (options: ContractProcedureCallbackOptions) => void, lazyOptions?: LazyTraverseContractProceduresOptions[]): LazyTraverseContractProceduresOptions[];
-declare function resolveContractProcedures(options: TraverseContractProceduresOptions, callback: (options: ContractProcedureCallbackOptions) => 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>>;
-
 interface BuilderWithMiddlewares<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
     /**
      * This property holds the defined options.
@@ -510,7 +479,7 @@ declare class Builder<TInitialContext extends Context, TCurrentContext extends C
     /**
      * Sets or overrides the config.
      *
-     * @see {@link https://orpc.unnoq.com/docs/lifecycle#middlewares-order Middlewares Order Docs}
+     * @see {@link https://orpc.unnoq.com/docs/client/server-side#middlewares-order Middlewares Order Docs}
      * @see {@link https://orpc.unnoq.com/docs/best-practices/dedupe-middleware#configuration Dedupe Middleware Docs}
      */
     $config(config: BuilderConfig): Builder<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
@@ -730,9 +699,9 @@ interface RouterImplementerWithMiddlewares<T extends AnyContractRouter, TInitial
         default: U;
     }>): EnhancedRouter<Lazy<U>, TInitialContext, TCurrentContext, Record<never, never>>;
 }
-type ImplementerInternalWithMiddlewares<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = (TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, UInputSchema, UOutputSchema, UErrorMap, UMeta> : RouterImplementerWithMiddlewares<TContract, TInitialContext, TCurrentContext> & {
+type ImplementerInternalWithMiddlewares<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, UInputSchema, UOutputSchema, 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> {
     /**
@@ -768,9 +737,9 @@ interface RouterImplementer<T extends AnyContractRouter, TInitialContext extends
         default: U;
     }>): EnhancedRouter<Lazy<U>, TInitialContext, TCurrentContext, Record<never, never>>;
 }
-type ImplementerInternal<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = (TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, UInputSchema, UOutputSchema, UErrorMap, UMeta> : RouterImplementer<TContract, TInitialContext, TCurrentContext> & {
+type ImplementerInternal<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, UInputSchema, UOutputSchema, 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, config: BuilderConfig, middlewares: AnyMiddleware[]): ImplementerInternal<T, TInitialContext, TCurrentContext>;
 type Implementer<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = {
     /**
@@ -782,7 +751,7 @@ type Implementer<TContract extends AnyContractRouter, TInitialContext extends Co
     /**
      * Sets or overrides the config.
      *
-     * @see {@link https://orpc.unnoq.com/docs/lifecycle#middlewares-order Middlewares Order Docs}
+     * @see {@link https://orpc.unnoq.com/docs/client/server-side#middlewares-order Middlewares Order Docs}
      * @see {@link https://orpc.unnoq.com/docs/best-practices/dedupe-middleware#configuration Dedupe Middleware Docs}
      */
     $config(config: BuilderConfig): Implementer<TContract, TInitialContext, TCurrentContext>;
@@ -815,7 +784,7 @@ declare function createContractedProcedure(procedure: AnyProcedure, contract: An
  * ```
  *
  */
-declare function call<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta>(procedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, input: InferSchemaInput<TInputSchema>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, Record<never, never>>>): ClientPromiseResult<InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+declare function call<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta>(procedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, input: InferSchemaInput<TInputSchema>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, Record<never, never>> & Omit<ClientOptions<Record<never, never>>, 'context'>>): ClientPromiseResult<InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
 
 type RouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext = Record<never, never>> = TRouter extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
     [K in keyof TRouter]: TRouter[K] extends Lazyable<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : never;
@@ -830,5 +799,5 @@ declare function createRouterClient<T extends AnyRouter, TClientContext extends
 declare function setHiddenRouterContract<T extends Lazyable<AnyRouter>>(router: T, contract: AnyContractRouter): T;
 declare function getHiddenRouterContract(router: Lazyable<AnyRouter | AnyContractRouter>): AnyContractRouter | undefined;
 
-export { AnyMiddleware, AnyProcedure, AnyRouter, Builder, Context, CreateProcedureClientOptions, DecoratedProcedure, InferRouterInitialContext, Lazy, Lazyable, MapInputMiddleware, MergedCurrentContext, MergedInitialContext, Middleware, ORPCErrorConstructorMap, Procedure, ProcedureClient, ProcedureHandler, Router, addMiddleware, call, createAccessibleLazyRouter, createActionableClient, createAssertedLazyProcedure, createContractedProcedure, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getHiddenRouterContract, getRouter, implement, implementerInternal, inferRPCMethodFromRouter, isStartWithMiddlewares, mergeMiddlewares, os, resolveContractProcedures, setHiddenRouterContract, traverseContractProcedures, unlazyRouter };
-export type { AccessibleLazyRouter, ActionableClient, ActionableClientRest, ActionableClientResult, ActionableError, BuilderConfig, BuilderDef, BuilderWithMiddlewares, Config, ContractProcedureCallbackOptions, DecoratedMiddleware, EnhanceRouterOptions, EnhancedRouter, ImplementedProcedure, Implementer, ImplementerInternal, ImplementerInternalWithMiddlewares, LazyTraverseContractProceduresOptions, ProcedureActionableClient, ProcedureBuilder, ProcedureBuilderWithInput, ProcedureBuilderWithInputOutput, ProcedureBuilderWithOutput, ProcedureImplementer, RouterBuilder, RouterClient, RouterImplementer, RouterImplementerWithMiddlewares, TraverseContractProceduresOptions, UnactionableError, UnlaziedRouter };
+export { AnyMiddleware, AnyProcedure, AnyRouter, Builder, Context, CreateProcedureClientOptions, DecoratedProcedure, EnhanceRouterOptions, EnhancedRouter, InferRouterInitialContext, Lazy, Lazyable, MapInputMiddleware, MergedCurrentContext, MergedInitialContext, Middleware, ORPCErrorConstructorMap, Procedure, ProcedureClient, ProcedureHandler, Router, addMiddleware, call, createActionableClient, createAssertedLazyProcedure, createContractedProcedure, createRouterClient, decorateMiddleware, fallbackConfig, getHiddenRouterContract, implement, implementerInternal, inferRPCMethodFromRouter, isStartWithMiddlewares, mergeMiddlewares, os, setHiddenRouterContract };
+export type { ActionableClient, ActionableClientRest, ActionableClientResult, ActionableError, BuilderConfig, BuilderDef, BuilderWithMiddlewares, Config, DecoratedMiddleware, ImplementedProcedure, Implementer, ImplementerInternal, ImplementerInternalWithMiddlewares, ProcedureActionableClient, ProcedureBuilder, ProcedureBuilderWithInput, ProcedureBuilderWithInputOutput, ProcedureBuilderWithOutput, ProcedureImplementer, RouterBuilder, RouterClient, RouterImplementer, RouterImplementerWithMiddlewares, UnactionableError };