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

package/dist/shared/server.BB464y-6.mjs

@@ -1,207 +0,0 @@
-import { wrapAsyncIteratorPreservingEventMeta, ORPCError } from '@orpc/client';
-import { createORPCErrorConstructorMap, reconcileORPCError, ValidationError, ProcedureContract } from '@orpc/contract';
-import { getConstructor, isTypescriptObject, resolveMaybeOptionalOptions, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, override, getTracer, traceAsyncIterator, traceReadableStream, mergeTwoLevels } from '@orpc/shared';
-
-class Lazy {
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  /**
-   * Checks if the given instance satisfies the {@link Lazy} class/interface.
-   */
-  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 === void 0 || Array.isArray(instance["~orpc"].metaPlugins)) && typeof instance["~orpc"].loader === "function";
-  }
-}
-function unlazy(maybeLazy) {
-  return maybeLazy instanceof Lazy ? maybeLazy["~orpc"].loader() : Promise.resolve({ default: maybeLazy });
-}
-
-function createProcedureClient(lazyableProcedure, ...rest) {
-  const options = resolveMaybeOptionalOptions(rest);
-  return async (...[input, callerOptions]) => {
-    const path = toArray(options.path);
-    const { default: procedure } = await unlazy(lazyableProcedure);
-    const clientContext = callerOptions?.context ?? {};
-    const context = await value(options.context, clientContext) ?? {};
-    const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
-    const reconcileError = async (e) => {
-      if (e instanceof ORPCError) {
-        return await reconcileORPCError(procedure["~orpc"].errorMap, e);
-      }
-      return e;
-    };
-    try {
-      const output = await runWithSpan("call_procedure", (span) => {
-        span?.setAttribute("procedure.path", path);
-        return intercept(
-          options.interceptors,
-          {
-            context,
-            // input can be optional if it is undefinable
-            input,
-            errors,
-            path,
-            procedure,
-            signal: callerOptions?.signal,
-            lastEventId: callerOptions?.lastEventId
-          },
-          (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
-        );
-      });
-      if (isAsyncIteratorObject(output)) {
-        return override(output, wrapAsyncIteratorPreservingEventMeta(
-          getTracer() ? traceAsyncIterator("consume_async_iterator_object_output", output) : output,
-          { mapError: reconcileError }
-        ));
-      } else if (getTracer() && output instanceof ReadableStream) {
-        return override(output, traceReadableStream("consume_octet_stream_output", output));
-      }
-      return output;
-    } catch (e) {
-      throw await reconcileError(e);
-    }
-  };
-}
-async function validateInput(i, schema, input) {
-  return runWithSpan(`validate_input.${i}`, async (span) => {
-    span?.setAttribute("input_schema.index", i);
-    const result = await schema["~standard"].validate(input);
-    if (result.issues) {
-      throw new ORPCError("BAD_REQUEST", {
-        message: "Input validation failed",
-        data: {
-          issues: result.issues
-        },
-        cause: new ValidationError({
-          message: "Input validation failed",
-          issues: result.issues,
-          invalidData: input
-        })
-      });
-    }
-    return result.value;
-  });
-}
-async function validateOutput(i, schema, output) {
-  return runWithSpan(`validate_output.${i}`, async (span) => {
-    span?.setAttribute("output_schema.index", i);
-    const result = await schema["~standard"].validate(output);
-    if (result.issues) {
-      throw new ORPCError("INTERNAL_SERVER_ERROR", {
-        message: "Output validation failed",
-        cause: new ValidationError({
-          message: "Output validation failed",
-          issues: result.issues,
-          invalidData: output
-        })
-      });
-    }
-    return result.value;
-  });
-}
-const middlewareDone = (...rest) => {
-  const options = resolveMaybeOptionalOptions(rest);
-  return {
-    output: options.output,
-    // context can be undefined when all field is optional
-    context: options.context ?? {}
-  };
-};
-async function executeProcedureInternal(procedure, options) {
-  const inputSchemas = toArray(procedure["~orpc"].inputSchemas);
-  const outputSchemas = toArray(procedure["~orpc"].outputSchemas);
-  const orderedMiddlewares = procedure["~orpc"].orderedMiddlewares;
-  const next = async (midIndex, context, input, signal) => {
-    let currentInput = input;
-    let middlewareInput = input;
-    const startInputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].inputSchemasLengthAtUse ?? 0;
-    const endInputIndex = midIndex === orderedMiddlewares.length ? inputSchemas.length : orderedMiddlewares[midIndex].inputSchemasLengthAtUse ?? 0;
-    if (!procedure["~orpc"].disableInputValidation) {
-      for (let i = startInputIndex; i < endInputIndex; i++) {
-        const validated = await validateInput(
-          i,
-          inputSchemas[i],
-          i !== 0 ? mergeTwoLevels(options.input, currentInput) : currentInput
-        );
-        currentInput = i !== 0 ? mergeTwoLevels(currentInput, validated) : validated;
-      }
-      middlewareInput = endInputIndex > 0 && endInputIndex < inputSchemas.length ? mergeTwoLevels(options.input, currentInput) : currentInput;
-    }
-    let currentOutput;
-    let currentContext = context;
-    if (midIndex < orderedMiddlewares.length) {
-      const { middleware } = orderedMiddlewares[midIndex];
-      const result = await runWithSpan(`middleware.${middleware.name}`, async (span) => {
-        span?.setAttribute("middleware.index", midIndex);
-        return await middleware(
-          {
-            ...options,
-            context,
-            signal,
-            next: (...rest) => {
-              const nextOptions = resolveMaybeOptionalOptions(rest);
-              const nextContext = nextOptions.context ?? {};
-              return next(
-                midIndex + 1,
-                { ...context, ...nextContext },
-                currentInput,
-                nextOptions.signal ?? signal
-              );
-            },
-            lastEventId: options.lastEventId
-          },
-          middlewareInput,
-          middlewareDone
-        );
-      });
-      currentOutput = result.output;
-      currentContext = { ...context, ...result.context };
-    } else {
-      currentOutput = await runWithSpan(
-        "handler",
-        () => procedure["~orpc"].handler({ ...options, context, input: currentInput, signal }, currentInput)
-      );
-    }
-    const startOutputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].outputSchemasLengthAtUse ?? 0;
-    const endOutputIndex = midIndex === orderedMiddlewares.length ? outputSchemas.length : orderedMiddlewares[midIndex].outputSchemasLengthAtUse ?? 0;
-    if (!procedure["~orpc"].disableOutputValidation) {
-      for (let i = endOutputIndex - 1; i >= startOutputIndex; i--) {
-        currentOutput = await validateOutput(i, outputSchemas[i], currentOutput);
-      }
-    }
-    return { output: currentOutput, context: currentContext };
-  };
-  const { output } = await next(0, options.context, options.input, options.signal);
-  return output;
-}
-
-class Procedure {
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  /**
-   * Checks if the given instance satisfies the {@link Procedure} class/interface.
-   */
-  static [Symbol.hasInstance](instance) {
-    if (this !== Procedure) {
-      return Function.prototype[Symbol.hasInstance].call(this, instance);
-    }
-    const constructor = getConstructor(instance);
-    if (constructor === Procedure) {
-      return true;
-    }
-    return instance instanceof ProcedureContract && Array.isArray(instance["~orpc"].orderedMiddlewares) && typeof instance["~orpc"].handler === "function";
-  }
-}
-
-export { Lazy as L, Procedure as P, createProcedureClient as c, unlazy as u };

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

@@ -1,73 +0,0 @@
-import { RouterContract, ProcedureContract, ORPCErrorFromErrorMap, ThrowableError, InferSchemaInput, InferSchemaOutput } from '@orpc/contract';
-import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.DFPxP2v3.mjs';
-
-type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any> | {
-    [k: string]: Lazyable<Router<TInitialContext>>;
-};
-type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap> : {
-    [K in keyof T]: T[K] extends RouterContract ? Lazyable<ContractedRouter<T[K], TInitialContext>> : never;
-};
-type AnyRouter = Router<any>;
-type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $> ? $ : never;
-/**
- * Infer all initial context of the router.
- *
- * @remarks
- * **Note**: A procedure is a router too.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-initial-contexts | Router - Infer Router Initial Contexts}
- */
-type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any> ? UInitialContext : {
-    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
-};
-/**
- * Infer all current context of the router.
- *
- * @remarks
- * **Note**: A procedure is a router too.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-final-contexts | Router - Infer Router Final Contexts}
- */
-type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
-    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterFinalContexts<U> : never;
-};
-/**
- * Infer all router inputs.
- *
- * @remarks
- * **Note**: A procedure is a router too.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-inputs | Router - Infer Router Inputs}
- */
-type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any> ? InferSchemaInput<UInputSchema> : {
-    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
-};
-/**
- * Infer all router outputs.
- *
- * @remarks
- * **Note**: A procedure is a router too.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-outputs | Router - Infer Router Outputs}
- */
-type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any> ? InferSchemaOutput<UOutputSchema> : {
-    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
-};
-/**
- * Infer the union of throwable errors for entire router.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-error | Router - Infer Router Error}
- */
-type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
-    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterError<U> : never;
-}[keyof T];
-/**
- * Infer throwable errors for each procedure, preserving the router shape.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-errors | Router - Infer Router Errors}
- */
-type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
-    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterErrors<U> : never;
-};
-
-export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterFinalContexts as a, InferRouterError as b, InferRouterErrors as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };

package/dist/shared/server.BSYGskId.d.ts

@@ -1,14 +0,0 @@
-import { Value, Promisable } from '@orpc/shared';
-import { StandardLazyRequest } from '@standard-server/core';
-import { C as Context } from './server.DFPxP2v3.js';
-import { a as StandardHandlerHandleOptions } from './server.DOg7ke6y.js';
-
-type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]> | undefined;
-} : {
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-});
-declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
-
-export { resolveFriendlyStandardHandlerHandleOptions as r };
-export type { FriendlyStandardHandlerHandleOptions as F };

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

@@ -1,14 +0,0 @@
-import { Value, Promisable } from '@orpc/shared';
-import { StandardLazyRequest } from '@standard-server/core';
-import { C as Context } from './server.DFPxP2v3.mjs';
-import { a as StandardHandlerHandleOptions } from './server.9B1jEm5a.mjs';
-
-type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]> | undefined;
-} : {
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-});
-declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
-
-export { resolveFriendlyStandardHandlerHandleOptions as r };
-export type { FriendlyStandardHandlerHandleOptions as F };

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

@@ -1,34 +0,0 @@
-import { C as Context } from './server.DFPxP2v3.mjs';
-import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.9B1jEm5a.mjs';
-
-interface RequestLimitHandlerPluginOptions {
-    /**
-     * The maximum allowed request body size in bytes.
-     */
-    maxBodySize: number;
-}
-/**
- * Rejects requests whose body exceeds `maxBodySize`.
- *
- * When used with the request compression plugin, the limit applies to the
- * decompressed payload rather than the compressed wire size.
- *
- * @see {@link https://orpc.dev/docs/plugins/request-limit | Request Limit Plugin}
- */
-declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    /**
-     * Should limit the original batch request body instead of sub-requests.
-     */
-    after: string[];
-    /**
-     * Should limit the final body size instead of the compressed one.
-     */
-    before: string[];
-    private readonly maxBodySize;
-    constructor(options: RequestLimitHandlerPluginOptions);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-export { RequestLimitHandlerPlugin as R };
-export type { RequestLimitHandlerPluginOptions as a };

package/dist/shared/server.CYbIpHbH.mjs

@@ -1,239 +0,0 @@
-import { ProcedureContract, resolveMetaPlugins, mergeErrorMap } from '@orpc/contract';
-import { isTypescriptObject, getOwn, omit } from '@orpc/shared';
-import { c as createProcedureClient, L as Lazy, u as unlazy, P as Procedure } from './server.BB464y-6.mjs';
-
-const DEFAULT_SUCCESS_STATUS = 200;
-const DEFAULT_ERROR_STATUS = 400;
-
-function createGuardedProcedureLazy(lazy) {
-  const guarded = new Lazy({
-    ...lazy["~orpc"],
-    async loader() {
-      const { default: maybeProcedure } = await unlazy(lazy);
-      if (!(maybeProcedure instanceof Procedure)) {
-        throw new TypeError(`
-          Expected a lazy<procedure> but got lazy<unknown>.
-          This should be caught by TypeScript compilation.
-          Please report this issue if you think this is a bug.
-        `);
-      }
-      return { default: maybeProcedure };
-    }
-  });
-  return guarded;
-}
-function createContractProcedure(procedure, contract) {
-  return new Procedure({
-    ...procedure["~orpc"],
-    errorMap: contract["~orpc"].errorMap,
-    meta: contract["~orpc"].meta,
-    metaPlugins: contract["~orpc"].metaPlugins
-  });
-}
-function call(lazyableProcedure, ...[
-  input = void 0,
-  options = {}
-]) {
-  return createProcedureClient(lazyableProcedure, options)(input, options);
-}
-
-const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol.for("ORPC_HIDDEN_ROUTER_CONTRACT");
-function withHiddenRouterContract(router, contract) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
-        return contract;
-      }
-      return Reflect.get(target, key);
-    }
-  });
-}
-function getHiddenRouterContract(router) {
-  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
-}
-
-function augmentRouter(router, options) {
-  if (router instanceof Lazy) {
-    const [meta, metaPlugins] = resolveMetaPlugins(
-      options.meta,
-      options.metaPlugins,
-      router["~orpc"].metaPlugins
-    );
-    const enhanced2 = new Lazy({
-      meta,
-      metaPlugins,
-      async loader() {
-        const { default: unlaziedRouter } = await unlazy(router);
-        const enhanced3 = augmentRouter(unlaziedRouter, options);
-        return unlazy(enhanced3);
-      }
-    });
-    return enhanced2;
-  }
-  if (router instanceof Procedure) {
-    const [meta, metaPlugins] = resolveMetaPlugins(
-      options.meta,
-      options.metaPlugins,
-      router["~orpc"].metaPlugins
-    );
-    const enhanced2 = new Procedure({
-      ...omit(options, ["middlewares", "errorMap", "meta", "metaPlugins"]),
-      ...router["~orpc"],
-      meta,
-      metaPlugins,
-      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
-      orderedMiddlewares: [
-        ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
-        ...router["~orpc"].orderedMiddlewares
-      ]
-    });
-    return enhanced2;
-  }
-  if (!isTypescriptObject(router)) {
-    return router;
-  }
-  const enhanced = {};
-  for (const [key, child] of Object.entries(router)) {
-    enhanced[key] = augmentRouter(child, options);
-  }
-  return enhanced;
-}
-function augmentImplementedRouter(router, options) {
-  if (router instanceof Lazy) {
-    const enhanced2 = new Lazy({
-      ...router["~orpc"],
-      async loader() {
-        const { default: unlaziedRouter } = await unlazy(router);
-        const enhanced3 = augmentImplementedRouter(unlaziedRouter, options);
-        return unlazy(enhanced3);
-      }
-    });
-    return enhanced2;
-  }
-  if (router instanceof Procedure) {
-    const enhanced2 = new Procedure({
-      ...omit(options, ["middlewares"]),
-      ...router["~orpc"],
-      orderedMiddlewares: [
-        ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
-        ...router["~orpc"].orderedMiddlewares
-      ]
-    });
-    return enhanced2;
-  }
-  if (!isTypescriptObject(router)) {
-    return router;
-  }
-  const enhanced = {};
-  for (const [key, child] of Object.entries(router)) {
-    enhanced[key] = augmentImplementedRouter(child, options);
-  }
-  return enhanced;
-}
-async function resolveContractProcedure(router, contract, path) {
-  if (contract instanceof Procedure) {
-    return contract;
-  }
-  const { default: maybeProcedure } = await unlazy(getRouter(router, path));
-  if (!(maybeProcedure instanceof Procedure)) {
-    throw new TypeError(
-      `[Contract-First] Missing or invalid implementation for procedure at path: "${path.join(".")}". Ensure the procedure is correctly implemented and matches its contract.`
-    );
-  }
-  return createContractProcedure(maybeProcedure, contract);
-}
-function getRouter(router, path) {
-  let current = router;
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i];
-    if (!isTypescriptObject(current)) {
-      return void 0;
-    }
-    if (current instanceof Procedure) {
-      return void 0;
-    }
-    if (!(current instanceof Lazy)) {
-      current = getOwn(current, segment);
-      continue;
-    }
-    const lazied = current;
-    const rest = path.slice(i);
-    return new Lazy({
-      ...lazied["~orpc"],
-      async loader() {
-        const unwrapped = await unlazy(lazied);
-        const next = getRouter(unwrapped.default, rest);
-        return await unlazy(next);
-      }
-    });
-  }
-  if (!isTypescriptObject(current)) {
-    return void 0;
-  }
-  return current;
-}
-function walkProcedureContractsSync(router, callback, path = []) {
-  const lazyResults = [];
-  walkProcedureContractsSyncInternal(router, callback, path.slice(), lazyResults);
-  return lazyResults;
-}
-function walkProcedureContractsSyncInternal(router, callback, path, lazyResults) {
-  const hiddenContract = getHiddenRouterContract(router);
-  if (hiddenContract !== void 0) {
-    router = hiddenContract;
-  }
-  if (router instanceof ProcedureContract) {
-    callback(router, path.slice());
-    return;
-  }
-  if (!isTypescriptObject(router)) {
-    return;
-  }
-  for (const [key, value] of Object.entries(router)) {
-    path.push(key);
-    if (value instanceof Lazy) {
-      lazyResults.push({ router: value, path: path.slice() });
-    } else {
-      walkProcedureContractsSyncInternal(value, callback, path, lazyResults);
-    }
-    path.pop();
-  }
-}
-async function walkProcedureContractsAsync(router, callback, path = []) {
-  const hiddenContract = getHiddenRouterContract(router);
-  if (hiddenContract !== void 0) {
-    router = hiddenContract;
-  }
-  if (router instanceof ProcedureContract) {
-    await callback(router, path);
-    return;
-  }
-  if (!isTypescriptObject(router)) {
-    return;
-  }
-  for (const [key, value] of Object.entries(router)) {
-    if (value instanceof Lazy) {
-      const { default: router2 } = await unlazy(value);
-      await walkProcedureContractsAsync(router2, callback, [...path, key]);
-    } else {
-      await walkProcedureContractsAsync(value, callback, [...path, key]);
-    }
-  }
-}
-async function unlazyRouter(router) {
-  if (router instanceof Procedure) {
-    return router;
-  }
-  if (!isTypescriptObject(router)) {
-    return router;
-  }
-  const unlazied = {};
-  for (const key of Object.keys(router)) {
-    const item = router[key];
-    const { default: unlaziedRouter } = await unlazy(item);
-    unlazied[key] = await unlazyRouter(unlaziedRouter);
-  }
-  return unlazied;
-}
-
-export { DEFAULT_SUCCESS_STATUS as D, DEFAULT_ERROR_STATUS as a, augmentRouter as b, augmentImplementedRouter as c, withHiddenRouterContract as d, createGuardedProcedureLazy as e, call as f, getRouter as g, walkProcedureContractsAsync as h, resolveContractProcedure as r, unlazyRouter as u, walkProcedureContractsSync as w };

package/dist/shared/server.CgBF3Vj1.d.ts

@@ -1,34 +0,0 @@
-import { C as Context } from './server.DFPxP2v3.js';
-import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.DOg7ke6y.js';
-
-interface RequestLimitHandlerPluginOptions {
-    /**
-     * The maximum allowed request body size in bytes.
-     */
-    maxBodySize: number;
-}
-/**
- * Rejects requests whose body exceeds `maxBodySize`.
- *
- * When used with the request compression plugin, the limit applies to the
- * decompressed payload rather than the compressed wire size.
- *
- * @see {@link https://orpc.dev/docs/plugins/request-limit | Request Limit Plugin}
- */
-declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    /**
-     * Should limit the original batch request body instead of sub-requests.
-     */
-    after: string[];
-    /**
-     * Should limit the final body size instead of the compressed one.
-     */
-    before: string[];
-    private readonly maxBodySize;
-    constructor(options: RequestLimitHandlerPluginOptions);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-export { RequestLimitHandlerPlugin as R };
-export type { RequestLimitHandlerPluginOptions as a };