@orpc/server 2.0.0-beta.47 → 2.0.0-beta.49

package/dist/procedure.d.ts

@@ -0,0 +1,72 @@
+import type { AnySchema, ErrorMap, ORPCErrorConstructorMap, ProcedureContractDefinition } from '@orpc/contract';
+import type { Promisable } from '@orpc/shared';
+import type { Context } from './context.ts';
+import type { AnyMiddleware } from './middleware.ts';
+export interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    context: TCurrentContext;
+    input: TInput;
+    path: string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap>;
+    signal?: AbortSignal | undefined;
+    lastEventId?: string | undefined;
+    errors: TErrorConstructorMap;
+}
+export interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Promisable<THandlerOutput>;
+}
+export interface OrderedMiddleware {
+    /**
+     * Snapshot of `inputSchemas.length`
+     * at the time this middleware was used.
+     *
+     * @default 0
+     */
+    inputSchemasLengthAtUse?: number | undefined;
+    /**
+     * Snapshot of `outputSchemas.length`
+     * at the time this middleware was used.
+     *
+     * @default 0
+     */
+    outputSchemasLengthAtUse?: number | undefined;
+    middleware: AnyMiddleware;
+}
+export interface ProcedureConfig {
+    /**
+     * When enabled, input schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * @remarks
+     * **Warning**: Do not disable validation for schemas that transform values.
+     *
+     * @default false
+     */
+    disableInputValidation?: boolean | undefined;
+    /**
+     * When enabled, output schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * Useful when output schemas exist only for specification generation.
+     *
+     * @remarks
+     * **Warning**: Do not disable validation for schemas that transform values.
+     *
+     * @default false
+     */
+    disableOutputValidation?: boolean | undefined;
+}
+export interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>, ProcedureConfig {
+    __TInitialContext?: (type: TInitialContext) => unknown;
+    __TInjectedContext?: (type: TInjectedContext) => unknown;
+    orderedMiddlewares: OrderedMiddleware[];
+    handler: ProcedureHandler<any, any, any, any>;
+}
+export declare class Procedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    '~orpc': ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+    constructor(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>);
+    /**
+     * Checks if the given instance satisfies the {@link Procedure} class/interface.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+export type AnyProcedure = Procedure<any, any, any, any, any>;

package/dist/procedure.js

@@ -0,0 +1,24 @@
+import { ProcedureContract } from '@orpc/contract';
+import { getConstructor } from '@orpc/shared';
+export class Procedure {
+    '~orpc';
+    constructor(def) {
+        this['~orpc'] = def;
+    }
+    /**
+     * Checks if the given instance satisfies the {@link Procedure} class/interface.
+     */
+    static [Symbol.hasInstance](instance) {
+        if (this !== Procedure) {
+            // fallback to default instanceof check if this is extended class
+            return Function.prototype[Symbol.hasInstance].call(this, instance);
+        }
+        const constructor = getConstructor(instance);
+        if (constructor === Procedure) {
+            return true;
+        }
+        return (instance instanceof ProcedureContract &&
+            Array.isArray(instance['~orpc'].orderedMiddlewares) &&
+            typeof instance['~orpc'].handler === 'function');
+    }
+}

package/dist/router-client.d.ts

@@ -0,0 +1,23 @@
+import type { ClientContext } from '@orpc/client';
+import type { ErrorMap, Schema } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { Lazyable } from './lazy.ts';
+import type { ProcedureClient, ProcedureClientOptions } from './procedure-client.ts';
+import { Procedure } from './procedure.ts';
+import type { AnyRouter, InferRouterInitialContext } from './router.ts';
+/**
+ * The client type derived from a router, exposing every procedure as a callable
+ * function while preserving the router's shape.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#creating-a-client | Client-Side Clients - Creating a Client}
+ */
+export type RouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext = object> = TRouter extends Procedure<any, any, infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureClient<TClientContext, $InputSchema, $OutputSchema, $ErrorMap> : {
+    [K in keyof TRouter]: TRouter[K] extends Lazyable<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : never;
+};
+/**
+ * Creates a server-side client that calls the router's procedures directly,
+ * within the same process, without any network layer.
+ *
+ * @see {@link https://orpc.dev/docs/client/server-side#router-clients | Server-Side Clients - Router Clients}
+ */
+export declare function createRouterClient<T extends AnyRouter, TClientContext extends ClientContext = object>(router: Lazyable<T | undefined>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<InferRouterInitialContext<T>, Schema<unknown>, ErrorMap, TClientContext>>): RouterClient<T, TClientContext>;

package/dist/router-client.js

@@ -0,0 +1,43 @@
+import { RECURSIVE_CLIENT_UNWRAP_KEYS } from '@orpc/client';
+import { resolveMaybeOptionalOptions, toArray } from '@orpc/shared';
+import { Lazy } from './lazy.js';
+import { createProcedureClient } from './procedure-client.js';
+import { createGuardedProcedureLazy } from './procedure-utils.js';
+import { Procedure } from './procedure.js';
+import { getRouter } from './router-utils.js';
+/**
+ * Creates a server-side client that calls the router's procedures directly,
+ * within the same process, without any network layer.
+ *
+ * @see {@link https://orpc.dev/docs/client/server-side#router-clients | Server-Side Clients - Router Clients}
+ */
+export function createRouterClient(router, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    if (router instanceof Procedure) {
+        return createProcedureClient(router, options);
+    }
+    const procedureCaller = router instanceof Lazy ? createProcedureClient(createGuardedProcedureLazy(router), options) : {};
+    const cache = new Map();
+    const recursive = new Proxy(procedureCaller, {
+        get(target, key) {
+            if (typeof key !== 'string' ||
+                (router instanceof Lazy && RECURSIVE_CLIENT_UNWRAP_KEYS.has(key))) {
+                return Reflect.get(target, key);
+            }
+            let nextClient = cache.get(key);
+            if (nextClient === undefined) {
+                const next = getRouter(router, [key]);
+                if (!next) {
+                    return Reflect.get(target, key);
+                }
+                nextClient = createRouterClient(next, {
+                    ...options,
+                    path: [...toArray(options.path), key],
+                });
+                cache.set(key, nextClient);
+            }
+            return nextClient;
+        },
+    });
+    return recursive;
+}

package/dist/router-hidden.d.ts

@@ -0,0 +1,5 @@
+import type { RouterContract } from '@orpc/contract';
+import type { Lazyable } from './lazy.ts';
+import type { AnyRouter } from './router.ts';
+export declare function withHiddenRouterContract<T extends Lazyable<AnyRouter>>(router: T, contract: RouterContract): T;
+export declare function getHiddenRouterContract(router: Lazyable<AnyRouter | RouterContract>): RouterContract | undefined;

package/dist/router-hidden.js

@@ -0,0 +1,14 @@
+const HIDDEN_ROUTER_CONTRACT_SYMBOL = /* @__PURE__ */ Symbol.for('ORPC_HIDDEN_ROUTER_CONTRACT');
+export function withHiddenRouterContract(router, contract) {
+    return new Proxy(router, {
+        get(target, key) {
+            if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
+                return contract;
+            }
+            return Reflect.get(target, key);
+        },
+    });
+}
+export function getHiddenRouterContract(router) {
+    return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
+}

package/dist/router-utils.d.ts

@@ -0,0 +1,48 @@
+import type { AnyProcedureContract, AugmentContractRouterOptions, ErrorMap, MergedErrorMap, RouterContract } from '@orpc/contract';
+import type { Promisable } from '@orpc/shared';
+import type { Context, MergedInitialContext } from './context.ts';
+import type { Lazyable } from './lazy.ts';
+import { Lazy } from './lazy.ts';
+import type { AnyMiddleware } from './middleware.ts';
+import type { AnyProcedure, ProcedureConfig } from './procedure.ts';
+import { Procedure } from './procedure.ts';
+import type { AnyRouter } from './router.ts';
+export type AugmentedRouter<T extends AnyRouter, TErrorMap extends ErrorMap> = T extends Procedure<infer $InitialContext, infer $CurrentContext, infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<$InitialContext, $CurrentContext, $InputSchema, $OutputSchema, MergedErrorMap<TErrorMap, $ErrorMap>> : {
+    [K in keyof T]: T[K] extends Lazy<infer $ extends AnyRouter> ? Lazy<AugmentedRouter<$, TErrorMap>> : T[K] extends AnyRouter ? AugmentedRouter<T[K], TErrorMap> : never;
+};
+export type AugmentedRouterWithMiddlewares<T extends AnyRouter, TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> = T extends Procedure<infer $InitialContext, infer $CurrentContext, infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<MergedInitialContext<TInitialContext, TInjectedContext, $InitialContext>, $CurrentContext, $InputSchema, $OutputSchema, MergedErrorMap<TErrorMap, $ErrorMap>> : {
+    [K in keyof T]: T[K] extends Lazy<infer $ extends AnyRouter> ? Lazy<AugmentedRouterWithMiddlewares<$, TInitialContext, TInjectedContext, TErrorMap>> : T[K] extends AnyRouter ? AugmentedRouterWithMiddlewares<T[K], TInitialContext, TInjectedContext, TErrorMap> : never;
+};
+interface AugmentRouterOptions<TErrorMap extends ErrorMap> extends AugmentContractRouterOptions<TErrorMap>, ProcedureConfig {
+    middlewares: AnyMiddleware[];
+}
+export declare function augmentRouter<T extends AnyRouter, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: AugmentRouterOptions<TErrorMap>): AugmentedRouter<T, TErrorMap> | AugmentedRouterWithMiddlewares<T, TInitialContext, TCurrentContext, TErrorMap>;
+interface AugmentImplementedRouterOptions extends ProcedureConfig {
+    middlewares: AnyMiddleware[];
+}
+export declare function augmentImplementedRouter<T extends AnyRouter, TInitialContext extends Context, TCurrentContext extends Context>(router: T, options: AugmentImplementedRouterOptions): AugmentedRouter<T, object> | AugmentedRouterWithMiddlewares<T, TInitialContext, TCurrentContext, object>;
+/**
+ * Resolves the procedure of a contract walked from a router: the procedure itself,
+ * or the implementation of a contract-first procedure, looked up by its path.
+ *
+ * @throws {TypeError} If a contract-first procedure has no valid implementation.
+ */
+export declare function resolveContractProcedure(router: AnyRouter, contract: AnyProcedureContract, path: readonly string[]): Promise<AnyProcedure>;
+export declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
+export interface WalkProcedureContractsLazyResult {
+    router: Lazy<AnyRouter>;
+    path: string[];
+}
+export declare function walkProcedureContractsSync(router: RouterContract | AnyRouter, callback: (contract: AnyProcedureContract | AnyProcedure, path: string[]) => void, path?: string[]): WalkProcedureContractsLazyResult[];
+export declare function walkProcedureContractsAsync(router: RouterContract | AnyRouter, callback: (contract: AnyProcedureContract | AnyProcedure, path: string[]) => Promisable<void>, path?: string[]): Promise<void>;
+export type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
+};
+/**
+ * Fully resolves all lazy routers inside a router, returning a plain router.
+ * Useful for making a router with lazy parts contract-compatible.
+ *
+ * @see {@link https://orpc.dev/docs/contract/router#router-to-contract | Router Contract - Router to Contract}
+ */
+export declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
+export {};

package/dist/router-utils.js

@@ -0,0 +1,202 @@
+import { mergeErrorMap, ProcedureContract, resolveMetaPlugins } from '@orpc/contract';
+import { getOwn, isNonPrimitive, omit, setOwn } from '@orpc/shared';
+import { Lazy, unlazy } from './lazy.js';
+import { createContractProcedure } from './procedure-utils.js';
+import { Procedure } from './procedure.js';
+import { getHiddenRouterContract } from './router-hidden.js';
+export function augmentRouter(router, options) {
+    if (router instanceof Lazy) {
+        const [meta, metaPlugins] = resolveMetaPlugins(options.meta, options.metaPlugins, router['~orpc'].metaPlugins);
+        const enhanced = new Lazy({
+            meta,
+            metaPlugins,
+            async loader() {
+                const { default: unlaziedRouter } = await unlazy(router);
+                const enhanced = augmentRouter(unlaziedRouter, options);
+                return unlazy(enhanced);
+            },
+        });
+        return enhanced;
+    }
+    if (router instanceof Procedure) {
+        const [meta, metaPlugins] = resolveMetaPlugins(options.meta, options.metaPlugins, router['~orpc'].metaPlugins);
+        const enhanced = new Procedure({
+            ...omit(options, ['middlewares', 'errorMap', 'meta', 'metaPlugins']),
+            ...router['~orpc'],
+            meta,
+            metaPlugins,
+            errorMap: mergeErrorMap(options.errorMap, router['~orpc'].errorMap),
+            orderedMiddlewares: [
+                ...options.middlewares.map((middleware) => ({
+                    middleware,
+                    inputSchemasLengthAtUse: 0,
+                    outputSchemasLengthAtUse: 0,
+                })),
+                ...router['~orpc'].orderedMiddlewares,
+            ],
+        });
+        return enhanced;
+    }
+    if (!isNonPrimitive(router)) {
+        return router;
+    }
+    const enhanced = {};
+    for (const [key, child] of Object.entries(router)) {
+        setOwn(enhanced, key, augmentRouter(child, options));
+    }
+    return enhanced;
+}
+export function augmentImplementedRouter(router, options) {
+    if (router instanceof Lazy) {
+        const enhanced = new Lazy({
+            ...router['~orpc'],
+            async loader() {
+                const { default: unlaziedRouter } = await unlazy(router);
+                const enhanced = augmentImplementedRouter(unlaziedRouter, options);
+                return unlazy(enhanced);
+            },
+        });
+        return enhanced;
+    }
+    if (router instanceof Procedure) {
+        const enhanced = new Procedure({
+            ...omit(options, ['middlewares']),
+            ...router['~orpc'],
+            orderedMiddlewares: [
+                ...options.middlewares.map((middleware) => ({
+                    middleware,
+                    inputSchemasLengthAtUse: 0,
+                    outputSchemasLengthAtUse: 0,
+                })),
+                ...router['~orpc'].orderedMiddlewares,
+            ],
+        });
+        return enhanced;
+    }
+    if (!isNonPrimitive(router)) {
+        return router;
+    }
+    const enhanced = {};
+    for (const [key, child] of Object.entries(router)) {
+        setOwn(enhanced, key, augmentImplementedRouter(child, options));
+    }
+    return enhanced;
+}
+/**
+ * Resolves the procedure of a contract walked from a router: the procedure itself,
+ * or the implementation of a contract-first procedure, looked up by its path.
+ *
+ * @throws {TypeError} If a contract-first procedure has no valid implementation.
+ */
+export async function resolveContractProcedure(router, contract, path) {
+    if (contract instanceof Procedure) {
+        return contract;
+    }
+    const { default: maybeProcedure } = await unlazy(getRouter(router, path));
+    if (!(maybeProcedure instanceof Procedure)) {
+        throw new TypeError(`[Contract-First] Missing or invalid implementation for procedure at path: "${path.join('.')}". ` +
+            `Ensure the procedure is correctly implemented and matches its contract.`);
+    }
+    return createContractProcedure(maybeProcedure, contract);
+}
+export function getRouter(router, path) {
+    let current = router;
+    for (let i = 0; i < path.length; i++) {
+        const segment = path[i];
+        if (!isNonPrimitive(current)) {
+            return undefined;
+        }
+        if (current instanceof Procedure) {
+            return undefined;
+        }
+        if (!(current instanceof Lazy)) {
+            current = getOwn(current, segment);
+            continue;
+        }
+        const lazied = current;
+        const rest = path.slice(i);
+        return new Lazy({
+            ...lazied['~orpc'],
+            async loader() {
+                const unwrapped = await unlazy(lazied);
+                const next = getRouter(unwrapped.default, rest);
+                return await unlazy(next);
+            },
+        });
+    }
+    if (!isNonPrimitive(current)) {
+        return undefined;
+    }
+    return current;
+}
+export function walkProcedureContractsSync(router, callback, path = []) {
+    const lazyResults = [];
+    walkProcedureContractsSyncInternal(router, callback, path.slice(), lazyResults);
+    return lazyResults;
+}
+function walkProcedureContractsSyncInternal(router, callback, path, lazyResults) {
+    const hiddenContract = getHiddenRouterContract(router);
+    if (hiddenContract !== undefined) {
+        router = hiddenContract;
+    }
+    if (router instanceof ProcedureContract) {
+        callback(router, path.slice());
+        return;
+    }
+    if (!isNonPrimitive(router)) {
+        return;
+    }
+    for (const [key, value] of Object.entries(router)) {
+        path.push(key);
+        if (value instanceof Lazy) {
+            lazyResults.push({ router: value, path: path.slice() });
+        }
+        else {
+            walkProcedureContractsSyncInternal(value, callback, path, lazyResults);
+        }
+        path.pop();
+    }
+}
+export async function walkProcedureContractsAsync(router, callback, path = []) {
+    const hiddenContract = getHiddenRouterContract(router);
+    if (hiddenContract !== undefined) {
+        router = hiddenContract;
+    }
+    if (router instanceof ProcedureContract) {
+        await callback(router, path);
+        return;
+    }
+    if (!isNonPrimitive(router)) {
+        return;
+    }
+    for (const [key, value] of Object.entries(router)) {
+        if (value instanceof Lazy) {
+            const { default: router } = await unlazy(value);
+            await walkProcedureContractsAsync(router, callback, [...path, key]);
+        }
+        else {
+            await walkProcedureContractsAsync(value, callback, [...path, key]);
+        }
+    }
+}
+/**
+ * Fully resolves all lazy routers inside a router, returning a plain router.
+ * Useful for making a router with lazy parts contract-compatible.
+ *
+ * @see {@link https://orpc.dev/docs/contract/router#router-to-contract | Router Contract - Router to Contract}
+ */
+export async function unlazyRouter(router) {
+    if (router instanceof Procedure) {
+        return router;
+    }
+    if (!isNonPrimitive(router)) {
+        return router;
+    }
+    const unlazied = {};
+    for (const key of Object.keys(router)) {
+        const item = router[key];
+        const { default: unlaziedRouter } = await unlazy(item);
+        setOwn(unlazied, key, await unlazyRouter(unlaziedRouter));
+    }
+    return unlazied;
+}

package/dist/{shared/server.Dz7j9BEh.d.ts → router.d.ts}

@@ -1,14 +1,15 @@
-import { RouterContract, ProcedureContract, ORPCErrorFromErrorMap, ThrowableError, InferSchemaInput, InferSchemaOutput } from '@orpc/contract';
-import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.DFPxP2v3.js';
-
-type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any> | {
+import type { InferSchemaInput, InferSchemaOutput, ORPCErrorFromErrorMap, ProcedureContract, RouterContract, ThrowableError } from '@orpc/contract';
+import type { Context, MergedContext } from './context.ts';
+import type { Lazyable } from './lazy.ts';
+import type { Procedure } from './procedure.ts';
+export type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any> | {
     [k: string]: Lazyable<Router<TInitialContext>>;
 };
-type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap> : {
+export type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap> : {
     [K in keyof T]: T[K] extends RouterContract ? Lazyable<ContractedRouter<T[K], TInitialContext>> : never;
 };
-type AnyRouter = Router<any>;
-type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $> ? $ : never;
+export type AnyRouter = Router<any>;
+export type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $> ? $ : never;
 /**
  * Infer all initial context of the router.
  *
@@ -17,7 +18,7 @@ type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $>
  *
  * @see {@link https://orpc.dev/docs/router#infer-router-initial-contexts | Router - Infer Router Initial Contexts}
  */
-type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any> ? UInitialContext : {
+export 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;
 };
 /**
@@ -28,7 +29,7 @@ type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer
  *
  * @see {@link https://orpc.dev/docs/router#infer-router-final-contexts | Router - Infer Router Final Contexts}
  */
-type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
+export type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterFinalContexts<U> : never;
 };
 /**
@@ -39,7 +40,7 @@ type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer U
  *
  * @see {@link https://orpc.dev/docs/router#infer-router-inputs | Router - Infer Router Inputs}
  */
-type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any> ? InferSchemaInput<UInputSchema> : {
+export type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any> ? InferSchemaInput<UInputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
 };
 /**
@@ -50,7 +51,7 @@ type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infe
  *
  * @see {@link https://orpc.dev/docs/router#infer-router-outputs | Router - Infer Router Outputs}
  */
-type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any> ? InferSchemaOutput<UOutputSchema> : {
+export type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any> ? InferSchemaOutput<UOutputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 /**
@@ -58,7 +59,7 @@ type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any
  *
  * @see {@link https://orpc.dev/docs/router#infer-router-error | Router - Infer Router Error}
  */
-type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
+export type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterError<U> : never;
 }[keyof T];
 /**
@@ -66,8 +67,6 @@ type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any,
  *
  * @see {@link https://orpc.dev/docs/router#infer-router-errors | Router - Infer Router Errors}
  */
-type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
+export type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterErrors<U> : never;
 };
-
-export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterFinalContexts as a, InferRouterError as b, InferRouterErrors as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };

package/dist/router.js

@@ -0,0 +1 @@
+export {};