@orpc/server 2.0.0-beta.46 → 2.0.0-beta.48

package/dist/index.mjs

@@ -1,463 +1,30 @@
-import { mergeErrorMap, resolveMetaPlugins, getHiddenMetaPlugins, ProcedureContract } from '@orpc/contract';
-export { ValidationError, asyncIteratorObject, defineMeta, error, eventIterator, type } from '@orpc/contract';
-import { toArray, bindMethods, isTypescriptObject, resolveMaybeOptionalOptions } from '@orpc/shared';
-export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, streamToAsyncIteratorObject as streamToEventIterator } from '@orpc/shared';
-import { L as Lazy, P as Procedure, c as createProcedureClient } from './shared/server.BB464y-6.mjs';
-export { u as unlazy } from './shared/server.BB464y-6.mjs';
-import { D as DecoratedProcedure } from './shared/server.sBQSgqK3.mjs';
-import { b as augmentRouter, c as augmentImplementedRouter, d as withHiddenRouterContract, e as createGuardedProcedureLazy, g as getRouter } from './shared/server.CYbIpHbH.mjs';
-export { a as DEFAULT_ERROR_STATUS, D as DEFAULT_SUCCESS_STATUS, f as call, r as resolveContractProcedure, u as unlazyRouter, h as walkProcedureContractsAsync, w as walkProcedureContractsSync } from './shared/server.CYbIpHbH.mjs';
-import { RECURSIVE_CLIENT_UNWRAP_KEYS } from '@orpc/client';
-export { COMMON_ERROR_STATUS_MAP, ORPCError, RPCJsonSerializer, RPCSerializer, isDefinedError, safe, toORPCError } from '@orpc/client';
-export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standard-server/core';
+export * from "./builder.mjs";
+export * from "./builder-variants.mjs";
+export * from "./constants.mjs";
+export * from "./context.mjs";
+export * from "./implementer.mjs";
+export * from "./implementer-procedure.mjs";
+export { SharedRouterImplementer } from "./implementer-router.mjs";
+export * from "./lazy.mjs";
+export * from "./middleware.mjs";
+export * from "./procedure.mjs";
+export * from "./procedure-client.mjs";
+export * from "./procedure-decorated.mjs";
+export { call } from "./procedure-utils.mjs";
+export * from "./router.mjs";
+export * from "./router-client.mjs";
+export { getRouter, resolveContractProcedure, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync } from "./router-utils.mjs";
+export { COMMON_ERROR_STATUS_MAP, isDefinedError, ORPCError, RPCJsonSerializer, RPCSerializer, safe, toORPCError } from "@orpc/client";
+export { asyncIteratorObject, defineMeta, error, eventIterator, type, ValidationError } from "@orpc/contract";
+export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, 
 
-function decorateMiddleware(middleware) {
-  const decorated = ((...args) => middleware(...args));
-  decorated["~orpc"] = middleware["~orpc"];
-  Object.defineProperty(decorated, "name", {
-    value: middleware.name
-  });
-  decorated.adaptInput = (adapt) => {
-    const mapped = decorateMiddleware(
-      (opts, input, ...args) => {
-        return middleware(opts, adapt(input), ...args);
-      }
-    );
-    mapped["~orpc"] = decorated["~orpc"];
-    Object.defineProperty(mapped, "name", {
-      value: decorated.name
-    });
-    return mapped;
-  };
-  decorated.errors = (errors) => {
-    const newMiddleware = decorateMiddleware(decorated);
-    newMiddleware["~orpc"] = {
-      ...decorated["~orpc"],
-      errorMap: mergeErrorMap(decorated["~orpc"]?.errorMap, errors)
-    };
-    return newMiddleware;
-  };
-  decorated.use = (usedMiddleware) => {
-    const merged = decorateMiddleware((opts, ...args) => {
-      return middleware(
-        {
-          ...opts,
-          async next(nextOpts1) {
-            const signal = nextOpts1?.signal ?? opts.signal;
-            const result = await usedMiddleware({
-              ...opts,
-              context: { ...opts.context, ...nextOpts1?.context },
-              signal,
-              next(nextOpts2, ...args2) {
-                return opts.next({
-                  context: {
-                    ...nextOpts1?.context,
-                    ...nextOpts2?.context
-                  },
-                  signal: nextOpts2?.signal ?? signal
-                }, ...args2);
-              }
-            }, ...args);
-            return {
-              ...result,
-              context: {
-                ...nextOpts1?.context,
-                ...result.context
-              }
-            };
-          }
-        },
-        ...args
-      );
-    });
-    merged["~orpc"] = {
-      ...decorated["~orpc"],
-      errorMap: mergeErrorMap(usedMiddleware["~orpc"]?.errorMap, decorated["~orpc"]?.errorMap),
-      metaPlugins: [
-        ...toArray(decorated["~orpc"]?.metaPlugins),
-        ...toArray(usedMiddleware["~orpc"]?.metaPlugins)
-      ]
-    };
-    Object.defineProperty(merged, "name", {
-      value: `${decorated.name} + ${usedMiddleware.name}`
-    });
-    return merged;
-  };
-  return decorated;
-}
+ asyncIteratorToStream as eventIteratorToStream, 
 
-class Builder {
-  "~orpc";
-  /**
-   * Private constructor to prevent direct instantiation.
-   * Use the static `create` method to initialize a new instance with a safe initial definition.
-   */
-  constructor(definition) {
-    this["~orpc"] = definition;
-  }
-  /**
-   * Creates a fresh builder with an empty definition.
-   * Prefer the exported `os` instance over calling this directly.
-   *
-   * @see {@link https://orpc.dev/docs/procedure | Procedure}
-   */
-  static create() {
-    return new Builder({
-      errorMap: {},
-      meta: {},
-      orderedMiddlewares: []
-    });
-  }
-  /**
-   * Declares the initial context type that must be provided when executing
-   * procedures built from this builder.
-   *
-   * @see {@link https://orpc.dev/docs/context#initial-context | Context - Initial Context}
-   */
-  $context() {
-    return this;
-  }
-  /**
-   * Overrides the procedure configuration, such as disabling runtime
-   * input/output validation.
-   *
-   * @see {@link https://orpc.dev/docs/recipes/validation-customization | Validation Customization}
-   */
-  $config(config) {
-    return new Builder({
-      ...this["~orpc"],
-      ...config
-    });
-  }
-  /**
-   * Applies metadata plugins to procedures built from this builder.
-   *
-   * @see {@link https://orpc.dev/docs/metadata | Metadata}
-   */
-  meta(...plugins) {
-    const [meta, metaPlugins] = resolveMetaPlugins(
-      this["~orpc"].meta,
-      this["~orpc"].metaPlugins,
-      plugins
-    );
-    return new Builder({
-      ...this["~orpc"],
-      meta,
-      metaPlugins
-    });
-  }
-  /**
-   * Defines typesafe errors that procedures built from this builder can throw
-   * via the `errors` utility in handlers and middleware.
-   *
-   * @see {@link https://orpc.dev/docs/error-handling#typesafe-errors | Error Handling - Typesafe Errors}
-   */
-  errors(errors) {
-    let builder = new Builder({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
-    });
-    const plugins = getHiddenMetaPlugins(errors);
-    if (plugins) {
-      builder = builder.meta(...plugins);
-    }
-    return builder;
-  }
-  /**
-   * Applies a middleware that runs before the handler of every procedure
-   * built from this builder.
-   *
-   * @see {@link https://orpc.dev/docs/middleware | Middleware}
-   */
-  use(middleware) {
-    let builder = new Builder({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap(middleware["~orpc"]?.errorMap ?? {}, this["~orpc"].errorMap),
-      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
-        middleware,
-        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
-        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
-      }]
-    });
-    if (middleware["~orpc"]?.metaPlugins) {
-      builder = builder.meta(...middleware["~orpc"]?.metaPlugins);
-    }
-    return builder;
-  }
-  /**
-   * Creates a standalone middleware that can be composed and applied to any
-   * compatible builder or procedure with `.use`.
-   *
-   * @see {@link https://orpc.dev/docs/middleware | Middleware}
-   */
-  middleware(middleware) {
-    const allMiddlewares = [
-      ...this["~orpc"].orderedMiddlewares.map(({ middleware: middleware2 }) => middleware2),
-      middleware
-    ];
-    let current = decorateMiddleware(allMiddlewares.shift());
-    for (const mid of allMiddlewares) {
-      current = current.use(mid);
-    }
-    current["~orpc"] = {
-      ...current["~orpc"],
-      errorMap: this["~orpc"].errorMap,
-      metaPlugins: [
-        ...toArray(this["~orpc"].metaPlugins),
-        ...toArray(middleware["~orpc"]?.metaPlugins)
-      ]
-    };
-    return current;
-  }
-  /**
-   * Defines the input schema used to validate and type the procedure input.
-   *
-   * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
-   */
-  input(schema) {
-    let builder = new Builder({
-      ...this["~orpc"],
-      inputSchemas: [...toArray(this["~orpc"].inputSchemas), schema]
-    });
-    const plugins = getHiddenMetaPlugins(schema);
-    if (plugins) {
-      builder = builder.meta(...plugins);
-    }
-    return builder;
-  }
-  /**
-   * Defines the output schema used to validate and type the procedure output.
-   *
-   * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
-   */
-  output(schema) {
-    let builder = new Builder({
-      ...this["~orpc"],
-      outputSchemas: [...toArray(this["~orpc"].outputSchemas), schema]
-    });
-    const plugins = getHiddenMetaPlugins(schema);
-    if (plugins) {
-      builder = builder.meta(...plugins);
-    }
-    return builder;
-  }
-  /**
-   * Defines the function that implements the procedure and completes the
-   * chain, returning a callable procedure.
-   *
-   * @see {@link https://orpc.dev/docs/procedure | Procedure}
-   */
-  handler(handler) {
-    let procedure = new DecoratedProcedure({
-      ...this["~orpc"],
-      handler
-    });
-    const plugins = getHiddenMetaPlugins(handler);
-    if (plugins) {
-      procedure = procedure.meta(...plugins);
-    }
-    return procedure;
-  }
-  /**
-   * Applies the builder's middleware, errors, and metadata to every procedure
-   * in the given router.
-   *
-   * @see {@link https://orpc.dev/docs/router#extending-router | Router - Extending Router}
-   */
-  router(router) {
-    return augmentRouter(router, {
-      ...this["~orpc"],
-      middlewares: this["~orpc"].orderedMiddlewares.map(({ middleware }) => middleware)
-    });
-  }
-  /**
-   * Like `.router`, but loads the router lazily on first access, which helps
-   * reduce startup time for large applications.
-   *
-   * @see {@link https://orpc.dev/docs/router#lazy-router | Router - Lazy Router}
-   */
-  lazy(loader) {
-    return new Lazy({
-      loader: async () => {
-        const { default: router } = await loader();
-        return {
-          default: this.router(router)
-        };
-      },
-      meta: this["~orpc"].meta,
-      metaPlugins: this["~orpc"].metaPlugins
-    });
-  }
-}
-const os = Builder.create();
+ asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, 
 
-class ProcedureImplementer {
-  "~orpc";
-  constructor(definition) {
-    this["~orpc"] = definition;
-  }
-  "use"(middleware) {
-    return new ProcedureImplementer({
-      ...this["~orpc"],
-      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
-        middleware,
-        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
-        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
-      }]
-    });
-  }
-  "handler"(handler) {
-    return new ImplementedProcedure({
-      ...this["~orpc"],
-      handler
-    });
-  }
-}
-class ImplementedProcedure extends Procedure {
-  use(middleware) {
-    return new ImplementedProcedure({
-      ...this["~orpc"],
-      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
-        middleware,
-        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
-        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
-      }]
-    });
-  }
-}
+ streamToAsyncIteratorObject as streamToEventIterator } from "@orpc/shared";
+export { ErrorEvent, 
 
-class SharedRouterImplementer {
-  constructor(contract, config, middlewares) {
-    this.contract = contract;
-    this.config = config;
-    this.middlewares = middlewares;
-  }
-  static create(contract, config, middlewares = []) {
-    return new SharedRouterImplementer(
-      contract,
-      config,
-      middlewares
-    );
-  }
-  use(middleware) {
-    return createRouterImplementerInternal(this.contract, this.config, [...this.middlewares, middleware]);
-  }
-  middleware(middleware) {
-    const allMiddlewares = [
-      ...this.middlewares,
-      middleware
-    ];
-    let current = decorateMiddleware(allMiddlewares.shift());
-    for (const mid of allMiddlewares) {
-      current = current.use(mid);
-    }
-    return current;
-  }
-  router(router) {
-    if (this.middlewares.length) {
-      router = augmentImplementedRouter(router, {
-        ...this.config,
-        middlewares: this.middlewares
-      });
-    }
-    return withHiddenRouterContract(router, this.contract);
-  }
-  lazy(loader) {
-    return new Lazy({
-      loader: async () => {
-        const { default: router } = await loader();
-        return { default: this.router(router) };
-      },
-      meta: {}
-    });
-  }
-}
-function createRouterImplementer(contract, config) {
-  return createRouterImplementerInternal(contract, config, []);
-}
-function createRouterImplementerInternal(contract, config, middlewares) {
-  if (contract instanceof ProcedureContract) {
-    return new ProcedureImplementer({
-      ...config,
-      ...contract["~orpc"],
-      orderedMiddlewares: middlewares.map((middleware) => ({ middleware }))
-    });
-  }
-  const implementer = {};
-  for (const [key, child] of Object.entries(contract)) {
-    implementer[key] = createRouterImplementerInternal(child, config, middlewares);
-  }
-  const shared = bindMethods(SharedRouterImplementer.create(contract, config, middlewares));
-  for (const [key, method] of Object.entries(shared)) {
-    if (key in implementer) {
-      const child = implementer[key];
-      implementer[key] = new Proxy(method, {
-        get(_, p) {
-          return Reflect.get(child, p);
-        }
-      });
-    } else {
-      implementer[key] = method;
-    }
-  }
-  return implementer;
-}
+ getEventMeta, unwrapEvent, 
 
-function implement(contract, config = {}) {
-  const routerImplementer = createRouterImplementer(contract, config);
-  const implementer = new Proxy(routerImplementer, {
-    get(_, p) {
-      let method;
-      if (p === "$context") {
-        method = () => implementer;
-      } else if (p === "$config") {
-        method = (incoming) => implement(contract, { ...config, ...incoming });
-      }
-      const value = Reflect.get(routerImplementer, p);
-      if (method) {
-        if (!isTypescriptObject(value)) {
-          return method;
-        }
-        return new Proxy(method, {
-          get(_2, p2) {
-            return Reflect.get(value, p2);
-          }
-        });
-      }
-      return value;
-    }
-  });
-  return implementer;
-}
-
-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 = /* @__PURE__ */ 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 === void 0) {
-        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;
-}
-
-export { Builder, DecoratedProcedure, ImplementedProcedure, Lazy, Procedure, ProcedureImplementer, SharedRouterImplementer, createProcedureClient, createRouterClient, getRouter, implement, os };
+ withEventMeta } from "@standard-server/core";

package/dist/lazy.d.mts

@@ -0,0 +1,20 @@
+import type { AnyMetaPlugin, Meta } from "@orpc/contract";
+export interface LazyDefinition<T> {
+	meta: Meta;
+	metaPlugins?: AnyMetaPlugin[] | undefined;
+	loader: () => Promise<{
+		default: T;
+	}>;
+}
+export declare class Lazy<T> {
+	"~orpc": LazyDefinition<T>;
+	constructor(def: LazyDefinition<T>);
+	/**
+	* Checks if the given instance satisfies the {@link Lazy} class/interface.
+	*/
+	static [Symbol.hasInstance](instance: unknown): boolean;
+}
+export type Lazyable<T> = T | Lazy<T>;
+export declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
+	default: T extends Lazy<infer U> ? U : T;
+}>;

package/dist/lazy.mjs

@@ -0,0 +1,22 @@
+import { getConstructor, isTypescriptObject } from "@orpc/shared";
+export class Lazy {
+	"~orpc";
+	constructor(def) {
+		this["~orpc"] = def;
+	}
+	
+	static [Symbol.hasInstance](instance) {
+		if (this !== Lazy) {
+			
+			return Function.prototype[Symbol.hasInstance].call(this, instance);
+		}
+		const constructor = getConstructor(instance);
+		if (constructor === Lazy) {
+			return true;
+		}
+		return isTypescriptObject(instance) && isTypescriptObject(instance["~orpc"]) && isTypescriptObject(instance["~orpc"].meta) && (instance["~orpc"].metaPlugins === undefined || Array.isArray(instance["~orpc"].metaPlugins)) && typeof instance["~orpc"].loader === "function";
+	}
+}
+export function unlazy(maybeLazy) {
+	return maybeLazy instanceof Lazy ? maybeLazy["~orpc"].loader() : Promise.resolve({ default: maybeLazy });
+}

package/dist/middleware-decorated.d.mts

@@ -0,0 +1,27 @@
+import type { ErrorMap, MergedErrorMap } from "@orpc/contract";
+import type { IntersectPick } from "@orpc/shared";
+import type { Context, MergedContext, MergedInitialContext } from "./context.mjs";
+import type { Middleware } from "./middleware.mjs";
+export interface DecoratedMiddleware<
+	TInContext extends Context,
+	TOutContext extends Context,
+	TInput,
+	TOutput,
+	TErrorMap extends ErrorMap
+> extends Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap> {
+	adaptInput<T>(adapt: (input: T) => TInput): DecoratedMiddleware<TInContext, TOutContext, T, TOutput, TErrorMap>;
+	errors<T extends ErrorMap>(errors: T): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, MergedErrorMap<TErrorMap, T>>;
+	use<
+		$OutContext extends IntersectPick<MergedContext<TInContext, TOutContext>, $OutContext>,
+		$Input extends TInput,
+		$InContext extends Context = MergedContext<TInContext, TOutContext>,
+		$ErrorMap extends ErrorMap = TErrorMap
+	>(middleware: Middleware<$InContext | MergedContext<TInContext, TOutContext>, $OutContext, $Input, TOutput, $ErrorMap>): DecoratedMiddleware<MergedInitialContext<TInContext, TOutContext, $InContext>, MergedContext<TOutContext, $OutContext>, $Input, TOutput, MergedErrorMap<$ErrorMap, TErrorMap>>;
+}
+export declare function decorateMiddleware<
+	TInContext extends Context,
+	TOutContext extends Context,
+	TInput,
+	TOutput,
+	TErrorMap extends ErrorMap
+>(middleware: Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>;

package/dist/middleware-decorated.mjs

@@ -0,0 +1,65 @@
+import { mergeErrorMap } from "@orpc/contract";
+import { toArray } from "@orpc/shared";
+export function decorateMiddleware(middleware) {
+	const decorated = ((...args) => middleware(...args));
+	decorated["~orpc"] = middleware["~orpc"];
+	Object.defineProperty(decorated, "name", { value: middleware.name });
+	decorated.adaptInput = (adapt) => {
+		const mapped = decorateMiddleware((opts, input, ...args) => {
+			return middleware(opts, adapt(input), ...args);
+		});
+		mapped["~orpc"] = decorated["~orpc"];
+		Object.defineProperty(mapped, "name", { value: decorated.name });
+		return mapped;
+	};
+	decorated.errors = (errors) => {
+		const newMiddleware = decorateMiddleware(decorated);
+		newMiddleware["~orpc"] = {
+			...decorated["~orpc"],
+			errorMap: mergeErrorMap(decorated["~orpc"]?.errorMap, errors)
+		};
+		return newMiddleware;
+	};
+	decorated.use = (usedMiddleware) => {
+		const merged = decorateMiddleware((opts, ...args) => {
+			return middleware({
+				...opts,
+				async next(nextOpts1) {
+					const signal = nextOpts1?.signal ?? opts.signal;
+					const result = await usedMiddleware({
+						...opts,
+						context: {
+							...opts.context,
+							...nextOpts1?.context
+						},
+						signal,
+						next(nextOpts2, ...args) {
+							return opts.next({
+								context: {
+									...nextOpts1?.context,
+									...nextOpts2?.context
+								},
+								signal: nextOpts2?.signal ?? signal
+							}, ...args);
+						}
+					}, ...args);
+					return {
+						...result,
+						context: {
+							...nextOpts1?.context,
+							...result.context
+						}
+					};
+				}
+			}, ...args);
+		});
+		merged["~orpc"] = {
+			...decorated["~orpc"],
+			errorMap: mergeErrorMap(usedMiddleware["~orpc"]?.errorMap, decorated["~orpc"]?.errorMap),
+			metaPlugins: [...toArray(decorated["~orpc"]?.metaPlugins), ...toArray(usedMiddleware["~orpc"]?.metaPlugins)]
+		};
+		Object.defineProperty(merged, "name", { value: `${decorated.name} + ${usedMiddleware.name}` });
+		return merged;
+	};
+	return decorated;
+}

package/dist/middleware.d.mts

@@ -0,0 +1,70 @@
+import type { AnyMetaPlugin, ErrorMap, ORPCErrorConstructorMap } from "@orpc/contract";
+import type { MaybeOptionalOptions, Promisable } from "@orpc/shared";
+import type { Context } from "./context.mjs";
+import type { AnyProcedure } from "./procedure.mjs";
+export type MiddlewareResult<
+	TOutContext extends Context,
+	TOutput
+> = Promisable<{
+	output: TOutput;
+	context: TOutContext;
+}>;
+export type MiddlewareNextOptions<TOutContext extends Context> = (object extends TOutContext ? {
+	context?: TOutContext | undefined;
+} : {
+	context: TOutContext;
+}) & {
+	/** Overrides the signal for the rest of the chain. */
+	signal?: AbortSignal | undefined;
+};
+export interface MiddlewareNext<TOutput> {
+	<T extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<T>>): MiddlewareResult<T, TOutput>;
+}
+export type MiddlewareDoneOptions<
+	TOutContext,
+	TOutput
+> = (object extends TOutContext ? {
+	context?: TOutContext | undefined;
+} : {
+	context: TOutContext;
+}) & {
+	output: TOutput;
+};
+export interface MiddlewareDone<TOutput> {
+	/**
+	* Create a successful result and terminate the middleware chain early.
+	*/
+	<TOutContext extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareDoneOptions<TOutContext, TOutput>>): MiddlewareResult<TOutContext, TOutput>;
+}
+export interface MiddlewareOptions<
+	TInContext extends Context,
+	TOutput,
+	TErrorConstructorMap extends ORPCErrorConstructorMap<any>
+> {
+	context: TInContext;
+	path: string[];
+	procedure: AnyProcedure;
+	signal?: AbortSignal | undefined;
+	lastEventId: string | undefined;
+	/**
+	* Invoke to continue the middleware chain.
+	*/
+	next: MiddlewareNext<TOutput>;
+	errors: TErrorConstructorMap;
+}
+export interface MiddlewareDefinition<TErrorMap extends ErrorMap> {
+	errorMap?: TErrorMap | undefined;
+	metaPlugins?: AnyMetaPlugin[] | undefined;
+}
+export interface Middleware<
+	TInContext extends Context,
+	TOutContext extends Context,
+	TInput,
+	TOutput,
+	TErrorMap extends ErrorMap
+> {
+	/** this property should be optional to support inline middleware */
+	"~orpc"?: MiddlewareDefinition<TErrorMap> | undefined;
+	(opts: MiddlewareOptions<TInContext, TOutput, ORPCErrorConstructorMap<TErrorMap>>, input: TInput, done: MiddlewareDone<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+export type AnyMiddleware = Middleware<any, any, any, any, any>;