@temporary-name/server 1.9.3-alpha.03f5d40e5b399f85012c2fb4e98167e26d551d36 → 1.9.3-alpha.0489b23089852dc674460c2b1311b592746e58e1

package/dist/shared/server.BVxcyR6X.mjs

@@ -1,287 +0,0 @@
-import { isObject, stringifyJSON, isORPCErrorStatus, tryDecodeURIComponent, value, toHttpPath, toArray, intercept, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, setSpanError, ORPCError, toORPCError } from '@temporary-name/shared';
-import { flattenHeader } from '@temporary-name/standard-server';
-import { c as createProcedureClient } from './server.DcfsPloY.mjs';
-import { fallbackContractConfig } from '@temporary-name/contract';
-import { d as deserialize, s as serialize, a as standardizeHTTPPath } from './server.BEHw7Eyx.mjs';
-import { traverseContractProcedures, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@temporary-name/server';
-import { createRouter, addRoute, findRoute } from 'rou3';
-
-async function decode(request, params, procedure) {
-  const inputStructure = fallbackContractConfig(
-    "defaultInputStructure",
-    procedure["~orpc"].route.inputStructure
-  );
-  if (inputStructure === "compact") {
-    const data = request.method === "GET" ? deserialize(request.url.searchParams) : deserialize(await request.body());
-    if (data === void 0) {
-      return params;
-    }
-    if (isObject(data)) {
-      return {
-        ...params,
-        ...data
-      };
-    }
-    return data;
-  }
-  const deserializeSearchParams = () => {
-    return deserialize(request.url.searchParams);
-  };
-  return {
-    params,
-    get query() {
-      const value = deserializeSearchParams();
-      Object.defineProperty(this, "query", { value, writable: true });
-      return value;
-    },
-    set query(value) {
-      Object.defineProperty(this, "query", { value, writable: true });
-    },
-    headers: request.headers,
-    body: deserialize(await request.body())
-  };
-}
-function encode(output, procedure) {
-  const successStatus = fallbackContractConfig(
-    "defaultSuccessStatus",
-    procedure["~orpc"].route.successStatus
-  );
-  const outputStructure = fallbackContractConfig(
-    "defaultOutputStructure",
-    procedure["~orpc"].route.outputStructure
-  );
-  if (outputStructure === "compact") {
-    return {
-      status: successStatus,
-      headers: {},
-      body: serialize(output)
-    };
-  }
-  if (!isDetailedOutput(output)) {
-    throw new Error(`
-        Invalid "detailed" output structure:
-        \u2022 Expected an object with optional properties:
-          - status (number 200-399)
-          - headers (Record<string, string | string[]>)
-          - body (any)
-        \u2022 No extra keys allowed.
-
-        Actual value:
-          ${stringifyJSON(output)}
-      `);
-  }
-  return {
-    status: output.status ?? successStatus,
-    headers: output.headers ?? {},
-    body: serialize(output.body)
-  };
-}
-function encodeError(error) {
-  return {
-    status: error.status,
-    headers: {},
-    body: serialize(error.toJSON(), { outputFormat: "plain" })
-  };
-}
-function isDetailedOutput(output) {
-  if (!isObject(output)) {
-    return false;
-  }
-  if (output.headers && !isObject(output.headers)) {
-    return false;
-  }
-  if (output.status !== void 0 && (typeof output.status !== "number" || !Number.isInteger(output.status) || isORPCErrorStatus(output.status))) {
-    return false;
-  }
-  return true;
-}
-
-function resolveFriendlyStandardHandleOptions(options) {
-  return {
-    ...options,
-    context: options.context ?? {}
-    // Context only optional if all fields are optional
-  };
-}
-function toRou3Pattern(path) {
-  return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/**:$1").replace(/\/\{([^}]+)\}/g, "/:$1");
-}
-function decodeParams(params) {
-  return Object.fromEntries(
-    Object.entries(params).map(([key, value]) => [key, tryDecodeURIComponent(value)])
-  );
-}
-
-class StandardOpenAPIMatcher {
-  tree = createRouter();
-  pendingRouters = [];
-  init(router, path = []) {
-    const laziedOptions = traverseContractProcedures({ router, path }, (traverseOptions) => {
-      if (!value(true, traverseOptions)) {
-        return;
-      }
-      const { path: path2, contract } = traverseOptions;
-      const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
-      const httpPath = toRou3Pattern(contract["~orpc"].route.path ?? toHttpPath(path2));
-      if (isProcedure(contract)) {
-        addRoute(this.tree, method, httpPath, {
-          path: path2,
-          contract,
-          procedure: contract,
-          // this mean dev not used contract-first so we can used contract as procedure directly
-          router
-        });
-      } else {
-        addRoute(this.tree, method, httpPath, {
-          path: path2,
-          contract,
-          procedure: void 0,
-          router
-        });
-      }
-    });
-    this.pendingRouters.push(
-      ...laziedOptions.map((option) => ({
-        ...option,
-        httpPathPrefix: toHttpPath(option.path),
-        laziedPrefix: getLazyMeta(option.router).prefix
-      }))
-    );
-  }
-  async match(method, pathname) {
-    if (this.pendingRouters.length) {
-      const newPendingRouters = [];
-      for (const pendingRouter of this.pendingRouters) {
-        if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || pathname.startsWith(pendingRouter.httpPathPrefix)) {
-          const { default: router } = await unlazy(pendingRouter.router);
-          this.init(router, pendingRouter.path);
-        } else {
-          newPendingRouters.push(pendingRouter);
-        }
-      }
-      this.pendingRouters = newPendingRouters;
-    }
-    const match = findRoute(this.tree, method, pathname);
-    if (!match) {
-      return void 0;
-    }
-    if (!match.data.procedure) {
-      const { default: maybeProcedure } = await unlazy(getRouter(match.data.router, match.data.path));
-      if (!isProcedure(maybeProcedure)) {
-        throw new Error(`
-          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.data.path)}.
-          Ensure that the procedure is correctly defined and matches the expected contract.
-        `);
-      }
-      match.data.procedure = createContractedProcedure(maybeProcedure, match.data.contract);
-    }
-    return {
-      path: match.data.path,
-      procedure: match.data.procedure,
-      params: match.params ? decodeParams(match.params) : void 0
-    };
-  }
-}
-
-class CompositeStandardHandlerPlugin {
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-  }
-  init(options, router) {
-    for (const plugin of this.plugins) {
-      plugin.init?.(options, router);
-    }
-  }
-}
-
-class StandardHandler {
-  interceptors;
-  clientInterceptors;
-  rootInterceptors;
-  matcher;
-  constructor(router, options) {
-    this.matcher = new StandardOpenAPIMatcher();
-    const plugins = new CompositeStandardHandlerPlugin(options.plugins);
-    plugins.init(options, router);
-    this.interceptors = toArray(options.interceptors);
-    this.clientInterceptors = toArray(options.clientInterceptors);
-    this.rootInterceptors = toArray(options.rootInterceptors);
-    this.matcher.init(router);
-  }
-  async handle(request, options) {
-    const prefix = options.prefix?.replace(/\/$/, "") || void 0;
-    if (prefix && !request.url.pathname.startsWith(`${prefix}/`) && request.url.pathname !== prefix) {
-      return { matched: false, response: void 0 };
-    }
-    return intercept(this.rootInterceptors, { ...options, request, prefix }, async (interceptorOptions) => {
-      return runWithSpan({ name: `${request.method} ${request.url.pathname}` }, async (span) => {
-        let step;
-        try {
-          return await intercept(
-            this.interceptors,
-            interceptorOptions,
-            async ({ request: request2, context, prefix: prefix2 }) => {
-              const method = request2.method;
-              const url = request2.url;
-              const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
-              const match = await runWithSpan(
-                { name: "find_procedure" },
-                () => this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`)
-              );
-              if (!match) {
-                return { matched: false, response: void 0 };
-              }
-              span?.updateName(`${ORPC_NAME}.${match.path.join("/")}`);
-              span?.setAttribute("rpc.system", ORPC_NAME);
-              span?.setAttribute("rpc.method", match.path.join("."));
-              step = "decode_input";
-              let input = await runWithSpan(
-                { name: "decode_input" },
-                () => decode(request2, match.params, match.procedure)
-              );
-              step = void 0;
-              if (isAsyncIteratorObject(input)) {
-                input = asyncIteratorWithSpan(
-                  { name: "consume_event_iterator_input", signal: request2.signal },
-                  input
-                );
-              }
-              const client = createProcedureClient(match.procedure, {
-                context,
-                path: match.path,
-                interceptors: this.clientInterceptors
-              });
-              step = "call_procedure";
-              const output = await client(input, {
-                signal: request2.signal,
-                lastEventId: flattenHeader(request2.headers["last-event-id"])
-              });
-              step = void 0;
-              const response = encode(output, match.procedure);
-              return {
-                matched: true,
-                response
-              };
-            }
-          );
-        } catch (e) {
-          if (step !== "call_procedure") {
-            setSpanError(span, e);
-          }
-          const error = step === "decode_input" && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
-            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
-            cause: e
-          }) : toORPCError(e);
-          const response = encodeError(error);
-          return {
-            matched: true,
-            response
-          };
-        }
-      });
-    });
-  }
-}
-
-export { CompositeStandardHandlerPlugin as C, StandardHandler as S, encodeError as a, StandardOpenAPIMatcher as b, decodeParams as c, decode as d, encode as e, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };

package/dist/shared/server.Bk5r0-2R.d.ts

@@ -1,56 +0,0 @@
-import { Meta } from '@temporary-name/contract';
-import { HTTPPath, Interceptor } from '@temporary-name/shared';
-import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
-import { C as Context, R as Router, E as ProcedureClientInterceptorOptions } from './server.CZNLCQBm.js';
-
-interface StandardHandlerPlugin<T extends Context> {
-    order?: number;
-    init?(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
-}
-declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
-    protected readonly plugins: TPlugin[];
-    constructor(plugins?: readonly TPlugin[]);
-    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
-}
-
-interface StandardHandleOptions<T extends Context> {
-    prefix?: HTTPPath;
-    context: T;
-}
-type StandardHandleResult = {
-    matched: true;
-    response: StandardResponse;
-} | {
-    matched: false;
-    response: undefined;
-};
-interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
-    request: StandardLazyRequest;
-}
-interface StandardHandlerOptions<TContext extends Context> {
-    plugins?: StandardHandlerPlugin<TContext>[];
-    /**
-     * Interceptors at the request level, helpful when you want catch errors
-     */
-    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
-    /**
-     * Interceptors at the root level, helpful when you want override the request/response
-     */
-    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
-    /**
-     *
-     * Interceptors for procedure client.
-     */
-    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
-}
-declare class StandardHandler<T extends Context> {
-    private readonly interceptors;
-    private readonly clientInterceptors;
-    private readonly rootInterceptors;
-    private readonly matcher;
-    constructor(router: Router<any, T>, options: NoInfer<StandardHandlerOptions<T>>);
-    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
-}
-
-export { CompositeStandardHandlerPlugin as C, StandardHandler as e };
-export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardHandleOptions as c, StandardHandleResult as d };

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

@@ -1,23 +0,0 @@
-import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.CZNLCQBm.mjs';
-import { c as StandardHandleOptions } from './server.CbLTWfgn.mjs';
-
-type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
-/**
- * {@link https://github.com/unjs/rou3}
- *
- * @internal
- */
-declare function toRou3Pattern(path: HTTPPath): string;
-/**
- * @internal
- */
-declare function decodeParams(params: Record<string, string>): Record<string, string>;
-
-export { decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };
-export type { FriendlyStandardHandleOptions as F };

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

@@ -1,192 +0,0 @@
-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';
-
-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;
-declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
-
-type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
-type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
-type ORPCErrorConstructorMap<T extends ErrorMap> = {
-    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
-};
-declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
-
-declare 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> {
-    context: TCurrentContext;
-    input: TInput;
-    path: readonly string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
-    signal?: AbortSignal;
-    lastEventId: string | undefined;
-    errors: TErrorConstructorMap;
-}
-interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
-}
-interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    __initialContext?: (type: TInitialContext) => unknown;
-    middlewares: readonly AnyMiddleware[];
-    inputValidationIndex: number;
-    outputValidationIndex: number;
-    handler: ProcedureHandler<TCurrentContext, any, any, any, any>;
-}
-/**
- * This class represents a procedure.
- *
- * @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> {
-    /**
-     * This property holds the defined options.
-     */
-    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
-}
-type AnyProcedure = Procedure<any, any, AnySchema, AnySchema, any, any>;
-declare function isProcedure(item: unknown): item is AnyProcedure;
-
-type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
-    output: TOutput;
-    context: TOutContext;
-}>;
-type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
-    context?: TOutContext;
-} : {
-    context: TOutContext;
-};
-interface MiddlewareNextFn<TOutput> {
-    <U extends Context = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
-}
-interface MiddlewareOutputFn<TOutput> {
-    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
-}
-interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
-    context: TInContext;
-    path: readonly string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
-    signal?: AbortSignal;
-    lastEventId: string | undefined;
-    next: MiddlewareNextFn<TOutput>;
-    errors: TErrorConstructorMap;
-}
-/**
- * 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, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
-    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
-}
-type AnyMiddleware = Middleware<any, any, any, any, any, any>;
-interface MapInputMiddleware<TInput, TMappedInput> {
-    (input: TInput): TMappedInput;
-}
-declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
-
-type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
-interface ProcedureClientInterceptorOptions<TInitialContext extends Context, 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> : {
-    [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
-};
-type AnyRouter = Router<any, any>;
-type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infer UInitialContext> ? UInitialContext : never;
-/**
- * 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, 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, 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 UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
-    [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, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
-    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
-};
-
-export { isProcedure as D, createProcedureClient as F, Procedure as P, createORPCErrorConstructorMap as l, mergeCurrentContext as m, LAZY_SYMBOL as n, lazy as p, isLazy as q, getLazyMeta as r, unlazy as u, middlewareOutputFn as y };
-export type { AnyMiddleware as A, ProcedureDef as B, Context as C, ProcedureClientInterceptorOptions as E, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, MergedInitialContext as M, ORPCErrorConstructorMap as O, Router as R, CreateProcedureClientOptions as a, ProcedureClient as b, AnyRouter as c, Lazy as d, AnyProcedure as e, Middleware as f, MergedCurrentContext as g, ProcedureHandler as h, MapInputMiddleware as i, ORPCErrorConstructorMapItemOptions as j, ORPCErrorConstructorMapItem as k, LazyMeta as o, MiddlewareResult as s, MiddlewareNextFnOptions as t, MiddlewareNextFn as v, MiddlewareOutputFn as w, MiddlewareOptions as x, ProcedureHandlerOptions as z };