@orpc/server 0.0.0-next.8f101b9 → 0.0.0-next.8f622a0

package/dist/{index.js → index.mjs}

@@ -1,31 +1,15 @@
-import {
-  LAZY_LOADER_SYMBOL,
-  Procedure,
-  adaptRouter,
-  addMiddleware,
-  createAccessibleLazyRouter,
-  createLazyProcedureFormAnyLazy,
-  createProcedureClient,
-  deepSetLazyRouterPrefix,
-  flatLazy,
-  getLazyRouterPrefix,
-  getRouterChild,
-  getRouterContract,
-  isLazy,
-  isProcedure,
-  lazy,
-  middlewareOutputFn,
-  setRouterContract,
-  unlazy
-} from "./chunk-KK4SDLC7.js";
+import { mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, mergeTags, isContractProcedure, getContractRouter } from '@orpc/contract';
+export { ValidationError, eventIterator, type } from '@orpc/contract';
+import { P as Procedure, d as addMiddleware, c as createProcedureClient, e as enhanceRouter, l as lazy, s as setHiddenRouterContract, i as isProcedure, f as isLazy, h as createAssertedLazyProcedure, g as getRouter } from './shared/server.BtxZnWJ9.mjs';
+export { L as LAZY_SYMBOL, q as call, w as createAccessibleLazyRouter, b as createContractedProcedure, j as createORPCErrorConstructorMap, r as getHiddenRouterContract, k as getLazyMeta, o as isStartWithMiddlewares, m as mergeCurrentContext, p as mergeMiddlewares, n as middlewareOutputFn, x as resolveContractProcedures, a as toHttpPath, t as traverseContractProcedures, u as unlazy, y as unlazyRouter, v as validateORPCError } from './shared/server.BtxZnWJ9.mjs';
+export { ORPCError, isDefinedError, safe } from '@orpc/client';
+export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+export { getEventMeta, withEventMeta } from '@orpc/standard-server';
 
-// src/builder.ts
-import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
-
-// src/config.ts
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
   initialInputValidationIndex: 0,
-  initialOutputValidationIndex: 0
+  initialOutputValidationIndex: 0,
+  dedupeLeadingMiddlewares: true
 };
 function fallbackConfig(key, value) {
   if (value === void 0) {
@@ -34,9 +18,8 @@ function fallbackConfig(key, value) {
   return value;
 }
 
-// src/middleware-decorated.ts
 function decorateMiddleware(middleware) {
-  const decorated = middleware;
+  const decorated = (...args) => middleware(...args);
   decorated.mapInput = (mapInput) => {
     const mapped = decorateMiddleware(
       (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
@@ -46,10 +29,14 @@ function decorateMiddleware(middleware) {
   decorated.concat = (concatMiddleware, mapInput) => {
     const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
     const concatted = decorateMiddleware((options, input, output, ...rest) => {
-      const next = async (...[nextOptions]) => {
-        return mapped({ ...options, context: { ...nextOptions?.context, ...options.context } }, input, output, ...rest);
-      };
-      const merged = middleware({ ...options, next }, input, output, ...rest);
+      const merged = middleware({
+        ...options,
+        next: (...[nextOptions1]) => mapped({
+          ...options,
+          context: { ...options.context, ...nextOptions1?.context },
+          next: (...[nextOptions2]) => options.next({ context: { ...nextOptions1?.context, ...nextOptions2?.context } })
+        }, input, output, ...rest)
+      }, input, output, ...rest);
       return merged;
     });
     return concatted;
@@ -57,30 +44,28 @@ function decorateMiddleware(middleware) {
   return decorated;
 }
 
-// src/procedure-decorated.ts
-import { mergeErrorMap, mergeMeta, mergeRoute } from "@orpc/contract";
-var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
+class DecoratedProcedure extends Procedure {
   errors(errors) {
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
   meta(meta) {
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
   route(route) {
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       route: mergeRoute(this["~orpc"].route, route)
     });
   }
   use(middleware, mapInput) {
     const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
@@ -89,9 +74,13 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
    * Make this procedure callable (works like a function while still being a procedure).
    */
   callable(...rest) {
-    return Object.assign(createProcedureClient(this, ...rest), {
-      "~type": "Procedure",
-      "~orpc": this["~orpc"]
+    return new Proxy(createProcedureClient(this, ...rest), {
+      get: (target, key) => {
+        return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
+      },
+      has: (target, key) => {
+        return Reflect.has(this, key) || Reflect.has(target, key);
+      }
     });
   }
   /**
@@ -100,10 +89,9 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
   actionable(...rest) {
     return this.callable(...rest);
   }
-};
+}
 
-// src/builder.ts
-var Builder = class _Builder {
+class Builder {
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
@@ -114,9 +102,10 @@ var Builder = class _Builder {
   $config(config) {
     const inputValidationCount = this["~orpc"].inputValidationIndex - fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex);
     const outputValidationCount = this["~orpc"].outputValidationIndex - fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex);
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       config,
+      dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares),
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
       outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config.initialOutputValidationIndex) + outputValidationCount
     });
@@ -125,7 +114,7 @@ var Builder = class _Builder {
    * Reset initial context
    */
   $context() {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       middlewares: [],
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
@@ -136,7 +125,7 @@ var Builder = class _Builder {
    * Reset initial meta
    */
   $meta(initialMeta) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       meta: initialMeta
     });
@@ -145,48 +134,54 @@ var Builder = class _Builder {
    * Reset initial route
    */
   $route(initialRoute) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       route: initialRoute
     });
   }
+  $input(initialInputSchema) {
+    return new Builder({
+      ...this["~orpc"],
+      inputSchema: initialInputSchema
+    });
+  }
   middleware(middleware) {
     return decorateMiddleware(middleware);
   }
   errors(errors) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
-      errorMap: mergeErrorMap2(this["~orpc"].errorMap, errors)
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
   use(middleware, mapInput) {
     const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
   }
   meta(meta) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
-      meta: mergeMeta2(this["~orpc"].meta, meta)
+      meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
   route(route) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
-      route: mergeRoute2(this["~orpc"].route, route)
+      route: mergeRoute(this["~orpc"].route, route)
     });
   }
   input(schema) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       inputSchema: schema,
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + this["~orpc"].middlewares.length
     });
   }
   output(schema) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       outputSchema: schema,
       outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + this["~orpc"].middlewares.length
@@ -199,43 +194,35 @@ var Builder = class _Builder {
     });
   }
   prefix(prefix) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
   tag(...tags) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       tags: mergeTags(this["~orpc"].tags, tags)
     });
   }
   router(router) {
-    return adaptRouter(router, this["~orpc"]);
+    return enhanceRouter(router, this["~orpc"]);
   }
   lazy(loader) {
-    return adaptRouter(flatLazy(lazy(loader)), this["~orpc"]);
+    return enhanceRouter(lazy(loader), this["~orpc"]);
   }
-};
-var os = new Builder({
+}
+const os = new Builder({
   config: {},
   route: {},
   meta: {},
   errorMap: {},
-  inputSchema: void 0,
-  outputSchema: void 0,
   inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
   outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
-  middlewares: []
+  middlewares: [],
+  dedupeLeadingMiddlewares: true
 });
 
-// src/context.ts
-function mergeContext(context, other) {
-  return { ...context, ...other };
-}
-
-// src/implementer.ts
-import { isContractProcedure } from "@orpc/contract";
 function implementerInternal(contract, config, middlewares) {
   if (isContractProcedure(contract)) {
     const impl2 = new Builder({
@@ -243,12 +230,16 @@ function implementerInternal(contract, config, middlewares) {
       config,
       middlewares,
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", config?.initialInputValidationIndex) + middlewares.length,
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config?.initialOutputValidationIndex) + middlewares.length
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config?.initialOutputValidationIndex) + middlewares.length,
+      dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
     });
     return impl2;
   }
   const impl = new Proxy(contract, {
     get: (target, key) => {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
       let method;
       if (key === "middleware") {
         method = (mid) => decorateMiddleware(mid);
@@ -262,23 +253,29 @@ function implementerInternal(contract, config, middlewares) {
         };
       } else if (key === "router") {
         method = (router) => {
-          const adapted = adaptRouter(router, {
+          const adapted = enhanceRouter(router, {
             middlewares,
-            errorMap: {}
+            errorMap: {},
+            prefix: void 0,
+            tags: void 0,
+            dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
           });
-          return setRouterContract(adapted, contract);
+          return setHiddenRouterContract(adapted, contract);
         };
       } else if (key === "lazy") {
         method = (loader) => {
-          const adapted = adaptRouter(flatLazy(lazy(loader)), {
+          const adapted = enhanceRouter(lazy(loader), {
             middlewares,
-            errorMap: {}
+            errorMap: {},
+            prefix: void 0,
+            tags: void 0,
+            dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
           });
-          return setRouterContract(adapted, contract);
+          return setHiddenRouterContract(adapted, contract);
         };
       }
-      const next = Reflect.get(target, key);
-      if (!next || typeof next !== "function" && typeof next !== "object") {
+      const next = getContractRouter(target, [key]);
+      if (!next) {
         return method ?? next;
       }
       const nextImpl = implementerInternal(next, config, middlewares);
@@ -305,44 +302,34 @@ function implement(contract, config = {}) {
         method = (config2) => implement(contract, config2);
       }
       const next = Reflect.get(target, key);
-      if (!next || typeof next !== "function" && typeof next !== "object") {
-        return method ?? next;
+      if (!method || !next || typeof next !== "function" && typeof next !== "object") {
+        return method || next;
       }
-      if (method) {
-        return new Proxy(method, {
-          get(_, key2) {
-            return Reflect.get(next, key2);
-          }
-        });
-      }
-      return next;
+      return new Proxy(method, {
+        get(_, key2) {
+          return Reflect.get(next, key2);
+        }
+      });
     }
   });
   return impl;
 }
 
-// src/procedure-utils.ts
-function call(procedure, input, ...rest) {
-  return createProcedureClient(procedure, ...rest)(input);
-}
-
-// src/router-client.ts
-function createRouterClient(router, ...rest) {
+function createRouterClient(router, ...[options]) {
   if (isProcedure(router)) {
-    const caller = createProcedureClient(router, ...rest);
+    const caller = createProcedureClient(router, options);
     return caller;
   }
-  const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
+  const procedureCaller = isLazy(router) ? createProcedureClient(createAssertedLazyProcedure(router), options) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = getRouterChild(router, key);
+      const next = getRouter(router, [key]);
       if (!next) {
         return Reflect.get(target, key);
       }
-      const [options] = rest;
       return createRouterClient(next, {
         ...options,
         path: [...options?.path ?? [], key]
@@ -352,39 +339,4 @@ function createRouterClient(router, ...rest) {
   return recursive;
 }
 
-// src/index.ts
-import { isDefinedError, ORPCError, safe, type } from "@orpc/contract";
-export {
-  Builder,
-  DecoratedProcedure,
-  LAZY_LOADER_SYMBOL,
-  ORPCError,
-  Procedure,
-  adaptRouter,
-  call,
-  createAccessibleLazyRouter,
-  createLazyProcedureFormAnyLazy,
-  createProcedureClient,
-  createRouterClient,
-  decorateMiddleware,
-  deepSetLazyRouterPrefix,
-  fallbackConfig,
-  flatLazy,
-  getLazyRouterPrefix,
-  getRouterChild,
-  getRouterContract,
-  implement,
-  implementerInternal,
-  isDefinedError,
-  isLazy,
-  isProcedure,
-  lazy,
-  mergeContext,
-  middlewareOutputFn,
-  os,
-  safe,
-  setRouterContract,
-  type,
-  unlazy
-};
-//# sourceMappingURL=index.js.map
+export { Builder, DecoratedProcedure, Procedure, addMiddleware, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getRouter, implement, implementerInternal, isLazy, isProcedure, lazy, os, setHiddenRouterContract };

package/dist/plugins/index.d.mts

@@ -0,0 +1,31 @@
+import { b as StandardHandlerInterceptorOptions, H as HandlerPlugin, a as StandardHandlerOptions } from '../shared/server.CDzXh8DM.mjs';
+export { C as CompositeHandlerPlugin } from '../shared/server.CDzXh8DM.mjs';
+import { Value } from '@orpc/shared';
+import { C as Context } from '../shared/server.BYTulgUc.mjs';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client';
+
+interface CORSOptions<TContext extends Context> {
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: readonly string[];
+}
+declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly options;
+    constructor(options?: CORSOptions<TContext>);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+interface ResponseHeadersPluginContext {
+    resHeaders?: Headers;
+}
+declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.d.ts

@@ -0,0 +1,31 @@
+import { b as StandardHandlerInterceptorOptions, H as HandlerPlugin, a as StandardHandlerOptions } from '../shared/server.CkGvC2T0.js';
+export { C as CompositeHandlerPlugin } from '../shared/server.CkGvC2T0.js';
+import { Value } from '@orpc/shared';
+import { C as Context } from '../shared/server.BYTulgUc.js';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client';
+
+interface CORSOptions<TContext extends Context> {
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: readonly string[];
+}
+declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly options;
+    constructor(options?: CORSOptions<TContext>);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+interface ResponseHeadersPluginContext {
+    resHeaders?: Headers;
+}
+declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.mjs

@@ -0,0 +1,103 @@
+export { C as CompositeHandlerPlugin } from '../shared/server.Dba3Iiyp.mjs';
+import { value } from '@orpc/shared';
+
+class CORSPlugin {
+  options;
+  constructor(options = {}) {
+    const defaults = {
+      origin: (origin) => origin,
+      allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
+    };
+    this.options = {
+      ...defaults,
+      ...options
+    };
+  }
+  init(options) {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.unshift(async (interceptorOptions) => {
+      if (interceptorOptions.request.method === "OPTIONS") {
+        const resHeaders = {};
+        if (this.options.maxAge !== void 0) {
+          resHeaders["access-control-max-age"] = this.options.maxAge.toString();
+        }
+        if (this.options.allowMethods?.length) {
+          resHeaders["access-control-allow-methods"] = this.options.allowMethods.join(",");
+        }
+        const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers["access-control-request-headers"];
+        if (Array.isArray(allowHeaders) && allowHeaders.length) {
+          resHeaders["access-control-allow-headers"] = allowHeaders.join(",");
+        } else if (typeof allowHeaders === "string") {
+          resHeaders["access-control-allow-headers"] = allowHeaders;
+        }
+        return {
+          matched: true,
+          response: {
+            status: 204,
+            headers: resHeaders,
+            body: void 0
+          }
+        };
+      }
+      return interceptorOptions.next();
+    });
+    options.rootInterceptors.unshift(async (interceptorOptions) => {
+      const result = await interceptorOptions.next();
+      if (!result.matched) {
+        return result;
+      }
+      const origin = Array.isArray(interceptorOptions.request.headers.origin) ? interceptorOptions.request.headers.origin.join(",") : interceptorOptions.request.headers.origin || "";
+      const allowedOrigin = await value(this.options.origin, origin, interceptorOptions);
+      const allowedOriginArr = Array.isArray(allowedOrigin) ? allowedOrigin : [allowedOrigin];
+      if (allowedOriginArr.includes("*")) {
+        result.response.headers["access-control-allow-origin"] = "*";
+      } else {
+        if (allowedOriginArr.includes(origin)) {
+          result.response.headers["access-control-allow-origin"] = origin;
+        }
+        result.response.headers.vary = interceptorOptions.request.headers.vary ?? "origin";
+      }
+      const allowedTimingOrigin = await value(this.options.timingOrigin, origin, interceptorOptions);
+      const allowedTimingOriginArr = Array.isArray(allowedTimingOrigin) ? allowedTimingOrigin : [allowedTimingOrigin];
+      if (allowedTimingOriginArr.includes("*")) {
+        result.response.headers["timing-allow-origin"] = "*";
+      } else if (allowedTimingOriginArr.includes(origin)) {
+        result.response.headers["timing-allow-origin"] = origin;
+      }
+      if (this.options.credentials) {
+        result.response.headers["access-control-allow-credentials"] = "true";
+      }
+      if (this.options.exposeHeaders?.length) {
+        result.response.headers["access-control-expose-headers"] = this.options.exposeHeaders.join(",");
+      }
+      return result;
+    });
+  }
+}
+
+class ResponseHeadersPlugin {
+  init(options) {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.push(async (interceptorOptions) => {
+      const headers = new Headers();
+      interceptorOptions.context.resHeaders = headers;
+      const result = await interceptorOptions.next();
+      if (!result.matched) {
+        return result;
+      }
+      const responseHeaders = result.response.headers;
+      for (const [key, value] of headers) {
+        if (Array.isArray(responseHeaders[key])) {
+          responseHeaders[key].push(value);
+        } else if (responseHeaders[key] !== void 0) {
+          responseHeaders[key] = [responseHeaders[key], value];
+        } else {
+          responseHeaders[key] = value;
+        }
+      }
+      return result;
+    });
+  }
+}
+
+export { CORSPlugin, ResponseHeadersPlugin };

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

@@ -0,0 +1,8 @@
+import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
+import { C as Context } from './server.BYTulgUc.mjs';
+import { a as StandardHandlerOptions } from './server.CDzXh8DM.mjs';
+
+interface StandardRPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardRPCJsonSerializerOptions {
+}
+
+export type { StandardRPCHandlerOptions as S };

package/dist/shared/server.BA-onDGB.d.ts

@@ -0,0 +1,8 @@
+import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
+import { C as Context } from './server.BYTulgUc.js';
+import { a as StandardHandlerOptions } from './server.CkGvC2T0.js';
+
+interface StandardRPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardRPCJsonSerializerOptions {
+}
+
+export type { StandardRPCHandlerOptions as S };