@temporary-name/server 1.9.3-alpha.a252b3ff8cb6bf7deaa6d41dc9ac8a8d50edd80e → 1.9.3-alpha.a253b67a3639148c12f13a47295e1922182adecd

package/dist/shared/server.D-DR5Z00.mjs

@@ -0,0 +1,362 @@
+import { mergePrefix, enhanceRoute, ValidationError } from '@temporary-name/contract';
+import { resolveMaybeOptionalOptions, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan, ORPCError } from '@temporary-name/shared';
+import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
+import { safeDecodeAsync, safeEncodeAsync } from '@temporary-name/zod';
+
+function isStartWithMiddlewares(middlewares, compare) {
+  if (compare.length > middlewares.length) {
+    return false;
+  }
+  for (let i = 0; i < middlewares.length; i++) {
+    if (compare[i] === void 0) {
+      return true;
+    }
+    if (middlewares[i] !== compare[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function mergeMiddlewares(first, second, options) {
+  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
+    return second;
+  }
+  return [...first, ...second];
+}
+function addMiddleware(middlewares, addition) {
+  return [...middlewares, addition];
+}
+
+class Contract {
+  /**
+   * This property holds the defined options.
+   */
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+}
+class Procedure extends Contract {
+}
+function isProcedure(item) {
+  return item instanceof Procedure || // This is so we'll return true for Proxy-wrapped Procedures e.g. as returned by `callable`
+  (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "route" in item["~orpc"] && "meta" in item["~orpc"] && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
+}
+
+function mergeCurrentContext(context, other) {
+  return { ...context, ...other };
+}
+
+function getRouter(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);
+    return lazyInternal(async () => {
+      const unwrapped = await unlazy(lazied);
+      const next = getRouter(unwrapped.default, rest);
+      return unlazy(next);
+    }, getLazyMeta(lazied));
+  }
+  return current;
+}
+function createAccessibleLazyRouter(lazied) {
+  const recursive = new Proxy(lazied, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = getRouter(lazied, [key]);
+      return createAccessibleLazyRouter(next);
+    }
+  });
+  return recursive;
+}
+function enhanceRouter(router, options) {
+  if (isLazy(router)) {
+    const laziedMeta = getLazyMeta(router);
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+    const enhanced2 = lazyInternal(
+      async () => {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = enhanceRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      },
+      {
+        ...laziedMeta,
+        prefix: enhancedPrefix
+      }
+    );
+    const accessible = createAccessibleLazyRouter(enhanced2);
+    return accessible;
+  }
+  if (isProcedure(router)) {
+    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, {
+      dedupeLeading: options.dedupeLeadingMiddlewares
+    });
+    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      route: enhanceRoute(router["~orpc"].route, options),
+      middlewares: newMiddlewares,
+      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
+      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
+    });
+    return enhanced2;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceRouter(router[key], options);
+  }
+  return enhanced;
+}
+function traverseContractProcedures(options, callback, lazyOptions = []) {
+  let currentRouter = options.router;
+  if (isLazy(currentRouter)) {
+    lazyOptions.push({
+      router: currentRouter,
+      path: options.path
+    });
+  } else if (currentRouter instanceof Contract) {
+    callback({
+      contract: currentRouter,
+      path: options.path
+    });
+  } else if (typeof currentRouter === "string") {
+    throw new Error("Unexpected: got string instead of router");
+  } else {
+    for (const key in currentRouter) {
+      traverseContractProcedures(
+        {
+          router: currentRouter[key],
+          path: [...options.path, key]
+        },
+        callback,
+        lazyOptions
+      );
+    }
+  }
+  return lazyOptions;
+}
+async function resolveContractProcedures(options, callback) {
+  const pending = [options];
+  for (const options2 of pending) {
+    const lazyOptions = traverseContractProcedures(options2, callback);
+    for (const options3 of lazyOptions) {
+      const { default: router } = await unlazy(options3.router);
+      pending.push({
+        router,
+        path: options3.path
+      });
+    }
+  }
+}
+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;
+}
+
+const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazyInternal(loader, meta = {}) {
+  return {
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
+  };
+}
+function lazy(prefix, loader) {
+  return enhanceRouter(lazyInternal(loader), {
+    middlewares: [],
+    dedupeLeadingMiddlewares: true,
+    prefix
+  });
+}
+function isLazy(item) {
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+}
+function getLazyMeta(lazied) {
+  return lazied[LAZY_SYMBOL].meta;
+}
+function unlazy(lazied) {
+  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+}
+
+function middlewareOutputFn(output) {
+  return { output, context: {} };
+}
+
+function createProcedureClient(lazyableProcedure, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
+  return async (...[input, callerOptions]) => {
+    const path = toArray(options.path);
+    const { default: procedure } = await unlazy(lazyableProcedure);
+    const clientContext = callerOptions?.context ?? {};
+    const context = await value(options.context ?? {}, clientContext);
+    const output = await runWithSpan({ name: "call_procedure", signal: callerOptions?.signal }, (span) => {
+      span?.setAttribute("procedure.path", [...path]);
+      return intercept(
+        toArray(options.interceptors),
+        {
+          context,
+          input,
+          path,
+          procedure,
+          request: callerOptions?.request,
+          signal: callerOptions?.signal,
+          lastEventId: callerOptions?.lastEventId
+        },
+        (interceptorOptions) => {
+          const { input: input2, ...opts } = interceptorOptions;
+          return executeProcedureInternal(interceptorOptions.procedure, input2, opts);
+        }
+      );
+    });
+    if (isAsyncIteratorObject(output)) {
+      if (output instanceof HibernationEventIterator) {
+        return output;
+      }
+      return overlayProxy(
+        output,
+        mapEventIterator(
+          asyncIteratorWithSpan(
+            { name: "consume_event_iterator_output", signal: callerOptions?.signal },
+            output
+          ),
+          {
+            value: (v) => v,
+            error: async (e) => e
+          }
+        )
+      );
+    }
+    return output;
+  };
+}
+async function validateInput(procedure, input) {
+  const schemas = procedure["~orpc"].schemas;
+  return runWithSpan({ name: "validate_input" }, async () => {
+    const resultBody = await safeDecodeAsync(schemas.bodySchema, input.body, { parseType: "body" });
+    const resultPath = await safeDecodeAsync(schemas.pathSchema, input.path, { parseType: "path" });
+    const resultQuery = await safeDecodeAsync(schemas.querySchema, input.query, { parseType: "query" });
+    const issues = [];
+    if (!resultBody.success) {
+      issues.push(...resultBody.error.issues.map((i) => ({ ...i, path: ["body", ...i.path] })));
+    }
+    if (!resultPath.success) {
+      issues.push(...resultPath.error.issues.map((i) => ({ ...i, path: ["path", ...i.path] })));
+    }
+    if (!resultQuery.success) {
+      issues.push(...resultQuery.error.issues.map((i) => ({ ...i, path: ["query", ...i.path] })));
+    }
+    if (issues.length > 0) {
+      throw new ORPCError("BAD_REQUEST", {
+        message: "Input validation failed",
+        data: {
+          issues
+        },
+        cause: new ValidationError({
+          message: "Input validation failed",
+          issues,
+          data: input
+        })
+      });
+    }
+    const results = {
+      body: resultBody.data,
+      path: resultPath.data,
+      query: resultQuery.data
+    };
+    return results;
+  });
+}
+async function validateOutput(procedure, output) {
+  const schema = procedure["~orpc"].schemas.outputSchema;
+  if (!schema) {
+    return output;
+  }
+  return runWithSpan({ name: "validate_output" }, async () => {
+    const result = await safeEncodeAsync(schema, output, { parseType: "output" });
+    if (!result.success) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Output validation failed",
+        cause: new ValidationError({
+          message: "Output validation failed",
+          issues: result.error.issues,
+          data: output
+        })
+      });
+    }
+    return result.data;
+  });
+}
+async function executeProcedureInternal(procedure, input, options) {
+  const middlewares = procedure["~orpc"].middlewares;
+  const inputValidationIndex = Math.min(
+    Math.max(0, procedure["~orpc"].inputValidationIndex),
+    middlewares.length
+  );
+  const outputValidationIndex = Math.min(
+    Math.max(0, procedure["~orpc"].outputValidationIndex),
+    middlewares.length
+  );
+  const next = async (index, context, input2) => {
+    let currentInput = input2;
+    if (index === inputValidationIndex) {
+      currentInput = await validateInput(procedure, currentInput);
+    }
+    const mid = middlewares[index];
+    const output = mid ? await runWithSpan({ name: `middleware.${mid.name}`, signal: options.signal }, async (span) => {
+      span?.setAttribute("middleware.index", index);
+      span?.setAttribute("middleware.name", mid.name);
+      const result = await mid(
+        {
+          ...options,
+          context,
+          next: async (...[nextOptions]) => {
+            const nextContext = nextOptions?.context ?? {};
+            return {
+              output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+              // NB: Pretty sure this isn't used (or meant to be used) at runtime, it's just there
+              // to get type inference in the builder (via the caller returning the output of next() in
+              // the middleware function)
+              context: nextContext
+            };
+          }
+        },
+        currentInput,
+        middlewareOutputFn
+      );
+      return result.output;
+    }) : await runWithSpan(
+      { name: "handler", signal: options.signal },
+      () => procedure["~orpc"].handler(currentInput, { ...options, context })
+    );
+    if (index === outputValidationIndex) {
+      return await validateOutput(procedure, output);
+    }
+    return output;
+  };
+  return next(0, options.context, input);
+}
+
+export { Contract as C, LAZY_SYMBOL as L, Procedure as P, addMiddleware as a, isLazy as b, createProcedureClient as c, getRouter as d, enhanceRouter as e, lazy as f, getLazyMeta as g, middlewareOutputFn as h, isProcedure as i, isStartWithMiddlewares as j, mergeMiddlewares as k, lazyInternal as l, mergeCurrentContext as m, createAccessibleLazyRouter as n, unlazyRouter as o, resolveContractProcedures as r, traverseContractProcedures as t, unlazy as u };

package/dist/shared/{server.BEHw7Eyx.mjs → server.JtIZ8YG7.mjs}

@@ -234,14 +234,4 @@ function deserialize(data) {
   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, deserialize as d, getDynamicParams as g, jsonSerialize as j, serialize as s };
+export { bracketNotationDeserialize as b, deserialize as d, jsonSerialize as j, serialize as s };

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

@@ -0,0 +1,252 @@
+import { Meta, Schemas, Route, InferProcedureClientInputs, InferSchemaOutput, EnhanceRouteOptions, AnySchema } from '@temporary-name/contract';
+import { Promisable, StandardLazyRequest, HTTPPath, ClientContext, Interceptor, Value, Client, MaybeOptionalOptions } 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>;
+type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+type BuildContextWithAuth<TContext extends Context, TAuthContext> = MergedCurrentContext<TContext, {
+    auth: TAuthContext | ('auth' extends keyof TContext ? TContext['auth'] : never);
+}>;
+declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = {}>(options?: {
+        context?: U;
+    }): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TMeta extends Meta> extends ProcedureHandlerOptions<TInContext, TMeta> {
+    next: MiddlewareNextFn<TOutput>;
+}
+/**
+ * A function that represents a middleware.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+ */
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+type DefaultProcedureHandlerOptions = ProcedureHandlerOptions<Context, Meta>;
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TMeta extends Meta> {
+    context: TCurrentContext;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, Schemas, TMeta>;
+    signal?: AbortSignal;
+    request?: StandardLazyRequest;
+    lastEventId: string | undefined;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput extends {
+    path: any;
+    query: any;
+    body: any;
+}, THandlerOutput, TMeta extends Meta> {
+    (input: TInput, opt: ProcedureHandlerOptions<TCurrentContext, TMeta>): Promisable<THandlerOutput>;
+}
+interface ContractDef<TInitialContext extends Context, TSchemas extends Schemas, TMeta extends Meta> {
+    meta: TMeta;
+    route: Route;
+    schemas: TSchemas;
+    middlewares: readonly Middleware<TInitialContext, any, any, any, any>[];
+    authConfigs: TypedAuthConfig[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+}
+type AnyContractDef = ContractDef<Context, Schemas, Meta>;
+declare class Contract<TDef extends AnyContractDef = AnyContractDef> {
+    /**
+     * This property holds the defined options.
+     */
+    '~orpc': TDef;
+    constructor(def: TDef);
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TMeta extends Meta> extends ContractDef<TInitialContext, TSchemas, TMeta> {
+    handler: ProcedureHandler<TCurrentContext, any, any, any>;
+}
+/**
+ * This class represents a procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
+ */
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TMeta extends Meta> extends Contract<ProcedureDef<TInitialContext, TCurrentContext, TSchemas, TMeta>> {
+}
+type AnyProcedure = Procedure<any, any, Schemas, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type ValidatedAuthContext = {};
+interface BasicAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> {
+    tokenPrefix?: string;
+    validate: (username: string, password: string, options: ProcedureHandlerOptions<TCurrentContext, TMeta>) => Promisable<TAuthContext>;
+}
+interface TokenAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> {
+    tokenPrefix?: string;
+    validate: (token: string, options: ProcedureHandlerOptions<TCurrentContext, TMeta>) => Promisable<TAuthContext>;
+}
+interface NamedTokenAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> extends TokenAuthConfig<TAuthContext, TCurrentContext, TMeta> {
+    name: string;
+}
+type AuthType = 'header' | 'query' | 'cookie' | 'bearer' | 'basic' | 'none';
+type AuthConfig<TAuthType extends AuthType, TAuthContext extends ValidatedAuthContext = ValidatedAuthContext, TCurrentContext extends Context = Context, TMeta extends Meta = Meta> = TAuthType extends 'basic' ? BasicAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'bearer' ? TokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'header' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'query' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'cookie' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'none' ? {} : never;
+type TypedAuthConfig<TAuthType extends AuthType = AuthType> = {
+    type: TAuthType;
+} & AuthConfig<TAuthType, object>;
+
+type ContractRouter = Contract | {
+    [k: string]: ContractRouter;
+};
+/**
+ * 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<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any> | {
+    [k: string]: Lazyable<Router<TInitialContext>>;
+};
+type AnyRouter = Router<any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer UInitialContext> ? UInitialContext : never;
+/**
+ * Infer all initial context of the router.
+ *
+ * @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> ? UInitialContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
+};
+/**
+ * Infer all current context of the router.
+ *
+ * @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> ? UCurrentContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
+};
+/**
+ * Infer all router inputs
+ *
+ * @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 USchemas, any> ? InferProcedureClientInputs<USchemas> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
+};
+/**
+ * Infer all router outputs
+ *
+ * @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, infer USchemas, any> ? InferSchemaOutput<USchemas['outputSchema']> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
+};
+
+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> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext>> : T extends Procedure<infer UInitialContext, infer UCurrentContext, infer USchemas, infer UMeta> ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, USchemas, UMeta> : {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? EnhancedRouter<T[K], TInitialContext, TCurrentContext> : never;
+};
+interface EnhanceRouterOptions extends EnhanceRouteOptions {
+    middlewares: readonly AnyMiddleware[];
+    dedupeLeadingMiddlewares: boolean;
+}
+declare function enhanceRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context>(router: T, options: EnhanceRouterOptions): EnhancedRouter<T, TInitialContext, TCurrentContext>;
+interface TraverseContractProceduresOptions {
+    router: ContractRouter | AnyRouter;
+    path: readonly string[];
+}
+interface TraverseContractProcedureCallbackOptions {
+    contract: Contract;
+    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<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> = Client<TClientContext, InferProcedureClientInputs<TSchemas>, InferSchemaOutput<TSchemas['outputSchema']>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TMeta extends Meta> extends ProcedureHandlerOptions<TInitialContext, TMeta> {
+    input: {
+        path: unknown;
+        query: unknown;
+        body: unknown;
+    };
+}
+type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: readonly string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TMeta>, Promise<InferSchemaOutput<TOutputSchema>>>[];
+} & (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, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TSchemas, TMeta>>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TSchemas['outputSchema'], TMeta, TClientContext>>): ProcedureClient<TClientContext, TSchemas>;
+
+export { middlewareOutputFn as D, isProcedure as K, createProcedureClient as O, Procedure as P, getRouter as X, createAccessibleLazyRouter as Z, enhanceRouter as _, traverseContractProcedures as a3, resolveContractProcedures as a4, unlazyRouter as a6, Contract as c, mergeCurrentContext as o, LAZY_SYMBOL as p, lazyInternal as r, lazy as s, isLazy as t, getLazyMeta as u, unlazy as v };
+export type { TraverseContractProceduresOptions as $, AuthType as A, BuildContextWithAuth as B, Context as C, EnhanceRouterOptions as E, DefaultProcedureHandlerOptions as F, ProcedureHandlerOptions as G, AnyContractDef as H, InferRouterInitialContext as I, ProcedureDef as J, Lazy as L, Middleware as M, ProcedureClientInterceptorOptions as N, ContractRouter as Q, Router as R, InferRouterInitialContexts as S, InferRouterCurrentContexts as T, InferRouterInputs as U, ValidatedAuthContext as V, InferRouterOutputs as W, AccessibleLazyRouter as Y, CreateProcedureClientOptions as a, TraverseContractProcedureCallbackOptions as a0, ContractProcedureCallbackOptions as a1, LazyTraverseContractProceduresOptions as a2, UnlaziedRouter as a5, ProcedureClient as b, MergedInitialContext as d, MergedCurrentContext as e, AuthConfig as f, ProcedureHandler as g, EnhancedRouter as h, MapInputMiddleware as i, ContractDef as j, AnyMiddleware as k, AnyProcedure as l, Lazyable as m, AnyRouter as n, LazyMeta as q, MiddlewareResult as w, MiddlewareNextFn as x, MiddlewareOutputFn as y, MiddlewareOptions as z };