@orpc/server 0.0.0-next.ca29a36 → 0.0.0-next.cac5dd3

package/dist/index.js

@@ -1,413 +0,0 @@
-import {
-  LAZY_LOADER_SYMBOL,
-  Procedure,
-  adaptRouter,
-  addMiddleware,
-  convertPathToHttpPath,
-  createAccessibleLazyRouter,
-  createContractedProcedure,
-  createLazyProcedureFormAnyLazy,
-  createProcedureClient,
-  deepSetLazyRouterPrefix,
-  eachAllContractProcedure,
-  eachContractProcedure,
-  flatLazy,
-  getLazyRouterPrefix,
-  getRouterChild,
-  getRouterContract,
-  isLazy,
-  isProcedure,
-  lazy,
-  middlewareOutputFn,
-  setRouterContract,
-  unlazy
-} from "./chunk-MHVECKBC.js";
-
-// src/builder.ts
-import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
-
-// src/config.ts
-var DEFAULT_CONFIG = {
-  initialInputValidationIndex: 0,
-  initialOutputValidationIndex: 0
-};
-function fallbackConfig(key, value) {
-  if (value === void 0) {
-    return DEFAULT_CONFIG[key];
-  }
-  return value;
-}
-
-// src/middleware-decorated.ts
-function decorateMiddleware(middleware) {
-  const decorated = middleware;
-  decorated.mapInput = (mapInput) => {
-    const mapped = decorateMiddleware(
-      (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
-    );
-    return mapped;
-  };
-  decorated.concat = (concatMiddleware, mapInput) => {
-    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
-    const concatted = decorateMiddleware((options, 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;
-  };
-  return decorated;
-}
-
-// src/procedure-decorated.ts
-import { mergeErrorMap, mergeMeta, mergeRoute } from "@orpc/contract";
-var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
-  errors(errors) {
-    return new _DecoratedProcedure({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
-    });
-  }
-  meta(meta) {
-    return new _DecoratedProcedure({
-      ...this["~orpc"],
-      meta: mergeMeta(this["~orpc"].meta, meta)
-    });
-  }
-  route(route) {
-    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({
-      ...this["~orpc"],
-      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
-    });
-  }
-  /**
-   * 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"]
-    });
-  }
-  /**
-   * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
-   */
-  actionable(...rest) {
-    return this.callable(...rest);
-  }
-};
-
-// src/builder.ts
-var Builder = class _Builder {
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  /**
-   * Reset config
-   */
-  $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({
-      ...this["~orpc"],
-      config,
-      inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config.initialOutputValidationIndex) + outputValidationCount
-    });
-  }
-  /**
-   * Reset initial context
-   */
-  $context() {
-    return new _Builder({
-      ...this["~orpc"],
-      middlewares: [],
-      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex)
-    });
-  }
-  /**
-   * Reset initial meta
-   */
-  $meta(initialMeta) {
-    return new _Builder({
-      ...this["~orpc"],
-      meta: initialMeta
-    });
-  }
-  /**
-   * Reset initial route
-   */
-  $route(initialRoute) {
-    return new _Builder({
-      ...this["~orpc"],
-      route: initialRoute
-    });
-  }
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
-  }
-  errors(errors) {
-    return new _Builder({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap2(this["~orpc"].errorMap, errors)
-    });
-  }
-  use(middleware, mapInput) {
-    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _Builder({
-      ...this["~orpc"],
-      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
-    });
-  }
-  meta(meta) {
-    return new _Builder({
-      ...this["~orpc"],
-      meta: mergeMeta2(this["~orpc"].meta, meta)
-    });
-  }
-  route(route) {
-    return new _Builder({
-      ...this["~orpc"],
-      route: mergeRoute2(this["~orpc"].route, route)
-    });
-  }
-  input(schema) {
-    return new _Builder({
-      ...this["~orpc"],
-      inputSchema: schema,
-      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + this["~orpc"].middlewares.length
-    });
-  }
-  output(schema) {
-    return new _Builder({
-      ...this["~orpc"],
-      outputSchema: schema,
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + this["~orpc"].middlewares.length
-    });
-  }
-  handler(handler) {
-    return new DecoratedProcedure({
-      ...this["~orpc"],
-      handler
-    });
-  }
-  prefix(prefix) {
-    return new _Builder({
-      ...this["~orpc"],
-      prefix: mergePrefix(this["~orpc"].prefix, prefix)
-    });
-  }
-  tag(...tags) {
-    return new _Builder({
-      ...this["~orpc"],
-      tags: mergeTags(this["~orpc"].tags, tags)
-    });
-  }
-  router(router) {
-    return adaptRouter(router, this["~orpc"]);
-  }
-  lazy(loader) {
-    return adaptRouter(flatLazy(lazy(loader)), this["~orpc"]);
-  }
-};
-var os = new Builder({
-  config: {},
-  route: {},
-  meta: {},
-  errorMap: {},
-  inputSchema: void 0,
-  outputSchema: void 0,
-  inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
-  outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
-  middlewares: []
-});
-
-// 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({
-      ...contract["~orpc"],
-      config,
-      middlewares,
-      inputValidationIndex: fallbackConfig("initialInputValidationIndex", config?.initialInputValidationIndex) + middlewares.length,
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config?.initialOutputValidationIndex) + middlewares.length
-    });
-    return impl2;
-  }
-  const impl = new Proxy(contract, {
-    get: (target, key) => {
-      let method;
-      if (key === "middleware") {
-        method = (mid) => decorateMiddleware(mid);
-      } else if (key === "use") {
-        method = (mid) => {
-          return implementerInternal(
-            contract,
-            config,
-            addMiddleware(middlewares, mid)
-          );
-        };
-      } else if (key === "router") {
-        method = (router) => {
-          const adapted = adaptRouter(router, {
-            middlewares,
-            errorMap: {}
-          });
-          return setRouterContract(adapted, contract);
-        };
-      } else if (key === "lazy") {
-        method = (loader) => {
-          const adapted = adaptRouter(flatLazy(lazy(loader)), {
-            middlewares,
-            errorMap: {}
-          });
-          return setRouterContract(adapted, contract);
-        };
-      }
-      const next = Reflect.get(target, key);
-      if (!next || typeof next !== "function" && typeof next !== "object") {
-        return method ?? next;
-      }
-      const nextImpl = implementerInternal(next, config, middlewares);
-      if (method) {
-        return new Proxy(method, {
-          get(_, key2) {
-            return Reflect.get(nextImpl, key2);
-          }
-        });
-      }
-      return nextImpl;
-    }
-  });
-  return impl;
-}
-function implement(contract, config = {}) {
-  const implInternal = implementerInternal(contract, config, []);
-  const impl = new Proxy(implInternal, {
-    get: (target, key) => {
-      let method;
-      if (key === "$context") {
-        method = () => impl;
-      } else if (key === "$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) {
-        return new Proxy(method, {
-          get(_, key2) {
-            return Reflect.get(next, key2);
-          }
-        });
-      }
-      return next;
-    }
-  });
-  return impl;
-}
-
-// src/procedure-utils.ts
-function call(procedure, input, ...rest) {
-  return createProcedureClient(procedure, ...rest)(input);
-}
-
-// src/router-client.ts
-function createRouterClient(router, ...rest) {
-  if (isProcedure(router)) {
-    const caller = createProcedureClient(router, ...rest);
-    return caller;
-  }
-  const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
-  const recursive = new Proxy(procedureCaller, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      const next = getRouterChild(router, key);
-      if (!next) {
-        return Reflect.get(target, key);
-      }
-      const [options] = rest;
-      return createRouterClient(next, {
-        ...options,
-        path: [...options?.path ?? [], key]
-      });
-    }
-  });
-  return recursive;
-}
-
-// src/index.ts
-import { isDefinedError, ORPCError, safe } from "@orpc/client";
-import { eventIterator, type, ValidationError } from "@orpc/contract";
-import { onError, onFinish, onStart, onSuccess } from "@orpc/shared";
-import { getEventMeta, withEventMeta } from "@orpc/standard-server";
-export {
-  Builder,
-  DecoratedProcedure,
-  LAZY_LOADER_SYMBOL,
-  ORPCError,
-  Procedure,
-  ValidationError,
-  adaptRouter,
-  call,
-  convertPathToHttpPath,
-  createAccessibleLazyRouter,
-  createContractedProcedure,
-  createLazyProcedureFormAnyLazy,
-  createProcedureClient,
-  createRouterClient,
-  decorateMiddleware,
-  deepSetLazyRouterPrefix,
-  eachAllContractProcedure,
-  eachContractProcedure,
-  eventIterator,
-  fallbackConfig,
-  flatLazy,
-  getEventMeta,
-  getLazyRouterPrefix,
-  getRouterChild,
-  getRouterContract,
-  implement,
-  implementerInternal,
-  isDefinedError,
-  isLazy,
-  isProcedure,
-  lazy,
-  mergeContext,
-  middlewareOutputFn,
-  onError,
-  onFinish,
-  onStart,
-  onSuccess,
-  os,
-  safe,
-  setRouterContract,
-  type,
-  unlazy,
-  withEventMeta
-};
-//# sourceMappingURL=index.js.map

package/dist/next.js

@@ -1,31 +0,0 @@
-import {
-  RPCHandler
-} from "./chunk-MBMXGUNI.js";
-import "./chunk-NTHCS5CK.js";
-import "./chunk-MHVECKBC.js";
-import "./chunk-TXHKQO7N.js";
-
-// src/adapters/next/serve.ts
-import { value } from "@orpc/shared";
-function serve(handler, ...[options]) {
-  const main = async (req) => {
-    const context = await value(options?.context ?? {}, req);
-    const { matched, response } = await handler.handle(req, { ...options, context });
-    if (matched) {
-      return response;
-    }
-    return new Response(`Cannot find a matching procedure for ${req.url}`, { status: 404 });
-  };
-  return {
-    GET: main,
-    POST: main,
-    PUT: main,
-    PATCH: main,
-    DELETE: main
-  };
-}
-export {
-  RPCHandler,
-  serve
-};
-//# sourceMappingURL=next.js.map

package/dist/node.js

@@ -1,31 +0,0 @@
-import {
-  RPCCodec,
-  RPCMatcher,
-  StandardHandler
-} from "./chunk-NTHCS5CK.js";
-import "./chunk-MHVECKBC.js";
-import "./chunk-TXHKQO7N.js";
-
-// src/adapters/node/rpc-handler.ts
-import { sendStandardResponse, toStandardRequest } from "@orpc/standard-server-node";
-var RPCHandler = class {
-  standardHandler;
-  constructor(router, options) {
-    const codec = options?.codec ?? new RPCCodec();
-    const matcher = options?.matcher ?? new RPCMatcher();
-    this.standardHandler = new StandardHandler(router, matcher, codec, options);
-  }
-  async handle(req, res, ...rest) {
-    const standardRequest = toStandardRequest(req, res);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
-    if (!result.matched) {
-      return { matched: false };
-    }
-    await sendStandardResponse(res, result.response);
-    return { matched: true };
-  }
-};
-export {
-  RPCHandler
-};
-//# sourceMappingURL=node.js.map

package/dist/plugins.js

@@ -1,11 +0,0 @@
-import {
-  CORSPlugin,
-  CompositePlugin,
-  ResponseHeadersPlugin
-} from "./chunk-TXHKQO7N.js";
-export {
-  CORSPlugin,
-  CompositePlugin,
-  ResponseHeadersPlugin
-};
-//# sourceMappingURL=plugins.js.map

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

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

package/dist/src/adapters/fetch/rpc-handler.d.ts

@@ -1,11 +0,0 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { Context } from '../../context';
-import type { Router } from '../../router';
-import type { RPCHandlerOptions, StandardHandleOptions } from '../standard';
-import type { FetchHandler, FetchHandleResult } from './types';
-export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
-    private readonly standardHandler;
-    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
-    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<FetchHandleResult>;
-}
-//# sourceMappingURL=rpc-handler.d.ts.map

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

@@ -1,14 +0,0 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { Context } from '../../context';
-import type { StandardHandleOptions } from '../standard';
-export type FetchHandleResult = {
-    matched: true;
-    response: Response;
-} | {
-    matched: false;
-    response: undefined;
-};
-export interface FetchHandler<T extends Context> {
-    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<FetchHandleResult>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/hono/index.d.ts

@@ -1,3 +0,0 @@
-export * from '../fetch';
-export * from './middleware';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/hono/middleware.d.ts

@@ -1,12 +0,0 @@
-import type { MaybeOptionalOptions, Value } from '@orpc/shared';
-import type { Context as HonoContext, MiddlewareHandler } from 'hono';
-import type { Context } from '../../context';
-import type { FetchHandler } from '../fetch';
-import type { StandardHandleOptions } from '../standard';
-export type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<T, [HonoContext]>;
-} : {
-    context: Value<T, [HonoContext]>;
-});
-export declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<CreateMiddlewareOptions<T>>): MiddlewareHandler;
-//# sourceMappingURL=middleware.d.ts.map

package/dist/src/adapters/next/index.d.ts

@@ -1,3 +0,0 @@
-export * from '../fetch';
-export * from './serve';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/next/serve.d.ts

@@ -1,19 +0,0 @@
-import type { MaybeOptionalOptions, Value } from '@orpc/shared';
-import type { NextRequest } from 'next/server';
-import type { Context } from '../../context';
-import type { FetchHandler } from '../fetch';
-import type { StandardHandleOptions } from '../standard';
-export type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<T, [NextRequest]>;
-} : {
-    context: Value<T, [NextRequest]>;
-});
-export interface ServeResult {
-    GET(req: NextRequest): Promise<Response>;
-    POST(req: NextRequest): Promise<Response>;
-    PUT(req: NextRequest): Promise<Response>;
-    PATCH(req: NextRequest): Promise<Response>;
-    DELETE(req: NextRequest): Promise<Response>;
-}
-export declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<ServeOptions<T>>): ServeResult;
-//# sourceMappingURL=serve.d.ts.map

package/dist/src/adapters/node/index.d.ts

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

package/dist/src/adapters/node/rpc-handler.d.ts

@@ -1,11 +0,0 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { Context } from '../../context';
-import type { Router } from '../../router';
-import type { RPCHandlerOptions, StandardHandleOptions } from '../standard';
-import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from './types';
-export declare class RPCHandler<T extends Context> implements NodeHttpHandler<T> {
-    private readonly standardHandler;
-    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
-    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
-}
-//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/node/types.d.ts

@@ -1,22 +0,0 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
-import type { Context } from '../../context';
-import type { StandardHandleOptions } from '../standard';
-export type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
-    /**
-     * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
-     * This is useful for `express.js` middleware.
-     */
-    originalUrl?: string;
-};
-export type NodeHttpResponse = ServerResponse | Http2ServerResponse;
-export type NodeHttpHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-export interface NodeHttpHandler<T extends Context> {
-    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/standard/handler.d.ts

@@ -1,53 +0,0 @@
-import type { ErrorFromErrorMap, HTTPPath, Meta, Schema, SchemaOutput } from '@orpc/contract';
-import type { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import type { StandardRequest, StandardResponse } from '@orpc/standard-server';
-import type { Context } from '../../context';
-import type { Plugin } from '../../plugins';
-import type { ProcedureClientInterceptorOptions } from '../../procedure-client';
-import type { Router } from '../../router';
-import type { StandardCodec, StandardMatcher } from './types';
-export type StandardHandleOptions<T extends Context> = {
-    prefix?: HTTPPath;
-} & (Record<never, never> extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-export type WellStandardHandleOptions<T extends Context> = StandardHandleOptions<T> & {
-    context: T;
-};
-export type StandardHandleResult = {
-    matched: true;
-    response: StandardResponse;
-} | {
-    matched: false;
-    response: undefined;
-};
-export type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
-    request: StandardRequest;
-};
-export interface StandardHandlerOptions<TContext extends Context> {
-    plugins?: Plugin<TContext>[];
-    /**
-     * Interceptors at the request level, helpful when you want catch errors
-     */
-    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
-    /**
-     * Interceptors at the root level, helpful when you want override the request/response
-     */
-    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
-    /**
-     *
-     * Interceptors for procedure client.
-     */
-    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Schema, Record<never, never>, Meta>, SchemaOutput<Schema, unknown>, ErrorFromErrorMap<Record<never, never>>>[];
-}
-export declare class StandardHandler<T extends Context> {
-    private readonly matcher;
-    private readonly codec;
-    private readonly options;
-    private readonly plugin;
-    constructor(router: Router<T, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<T>>);
-    handle(request: StandardRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
-}
-//# sourceMappingURL=handler.d.ts.map

package/dist/src/adapters/standard/index.d.ts

@@ -1,6 +0,0 @@
-export * from './handler';
-export * from './rpc-codec';
-export * from './rpc-handler';
-export * from './rpc-matcher';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/standard/rpc-codec.d.ts

@@ -1,16 +0,0 @@
-import type { ORPCError } from '@orpc/client';
-import type { StandardRequest, StandardResponse } from '@orpc/standard-server';
-import type { AnyProcedure } from '../../procedure';
-import type { StandardCodec, StandardParams } from './types';
-import { RPCSerializer } from '@orpc/client/rpc';
-export interface StandardCodecOptions {
-    serializer?: RPCSerializer;
-}
-export declare class RPCCodec implements StandardCodec {
-    private readonly serializer;
-    constructor(options?: StandardCodecOptions);
-    decode(request: StandardRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
-    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
-    encodeError(error: ORPCError<any, any>): StandardResponse;
-}
-//# sourceMappingURL=rpc-codec.d.ts.map