@orpc/server 0.0.0-next.c59d67c → 0.0.0-next.caefe3a

package/dist/src/router.d.ts

@@ -1,20 +1,29 @@
-import type { ContractProcedure, ContractRouter, SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { Context } from './types';
-import { type DecoratedProcedure, type Procedure } from './procedure';
-export interface Router<TContext extends Context> {
-    [k: string]: Procedure<TContext, any, any, any, any> | Router<TContext>;
-}
-export type HandledRouter<TRouter extends Router<any>> = {
-    [K in keyof TRouter]: TRouter[K] extends Procedure<infer UContext, infer UExtraContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? DecoratedProcedure<UContext, UExtraContext, UInputSchema, UOutputSchema, UFuncOutput> : TRouter[K] extends Router<any> ? HandledRouter<TRouter[K]> : never;
-};
-export type RouterWithContract<TContext extends Context, TContract extends ContractRouter> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any> : TContract[K] extends ContractRouter ? RouterWithContract<TContext, TContract[K]> : never;
+import type { AnyContractRouter, ContractProcedure, ErrorMap, HTTPPath, MergedErrorMap, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { Context } from './context';
+import type { Lazy, Lazyable } from './lazy';
+import type { AnyMiddleware } from './middleware';
+import type { AnyProcedure } from './procedure';
+import { Procedure } from './procedure';
+import { type AccessibleLazyRouter } from './router-accessible-lazy';
+export type Router<TInitialContext extends Context, TContract extends AnyContractRouter> = Lazyable<TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, any, UErrorMap, UMeta> : {
+    [K in keyof TContract]: TContract[K] extends AnyContractRouter ? Router<TInitialContext, TContract[K]> : never;
+}>;
+export type AnyRouter = Router<any, any>;
+export type InferRouterInputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterInputs<U> : T extends Procedure<any, any, infer UInputSchema, any, any, any, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterInputs<T[K]> : never;
 };
-export declare function toContractRouter(router: ContractRouter | Router<any>): ContractRouter;
-export type InferRouterInputs<T extends Router<any>> = {
-    [K in keyof T]: T[K] extends Procedure<any, any, infer UInputSchema, any, any> ? SchemaInput<UInputSchema> : T[K] extends Router<any> ? InferRouterInputs<T[K]> : never;
+export type InferRouterOutputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterOutputs<U> : T extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput, any, any> ? SchemaOutput<UOutputSchema, UFuncOutput> : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterOutputs<T[K]> : never;
 };
-export type InferRouterOutputs<T extends Router<any>> = {
-    [K in keyof T]: T[K] extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput> ? SchemaOutput<UOutputSchema, UFuncOutput> : T[K] extends Router<any> ? InferRouterOutputs<T[K]> : never;
+export type AdaptedRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap> = TRouter extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<AdaptedRouter<U, TInitialContext, TErrorMap>> : TRouter extends Procedure<any, infer UCurrentContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, UCurrentContext, UInputSchema, UOutputSchema, UFuncOutput, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+    [K in keyof TRouter]: TRouter[K] extends AnyRouter ? AdaptedRouter<TRouter[K], TInitialContext, TErrorMap> : never;
 };
+export interface AdaptRouterOptions<TErrorMap extends ErrorMap> {
+    middlewares: AnyMiddleware[];
+    tags?: readonly string[];
+    prefix?: HTTPPath;
+    errorMap: TErrorMap;
+}
+export declare function adaptRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap>(router: TRouter, options: AdaptRouterOptions<TErrorMap>): AdaptedRouter<TRouter, TInitialContext, TErrorMap>;
+export declare function getRouterChild<T extends AnyRouter | Lazy<undefined>>(router: T, ...path: string[]): T extends Lazy<any> ? Lazy<AnyProcedure> | Lazy<Record<string, AnyRouter>> | Lazy<undefined> : AnyRouter | Lazy<undefined> | undefined;
 //# sourceMappingURL=router.d.ts.map

package/dist/src/utils.d.ts

@@ -1,3 +1,24 @@
-import type { Context, MergeContext } from './types';
-export declare function mergeContext<A extends Context, B extends Context>(a: A, b: B): MergeContext<A, B>;
+import type { AnyContractProcedure, AnyContractRouter, HTTPPath } from '@orpc/contract';
+import type { Lazy } from './lazy';
+import type { AnyProcedure } from './procedure';
+import type { AnyRouter } from './router';
+export interface EachContractProcedureOptions {
+    router: AnyRouter | AnyContractRouter;
+    path: string[];
+}
+export interface EachContractProcedureCallbackOptions {
+    contract: AnyContractProcedure;
+    path: string[];
+}
+export interface EachContractProcedureLaziedOptions {
+    lazied: Lazy<AnyProcedure> | Lazy<Record<string, AnyRouter> | AnyProcedure>;
+    path: string[];
+}
+export declare function eachContractProcedure(options: EachContractProcedureOptions, callback: (options: EachContractProcedureCallbackOptions) => void, laziedOptions?: EachContractProcedureLaziedOptions[]): EachContractProcedureLaziedOptions[];
+export declare function eachAllContractProcedure(options: EachContractProcedureOptions, callback: (options: EachContractProcedureCallbackOptions) => void): Promise<void>;
+export declare function convertPathToHttpPath(path: string[]): HTTPPath;
+/**
+ * Create a new procedure that ensure the contract is applied to the procedure.
+ */
+export declare function createContractedProcedure(contract: AnyContractProcedure, procedure: AnyProcedure): AnyProcedure;
 //# sourceMappingURL=utils.d.ts.map

package/dist/standard.js

@@ -0,0 +1,17 @@
+import {
+  RPCCodec,
+  RPCMatcher,
+  RPCSerializer,
+  StandardHandler,
+  serializeRPCJson
+} from "./chunk-PZ44ZPVC.js";
+import "./chunk-OEPDHGQ4.js";
+import "./chunk-OWMUECGT.js";
+export {
+  RPCCodec,
+  RPCMatcher,
+  RPCSerializer,
+  StandardHandler,
+  serializeRPCJson
+};
+//# sourceMappingURL=standard.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.c59d67c",
+  "version": "0.0.0-next.caefe3a",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,11 +19,36 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./plugins": {
+      "types": "./dist/src/plugins/index.d.ts",
+      "import": "./dist/plugins.js",
+      "default": "./dist/plugins.js"
+    },
+    "./standard": {
+      "types": "./dist/src/adapters/standard/index.d.ts",
+      "import": "./dist/standard.js",
+      "default": "./dist/standard.js"
+    },
     "./fetch": {
-      "types": "./dist/src/fetch/index.d.ts",
+      "types": "./dist/src/adapters/fetch/index.d.ts",
       "import": "./dist/fetch.js",
       "default": "./dist/fetch.js"
     },
+    "./hono": {
+      "types": "./dist/src/adapters/hono/index.d.ts",
+      "import": "./dist/hono.js",
+      "default": "./dist/hono.js"
+    },
+    "./next": {
+      "types": "./dist/src/adapters/next/index.d.ts",
+      "import": "./dist/next.js",
+      "default": "./dist/next.js"
+    },
+    "./node": {
+      "types": "./dist/src/adapters/node/index.d.ts",
+      "import": "./dist/node.js",
+      "default": "./dist/node.js"
+    },
     "./🔒/*": {
       "types": "./dist/src/*.d.ts"
     }
@@ -34,19 +59,19 @@
     "dist"
   ],
   "peerDependencies": {
-    "zod": ">=3.23.0",
-    "@orpc/zod": "0.0.0-next.c59d67c"
+    "hono": ">=4.6.0",
+    "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/contract": "0.0.0-next.c59d67c",
-    "@orpc/shared": "0.0.0-next.c59d67c",
-    "@orpc/transformer": "0.0.0-next.c59d67c"
+    "content-disposition": "^0.5.4",
+    "@orpc/shared": "0.0.0-next.caefe3a",
+    "@orpc/contract": "0.0.0-next.caefe3a"
   },
   "devDependencies": {
-    "@orpc/openapi": "0.0.0-next.c59d67c"
+    "light-my-request": "^6.5.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-TDFYNRZV.js

@@ -1,190 +0,0 @@
-// src/utils.ts
-function mergeContext(a, b) {
-  if (!a)
-    return b;
-  if (!b)
-    return a;
-  return {
-    ...a,
-    ...b
-  };
-}
-
-// src/middleware.ts
-var decoratedMiddlewareSymbol = Symbol("\u{1F512}decoratedMiddleware");
-function decorateMiddleware(middleware) {
-  if (Reflect.get(middleware, decoratedMiddlewareSymbol)) {
-    return middleware;
-  }
-  const concat = (concatMiddleware, mapInput2) => {
-    const concatMiddleware_ = mapInput2 ? decorateMiddleware(concatMiddleware).mapInput(mapInput2) : concatMiddleware;
-    return decorateMiddleware(async (input, context, meta, ...rest) => {
-      const input_ = input;
-      const context_ = context;
-      const meta_ = meta;
-      const next = async (options) => {
-        return concatMiddleware_(input_, mergeContext(context_, options.context), meta_, ...rest);
-      };
-      const m1 = await middleware(input_, context_, {
-        ...meta_,
-        next
-      }, ...rest);
-      return m1;
-    });
-  };
-  const mapInput = (map) => {
-    return decorateMiddleware(
-      (input, ...rest) => middleware(map(input), ...rest)
-    );
-  };
-  return Object.assign(middleware, {
-    [decoratedMiddlewareSymbol]: true,
-    concat,
-    mapInput
-  });
-}
-
-// src/procedure-caller.ts
-import { value } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-import { OpenAPIDeserializer } from "@orpc/transformer";
-function createProcedureCaller(options) {
-  const path = options.path ?? [];
-  const procedure = options.procedure;
-  const caller = async (input) => {
-    const input_ = (() => {
-      if (!(input instanceof FormData)) {
-        return input;
-      }
-      const transformer = new OpenAPIDeserializer({
-        schema: procedure.zz$p.contract.zz$cp.InputSchema
-      });
-      return transformer.deserializeAsFormData(input);
-    })();
-    const validInput = (() => {
-      const schema = procedure.zz$p.contract.zz$cp.InputSchema;
-      if (!schema) {
-        return input_;
-      }
-      try {
-        return schema.parse(input_);
-      } catch (e) {
-        throw new ORPCError({
-          message: "Validation input failed",
-          code: "BAD_REQUEST",
-          cause: e
-        });
-      }
-    })();
-    const middlewares = procedure.zz$p.middlewares ?? [];
-    let currentMidIndex = 0;
-    let currentContext = await value(options.context);
-    const next = async (nextOptions) => {
-      const mid = middlewares[currentMidIndex];
-      currentMidIndex += 1;
-      currentContext = mergeContext(currentContext, nextOptions.context);
-      if (mid) {
-        return await mid(validInput, currentContext, {
-          path,
-          procedure,
-          next,
-          output: (output2) => ({ output: output2, context: void 0 })
-        });
-      } else {
-        return {
-          output: await await procedure.zz$p.func(validInput, currentContext, {
-            path,
-            procedure
-          }),
-          context: currentContext
-        };
-      }
-    };
-    const output = (await next({})).output;
-    const validOutput = await (async () => {
-      const schema = procedure.zz$p.contract.zz$cp.OutputSchema;
-      if (!schema) {
-        return output;
-      }
-      const result = await schema.safeParseAsync(output);
-      if (result.error) {
-        throw new ORPCError({
-          message: "Validation output failed",
-          code: "INTERNAL_SERVER_ERROR",
-          cause: result.error
-        });
-      }
-      return result.data;
-    })();
-    return validOutput;
-  };
-  return caller;
-}
-
-// src/procedure.ts
-import {
-  DecoratedContractProcedure,
-  isContractProcedure
-} from "@orpc/contract";
-var Procedure = class {
-  constructor(zz$p) {
-    this.zz$p = zz$p;
-  }
-};
-var DECORATED_PROCEDURE_SYMBOL = Symbol("DECORATED_PROCEDURE");
-function decorateProcedure(procedure) {
-  if (DECORATED_PROCEDURE_SYMBOL in procedure) {
-    return procedure;
-  }
-  return Object.assign(createProcedureCaller({
-    procedure,
-    context: void 0
-  }), {
-    [DECORATED_PROCEDURE_SYMBOL]: true,
-    zz$p: procedure.zz$p,
-    prefix(prefix) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).prefix(prefix)
-        }
-      });
-    },
-    route(opts) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).route(opts)
-        }
-      });
-    },
-    use(middleware, mapInput) {
-      const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          middlewares: [middleware_, ...procedure.zz$p.middlewares ?? []]
-        }
-      });
-    }
-  });
-}
-function isProcedure(item) {
-  if (item instanceof Procedure)
-    return true;
-  return (typeof item === "object" || typeof item === "function") && item !== null && "zz$p" in item && typeof item.zz$p === "object" && item.zz$p !== null && "contract" in item.zz$p && isContractProcedure(item.zz$p.contract) && "func" in item.zz$p && typeof item.zz$p.func === "function";
-}
-
-export {
-  mergeContext,
-  decorateMiddleware,
-  createProcedureCaller,
-  Procedure,
-  decorateProcedure,
-  isProcedure
-};
-//# sourceMappingURL=chunk-TDFYNRZV.js.map

package/dist/src/fetch/handle.d.ts

@@ -1,7 +0,0 @@
-import type { Router } from '../router';
-import type { FetchHandler, FetchHandlerOptions } from './types';
-export type HandleFetchRequestOptions<TRouter extends Router<any>> = FetchHandlerOptions<TRouter> & {
-    handlers: readonly [FetchHandler, ...FetchHandler[]];
-};
-export declare function handleFetchRequest<TRouter extends Router<any>>(options: HandleFetchRequestOptions<TRouter>): Promise<Response>;
-//# sourceMappingURL=handle.d.ts.map

package/dist/src/fetch/handler.d.ts

@@ -1,3 +0,0 @@
-import type { FetchHandler } from './types';
-export declare function createORPCHandler(): FetchHandler;
-//# sourceMappingURL=handler.d.ts.map

package/dist/src/fetch/index.d.ts

@@ -1,4 +0,0 @@
-export * from './handle';
-export * from './handler';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/fetch/types.d.ts

@@ -1,35 +0,0 @@
-import type { PartialOnUndefinedDeep, Promisable, Value } from '@orpc/shared';
-import type { Router } from '../router';
-export interface FetchHandlerHooks {
-    next: () => Promise<Response>;
-    response: (response: Response) => Response;
-}
-export type FetchHandlerOptions<TRouter extends Router<any>> = {
-    /**
-     * The `router` used for handling the request and routing,
-     *
-     */
-    router: TRouter;
-    /**
-     * The request need to be handled.
-     */
-    request: Request;
-    /**
-     * Remove the prefix from the request path.
-     *
-     * @example /orpc
-     * @example /api
-     */
-    prefix?: string;
-    /**
-     * Hooks for executing logics on lifecycle events.
-     */
-    hooks?: (context: TRouter extends Router<infer UContext> ? UContext : never, hooks: FetchHandlerHooks) => Promisable<Response>;
-} & PartialOnUndefinedDeep<{
-    /**
-     * The context used to handle the request.
-     */
-    context: Value<TRouter extends Router<infer UContext> ? UContext : never>;
-}>;
-export type FetchHandler = <TRouter extends Router<any>>(options: FetchHandlerOptions<TRouter>) => Promise<Response | undefined>;
-//# sourceMappingURL=types.d.ts.map

package/dist/src/procedure-builder.d.ts

@@ -1,31 +0,0 @@
-import type { MapInputMiddleware, Middleware } from './middleware';
-import type { Context, MergeContext } from './types';
-import { type ContractProcedure, type RouteOptions, type Schema, type SchemaInput, type SchemaOutput } from '@orpc/contract';
-import { type DecoratedProcedure, type ProcedureFunc } from './procedure';
-import { ProcedureImplementer } from './procedure-implementer';
-export declare class ProcedureBuilder<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema> {
-    zz$pb: {
-        contract: ContractProcedure<TInputSchema, TOutputSchema>;
-        middlewares?: Middleware<any, any, any, any>[];
-    };
-    constructor(zz$pb: {
-        contract: ContractProcedure<TInputSchema, TOutputSchema>;
-        middlewares?: Middleware<any, any, any, any>[];
-    });
-    /**
-     * Self chainable
-     */
-    route(opts: RouteOptions): ProcedureBuilder<TContext, TExtraContext, TInputSchema, TOutputSchema>;
-    input<USchema extends Schema = undefined>(schema: USchema, example?: SchemaInput<USchema>): ProcedureBuilder<TContext, TExtraContext, USchema, TOutputSchema>;
-    output<USchema extends Schema = undefined>(schema: USchema, example?: SchemaOutput<USchema>): ProcedureBuilder<TContext, TExtraContext, TInputSchema, USchema>;
-    /**
-     * Convert to ProcedureBuilder
-     */
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, SchemaInput<TOutputSchema>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UMappedInput>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
-    /**
-     * Convert to Procedure
-     */
-    func<UFuncOutput extends SchemaOutput<TOutputSchema>>(func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>;
-}
-//# sourceMappingURL=procedure-builder.d.ts.map

package/dist/src/procedure-caller.d.ts

@@ -1,19 +0,0 @@
-import type { SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { Procedure } from './procedure';
-import { type Value } from '@orpc/shared';
-export interface CreateProcedureCallerOptions<TProcedure extends Procedure<any, any, any, any, any>> {
-    procedure: TProcedure;
-    /**
-     * The context used when calling the procedure.
-     */
-    context: Value<TProcedure extends Procedure<infer UContext, any, any, any, any> ? UContext : never>;
-    /**
-     * This is helpful for logging and analytics.
-     *
-     * @internal
-     */
-    path?: string[];
-}
-export type ProcedureCaller<TProcedure extends Procedure<any, any, any, any, any>> = TProcedure extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? (...input: [input: SchemaInput<UInputSchema> | FormData] | (undefined extends SchemaInput<UInputSchema> ? [] : never)) => Promise<SchemaOutput<UOutputSchema, UFuncOutput>> : never;
-export declare function createProcedureCaller<TProcedure extends Procedure<any, any, any, any, any>>(options: CreateProcedureCallerOptions<TProcedure>): ProcedureCaller<TProcedure>;
-//# sourceMappingURL=procedure-caller.d.ts.map

package/dist/src/procedure-implementer.d.ts

@@ -1,18 +0,0 @@
-import type { ContractProcedure, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { Context, MergeContext } from './types';
-import { type MapInputMiddleware, type Middleware } from './middleware';
-import { type DecoratedProcedure, type ProcedureFunc } from './procedure';
-export declare class ProcedureImplementer<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema> {
-    zz$pi: {
-        contract: ContractProcedure<TInputSchema, TOutputSchema>;
-        middlewares?: Middleware<any, any, any, any>[];
-    };
-    constructor(zz$pi: {
-        contract: ContractProcedure<TInputSchema, TOutputSchema>;
-        middlewares?: Middleware<any, any, any, any>[];
-    });
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, SchemaInput<TOutputSchema>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UMappedInput>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
-    func<UFuncOutput extends SchemaOutput<TOutputSchema>>(func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>;
-}
-//# sourceMappingURL=procedure-implementer.d.ts.map

package/dist/src/router-builder.d.ts

@@ -1,22 +0,0 @@
-import type { HandledRouter, Router } from './router';
-import type { Context, MergeContext } from './types';
-import { type HTTPPath } from '@orpc/contract';
-import { type MapInputMiddleware, type Middleware } from './middleware';
-export declare class RouterBuilder<TContext extends Context, TExtraContext extends Context> {
-    zz$rb: {
-        prefix?: HTTPPath;
-        tags?: string[];
-        middlewares?: Middleware<any, any, any, any>[];
-    };
-    constructor(zz$rb: {
-        prefix?: HTTPPath;
-        tags?: string[];
-        middlewares?: Middleware<any, any, any, any>[];
-    });
-    prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext>;
-    tags(...tags: string[]): RouterBuilder<TContext, TExtraContext>;
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, unknown, unknown>): RouterBuilder<TContext, MergeContext<TExtraContext, UExtraContext>>;
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, unknown>, mapInput: MapInputMiddleware<unknown, UMappedInput>): RouterBuilder<TContext, MergeContext<TExtraContext, UExtraContext>>;
-    router<URouter extends Router<TContext>>(router: URouter): HandledRouter<URouter>;
-}
-//# sourceMappingURL=router-builder.d.ts.map

package/dist/src/router-caller.d.ts

@@ -1,22 +0,0 @@
-import type { Value } from '@orpc/shared';
-import type { Router } from './router';
-import { type Procedure } from './procedure';
-import { type ProcedureCaller } from './procedure-caller';
-export interface CreateRouterCallerOptions<TRouter extends Router<any>> {
-    router: TRouter;
-    /**
-     * The context used when calling the procedure.
-     */
-    context: Value<TRouter extends Router<infer UContext> ? UContext : never>;
-    /**
-     * This is helpful for logging and analytics.
-     *
-     * @internal
-     */
-    basePath?: string[];
-}
-export type RouterCaller<TRouter extends Router<any>> = {
-    [K in keyof TRouter]: TRouter[K] extends Procedure<any, any, any, any, any> ? ProcedureCaller<TRouter[K]> : TRouter[K] extends Router<any> ? RouterCaller<TRouter[K]> : never;
-};
-export declare function createRouterCaller<TRouter extends Router<any>>(options: CreateRouterCallerOptions<TRouter>): RouterCaller<TRouter>;
-//# sourceMappingURL=router-caller.d.ts.map

package/dist/src/router-implementer.d.ts

@@ -1,20 +0,0 @@
-import type { Middleware } from './middleware';
-import type { RouterWithContract } from './router';
-import type { Context } from './types';
-import { type ContractProcedure, type ContractRouter } from '@orpc/contract';
-import { ProcedureImplementer } from './procedure-implementer';
-export declare class RouterImplementer<TContext extends Context, TContract extends ContractRouter> {
-    zz$ri: {
-        contract: TContract;
-    };
-    constructor(zz$ri: {
-        contract: TContract;
-    });
-    router(router: RouterWithContract<TContext, TContract>): RouterWithContract<TContext, TContract>;
-}
-export type ChainedRouterImplementer<TContext extends Context, TContract extends ContractRouter, TExtraContext extends Context> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema> : TContract[K] extends ContractRouter ? ChainedRouterImplementer<TContext, TContract[K], TExtraContext> : never;
-} & RouterImplementer<TContext, TContract>;
-export declare function chainRouterImplementer<TContext extends Context, TContract extends ContractRouter, TExtraContext extends Context>(contract: TContract, middlewares?: Middleware<any, any, any, any>[]): ChainedRouterImplementer<TContext, TContract, TExtraContext>;
-export declare function assertRouterImplementation(contract: ContractRouter, router: RouterWithContract<any, any>, path?: string[]): void;
-//# sourceMappingURL=router-implementer.d.ts.map

package/dist/src/types.d.ts

@@ -1,8 +0,0 @@
-import type { WELL_DEFINED_PROCEDURE } from './procedure';
-export type Context = Record<string, unknown> | undefined;
-export type MergeContext<TA extends Context, TB extends Context> = TA extends undefined ? TB : TB extends undefined ? TA : TA & TB;
-export interface Meta {
-    path: string[];
-    procedure: WELL_DEFINED_PROCEDURE;
-}
-//# sourceMappingURL=types.d.ts.map