@temporary-name/server 1.9.3-alpha.bb3867758271e7fcf8c191f9693365d655697e7f → 1.9.3-alpha.beffd198e2d5853e3d12fa1517c8c9c06bbe6cee

package/dist/shared/server.ChOv1yG3.mjs

@@ -0,0 +1,319 @@
+import { HTTPMethods } from '@temporary-name/shared';
+import * as z from '@temporary-name/zod';
+
+function isStartWithMiddlewares(middlewares, compare) {
+  if (compare.length > middlewares.length) {
+    return false;
+  }
+  for (let i = 0; i < middlewares.length; i++) {
+    if (compare[i] === void 0) {
+      return true;
+    }
+    if (middlewares[i] !== compare[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function mergeMiddlewares(first, second, options) {
+  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
+    return second;
+  }
+  return [...first, ...second];
+}
+function addMiddleware(middlewares, addition) {
+  return [...middlewares, addition];
+}
+
+class Contract {
+  /**
+   * This property holds the defined options.
+   */
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+}
+class Procedure extends Contract {
+}
+function isProcedure(item) {
+  return item instanceof Procedure || // This is so we'll return true for Proxy-wrapped Procedures e.g. as returned by `callable`
+  (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "route" in item["~orpc"] && "meta" in item["~orpc"] && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
+}
+
+class ValidationError extends Error {
+  issues;
+  data;
+  constructor(options) {
+    super(options.message, options);
+    this.issues = options.issues;
+    this.data = options.data;
+  }
+}
+
+function mergeRoute(a, b) {
+  return { ...a, ...b };
+}
+function prefixRoute(route, prefix) {
+  if (!route.path) {
+    return route;
+  }
+  return {
+    ...route,
+    path: `${prefix}${route.path}`
+  };
+}
+function unshiftTagRoute(route, tags) {
+  return {
+    ...route,
+    tags: [...tags, ...route.tags ?? []]
+  };
+}
+function mergePrefix(a, b) {
+  return a ? `${a}${b}` : b;
+}
+function mergeTags(a, b) {
+  return a ? [...a, ...b] : b;
+}
+function enhanceRoute(route, options) {
+  let router = route;
+  if (options.prefix) {
+    router = prefixRoute(router, options.prefix);
+  }
+  if (options.tags?.length) {
+    router = unshiftTagRoute(router, options.tags);
+  }
+  return router;
+}
+
+function getRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!current) {
+      return void 0;
+    }
+    if (isProcedure(current)) {
+      return void 0;
+    }
+    if (!isLazy(current)) {
+      current = current[segment];
+      continue;
+    }
+    const lazied = current;
+    const rest = path.slice(i);
+    return lazyInternal(async () => {
+      const unwrapped = await unlazy(lazied);
+      const next = getRouter(unwrapped.default, rest);
+      return unlazy(next);
+    }, getLazyMeta(lazied));
+  }
+  return current;
+}
+function createAccessibleLazyRouter(lazied) {
+  const recursive = new Proxy(lazied, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = getRouter(lazied, [key]);
+      return createAccessibleLazyRouter(next);
+    }
+  });
+  return recursive;
+}
+function enhanceRouter(router, options) {
+  if (isLazy(router)) {
+    const laziedMeta = getLazyMeta(router);
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+    const enhanced2 = lazyInternal(
+      async () => {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = enhanceRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      },
+      {
+        ...laziedMeta,
+        prefix: enhancedPrefix
+      }
+    );
+    const accessible = createAccessibleLazyRouter(enhanced2);
+    return accessible;
+  }
+  if (isProcedure(router)) {
+    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, {
+      dedupeLeading: options.dedupeLeadingMiddlewares
+    });
+    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      route: enhanceRoute(router["~orpc"].route, options),
+      middlewares: newMiddlewares,
+      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
+      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
+    });
+    return enhanced2;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceRouter(router[key], options);
+  }
+  return enhanced;
+}
+function traverseContractProcedures(options, callback, lazyOptions = []) {
+  const currentRouter = options.router;
+  if (isLazy(currentRouter)) {
+    lazyOptions.push({
+      router: currentRouter,
+      path: options.path
+    });
+  } else if (currentRouter instanceof Contract) {
+    callback({
+      contract: currentRouter,
+      path: options.path
+    });
+  } else if (typeof currentRouter === "string") {
+    throw new Error("Unexpected: got string instead of router");
+  } else {
+    for (const key in currentRouter) {
+      traverseContractProcedures(
+        {
+          router: currentRouter[key],
+          path: [...options.path, key]
+        },
+        callback,
+        lazyOptions
+      );
+    }
+  }
+  return lazyOptions;
+}
+async function resolveContractProcedures(options, callback) {
+  const pending = [options];
+  for (const options2 of pending) {
+    const lazyOptions = traverseContractProcedures(options2, callback);
+    for (const options3 of lazyOptions) {
+      const { default: router } = await unlazy(options3.router);
+      pending.push({
+        router,
+        path: options3.path
+      });
+    }
+  }
+}
+async function unlazyRouter(router) {
+  if (isProcedure(router)) {
+    return router;
+  }
+  const unlazied = {};
+  for (const key in router) {
+    const item = router[key];
+    const { default: unlaziedRouter } = await unlazy(item);
+    unlazied[key] = await unlazyRouter(unlaziedRouter);
+  }
+  return unlazied;
+}
+
+const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazyInternal(loader, meta = {}) {
+  return {
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
+  };
+}
+function lazy(prefix, loader) {
+  return enhanceRouter(lazyInternal(loader), {
+    middlewares: [],
+    dedupeLeadingMiddlewares: true,
+    prefix
+  });
+}
+function isLazy(item) {
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+}
+function getLazyMeta(lazied) {
+  return lazied[LAZY_SYMBOL].meta;
+}
+function unlazy(lazied) {
+  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+}
+
+const endpointRegex = new RegExp(`^(${HTTPMethods.join("|")})`);
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function getDynamicParams(path) {
+  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
+    raw: v,
+    name: v.match(/\{\+?([^}]+)\}/)[1]
+  })) : void 0;
+}
+function parseEndpointDefinition(stringsOrEndpoint, values) {
+  let method, path, pathSchema;
+  if (stringsOrEndpoint instanceof Array) {
+    let endpoint = stringsOrEndpoint[0];
+    if (endpoint === void 0 || !endpointRegex.test(endpoint)) {
+      throw new Error(".endpoint() must start with a valid HTTP endpoint string.");
+    }
+    const shape = {};
+    for (let i = 1; i < stringsOrEndpoint.length; i++) {
+      const str = stringsOrEndpoint[i];
+      const value = values[i - 1];
+      if (typeof value !== "object" || value instanceof z.core.$ZodType) {
+        throw new Error(
+          `Each template value for .endpoint must be an object with a single key, whose value is a ZodType.`
+        );
+      }
+      const valueEntries = Object.entries(value);
+      if (valueEntries.length !== 1) {
+        throw new Error(
+          `Each template value for .endpoint must be an object with a single key, whose value is a ZodType.`
+        );
+      }
+      const [key, schema] = valueEntries[0];
+      endpoint += `{${key}}${str}`;
+      if (key in schema) {
+        throw new Error(`Duplicate path parameter name "${key}" in endpoint.`);
+      }
+      shape[key] = schema;
+    }
+    [method, path] = endpoint.split(" ", 2);
+    pathSchema = z.object(shape);
+  } else if (values.length <= 1) {
+    const endpoint = stringsOrEndpoint;
+    const schema = values[0];
+    [method, path] = endpoint.split(" ", 2);
+    const pathParamNames = getDynamicParams(path)?.map((p) => p.name) ?? [];
+    let schemaKeys;
+    if (schema instanceof z.core.$ZodType) {
+      if (schema instanceof z.core.$ZodObject) {
+        schemaKeys = Object.keys(schema._zod.def.shape);
+        pathSchema = schema;
+      } else {
+        throw new Error(
+          `Path schema for endpoint "${endpoint}" must be a ZodObject schema (or object where each value is a ZodType).`
+        );
+      }
+    } else if (typeof schema === "object") {
+      schemaKeys = Object.keys(schema);
+      pathSchema = z.object(schema);
+    } else if (schema !== void 0) {
+      throw new Error(
+        `Path schema for endpoint "${endpoint}" must be a ZodObject schema (or object where each value is a ZodType).`
+      );
+    } else {
+      schemaKeys = [];
+      pathSchema = z.object({});
+    }
+    if (pathParamNames.length !== schemaKeys.length || !pathParamNames.every((name) => schemaKeys.includes(name))) {
+      throw new Error(`Path schema keys do not match dynamic parameters in endpoint "${endpoint}".`);
+    }
+  } else {
+    throw new Error("Invalid arguments for .endpoint() method.");
+  }
+  return { method, path, pathSchema };
+}
+
+export { Contract as C, LAZY_SYMBOL as L, Procedure as P, ValidationError as V, mergeTags as a, mergeRoute as b, prefixRoute as c, addMiddleware as d, enhanceRouter as e, getLazyMeta as f, getDynamicParams as g, isLazy as h, isProcedure as i, getRouter as j, lazy as k, lazyInternal as l, mergePrefix as m, isStartWithMiddlewares as n, mergeMiddlewares as o, parseEndpointDefinition as p, createAccessibleLazyRouter as q, resolveContractProcedures as r, standardizeHTTPPath as s, traverseContractProcedures as t, unlazy as u, unlazyRouter as v, endpointRegex as w };

package/dist/shared/server.Cza0RB3u.mjs

@@ -0,0 +1,160 @@
+import { resolveMaybeOptionalOptions, toArray, value, runWithSpan, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan, ORPCError } from '@temporary-name/shared';
+import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
+import { safeDecodeAsync, safeEncodeAsync } from '@temporary-name/zod';
+import { u as unlazy, V as ValidationError } from './server.ChOv1yG3.mjs';
+
+function mergeCurrentContext(context, other) {
+  return { ...context, ...other };
+}
+
+function middlewareOutputFn(output) {
+  return { output, context: {} };
+}
+
+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 output = await runWithSpan({ name: "call_procedure", signal: callerOptions?.signal }, (span) => {
+      span?.setAttribute("procedure.path", [...path]);
+      return executeProcedureInternal(procedure, input, {
+        context,
+        path,
+        procedure,
+        request: callerOptions?.request,
+        signal: callerOptions?.signal,
+        lastEventId: callerOptions?.lastEventId
+      });
+    });
+    if (isAsyncIteratorObject(output)) {
+      if (output instanceof HibernationEventIterator) {
+        return output;
+      }
+      return overlayProxy(
+        output,
+        mapEventIterator(
+          asyncIteratorWithSpan(
+            { name: "consume_event_iterator_output", signal: callerOptions?.signal },
+            output
+          ),
+          {
+            value: (v) => v,
+            error: async (e) => e
+          }
+        )
+      );
+    }
+    return output;
+  };
+}
+async function validateInput(procedure, input) {
+  const schemas = procedure["~orpc"].schemas;
+  return runWithSpan({ name: "validate_input" }, async () => {
+    const resultBody = await safeDecodeAsync(schemas.bodySchema, input.body, { parseType: "body" });
+    const resultPath = await safeDecodeAsync(schemas.pathSchema, input.path, { parseType: "path" });
+    const resultQuery = await safeDecodeAsync(schemas.querySchema, input.query, { parseType: "query" });
+    const issues = [];
+    if (!resultBody.success) {
+      issues.push(...resultBody.error.issues.map((i) => ({ ...i, path: ["body", ...i.path] })));
+    }
+    if (!resultPath.success) {
+      issues.push(...resultPath.error.issues.map((i) => ({ ...i, path: ["path", ...i.path] })));
+    }
+    if (!resultQuery.success) {
+      issues.push(...resultQuery.error.issues.map((i) => ({ ...i, path: ["query", ...i.path] })));
+    }
+    if (issues.length > 0) {
+      throw new ORPCError("BAD_REQUEST", {
+        message: "Input validation failed",
+        data: {
+          issues
+        },
+        cause: new ValidationError({
+          message: "Input validation failed",
+          issues,
+          data: input
+        })
+      });
+    }
+    const results = {
+      body: resultBody.data,
+      path: resultPath.data,
+      query: resultQuery.data
+    };
+    return results;
+  });
+}
+async function validateOutput(procedure, output) {
+  const schema = procedure["~orpc"].schemas.outputSchema;
+  if (!schema) {
+    return output;
+  }
+  return runWithSpan({ name: "validate_output" }, async () => {
+    const result = await safeEncodeAsync(schema, output, { parseType: "output" });
+    if (!result.success) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Output validation failed",
+        cause: new ValidationError({
+          message: "Output validation failed",
+          issues: result.error.issues,
+          data: output
+        })
+      });
+    }
+    return result.data;
+  });
+}
+async function executeProcedureInternal(procedure, input, options) {
+  const middlewares = procedure["~orpc"].middlewares;
+  const inputValidationIndex = Math.min(
+    Math.max(0, procedure["~orpc"].inputValidationIndex),
+    middlewares.length
+  );
+  const outputValidationIndex = Math.min(
+    Math.max(0, procedure["~orpc"].outputValidationIndex),
+    middlewares.length
+  );
+  const next = async (index, context, input2) => {
+    let currentInput = input2;
+    if (index === inputValidationIndex) {
+      currentInput = await validateInput(procedure, currentInput);
+    }
+    const mid = middlewares[index];
+    const output = mid ? await runWithSpan({ name: `middleware.${mid.name}`, signal: options.signal }, async (span) => {
+      span?.setAttribute("middleware.index", index);
+      span?.setAttribute("middleware.name", mid.name);
+      const result = await mid(
+        {
+          ...options,
+          context,
+          next: async (nextOptions) => {
+            const nextContext = nextOptions?.context ?? {};
+            return {
+              output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+              // NB: Pretty sure this isn't used (or meant to be used) at runtime, it's just there
+              // to get type inference in the builder (via the caller returning the output of next() in
+              // the middleware function)
+              context: nextContext
+            };
+          }
+        },
+        currentInput,
+        middlewareOutputFn
+      );
+      return result.output;
+    }) : await runWithSpan(
+      { name: "handler", signal: options.signal },
+      () => procedure["~orpc"].handler(currentInput, { ...options, context })
+    );
+    if (index === outputValidationIndex) {
+      return await validateOutput(procedure, output);
+    }
+    return output;
+  };
+  return next(0, options.context, input);
+}
+
+export { middlewareOutputFn as a, createProcedureClient as c, mergeCurrentContext as m };

package/dist/shared/server.YUvuxHty.mjs

@@ -0,0 +1,48 @@
+import { isAsyncIteratorObject, ORPCError } from '@temporary-name/shared';
+import { mapEventIterator } from '@temporary-name/standard-server';
+import { custom, safeParseAsync } from '@temporary-name/zod';
+import { V as ValidationError } from './server.ChOv1yG3.mjs';
+
+const EVENT_ITERATOR_DETAILS_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_DETAILS");
+function eventIterator(yields, returns) {
+  const schema = custom(
+    (iterator) => isAsyncIteratorObject(iterator)
+  ).transform((iterator) => {
+    const mapped = mapEventIterator(iterator, {
+      async value(value, done) {
+        const schema2 = done ? returns : yields;
+        if (!schema2) {
+          return value;
+        }
+        const result = await safeParseAsync(schema2, value);
+        if (result.success) {
+          return result.data;
+        } else {
+          throw new ORPCError("EVENT_ITERATOR_VALIDATION_FAILED", {
+            message: "Event iterator validation failed",
+            cause: new ValidationError({
+              issues: result.error.issues,
+              message: "Event iterator validation failed",
+              data: value
+            })
+          });
+        }
+      },
+      error: async (error) => error
+    });
+    return mapped;
+  });
+  schema[EVENT_ITERATOR_DETAILS_SYMBOL] = {
+    yields,
+    returns
+  };
+  return schema;
+}
+function getEventIteratorSchemaDetails(schema) {
+  if (schema === void 0) {
+    return void 0;
+  }
+  return schema[EVENT_ITERATOR_DETAILS_SYMBOL];
+}
+
+export { eventIterator as e, getEventIteratorSchemaDetails as g };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@temporary-name/server",
   "type": "module",
-  "version": "1.9.3-alpha.bb3867758271e7fcf8c191f9693365d655697e7f",
+  "version": "1.9.3-alpha.beffd198e2d5853e3d12fa1517c8c9c06bbe6cee",
   "license": "MIT",
   "homepage": "https://www.stainless.com/",
   "repository": {
@@ -23,11 +23,6 @@
       "import": "./dist/helpers/index.mjs",
       "default": "./dist/helpers/index.mjs"
     },
-    "./plugins": {
-      "types": "./dist/plugins/index.d.mts",
-      "import": "./dist/plugins/index.mjs",
-      "default": "./dist/plugins/index.mjs"
-    },
     "./standard": {
       "types": "./dist/adapters/standard/index.d.mts",
       "import": "./dist/adapters/standard/index.mjs",
@@ -57,31 +52,17 @@
   "files": [
     "dist"
   ],
-  "peerDependencies": {
-    "drizzle-orm": "^0.44.5",
-    "drizzle-zod": "^0.8.3"
-  },
-  "peerDependenciesMeta": {
-    "drizzle-orm": {
-      "optional": true
-    },
-    "drizzle-zod": {
-      "optional": true
-    }
-  },
   "dependencies": {
     "cookie": "^1.0.2",
     "rou3": "^0.7.7",
     "zod": "^4.1.12",
-    "@temporary-name/contract": "1.9.3-alpha.bb3867758271e7fcf8c191f9693365d655697e7f",
-    "@temporary-name/json-schema": "1.9.3-alpha.bb3867758271e7fcf8c191f9693365d655697e7f",
-    "@temporary-name/interop": "1.9.3-alpha.bb3867758271e7fcf8c191f9693365d655697e7f",
-    "@temporary-name/shared": "1.9.3-alpha.bb3867758271e7fcf8c191f9693365d655697e7f",
-    "@temporary-name/standard-server": "1.9.3-alpha.bb3867758271e7fcf8c191f9693365d655697e7f",
-    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.bb3867758271e7fcf8c191f9693365d655697e7f",
-    "@temporary-name/standard-server-fetch": "1.9.3-alpha.bb3867758271e7fcf8c191f9693365d655697e7f",
-    "@temporary-name/zod": "1.9.3-alpha.bb3867758271e7fcf8c191f9693365d655697e7f",
-    "@temporary-name/standard-server-node": "1.9.3-alpha.bb3867758271e7fcf8c191f9693365d655697e7f"
+    "@temporary-name/shared": "1.9.3-alpha.beffd198e2d5853e3d12fa1517c8c9c06bbe6cee",
+    "@temporary-name/interop": "1.9.3-alpha.beffd198e2d5853e3d12fa1517c8c9c06bbe6cee",
+    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.beffd198e2d5853e3d12fa1517c8c9c06bbe6cee",
+    "@temporary-name/standard-server-fetch": "1.9.3-alpha.beffd198e2d5853e3d12fa1517c8c9c06bbe6cee",
+    "@temporary-name/standard-server-node": "1.9.3-alpha.beffd198e2d5853e3d12fa1517c8c9c06bbe6cee",
+    "@temporary-name/standard-server": "1.9.3-alpha.beffd198e2d5853e3d12fa1517c8c9c06bbe6cee",
+    "@temporary-name/zod": "1.9.3-alpha.beffd198e2d5853e3d12fa1517c8c9c06bbe6cee"
   },
   "devDependencies": {
     "@types/supertest": "^6.0.3",
@@ -91,6 +72,7 @@
   "scripts": {
     "build": "unbuild",
     "build:watch": "pnpm run build --watch",
-    "type:check": "tsc -b"
+    "clean": "tsc -b --clean",
+    "lint:tsc": "tsc -b"
   }
 }

package/dist/plugins/index.d.mts

@@ -1,84 +0,0 @@
-import { Value, Promisable, ORPCError } from '@temporary-name/shared';
-import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.D6Qs_UcF.mjs';
-import { C as Context, G as ProcedureClientInterceptorOptions } from '../shared/server.BL2R5jcp.mjs';
-import { Meta } from '@temporary-name/contract';
-
-interface CORSOptions<T extends Context> {
-    origin?: Value<Promisable<string | readonly string[] | null | undefined>, [
-        origin: string,
-        options: StandardHandlerInterceptorOptions<T>
-    ]>;
-    timingOrigin?: Value<Promisable<string | readonly string[] | null | undefined>, [
-        origin: string,
-        options: StandardHandlerInterceptorOptions<T>
-    ]>;
-    allowMethods?: readonly string[];
-    allowHeaders?: readonly string[];
-    maxAge?: number;
-    credentials?: boolean;
-    exposeHeaders?: readonly string[];
-}
-/**
- * CORSPlugin is a plugin for oRPC that allows you to configure CORS for your API.
- *
- * @see {@link https://orpc.unnoq.com/docs/plugins/cors CORS Plugin Docs}
- */
-declare class CORSPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    private readonly options;
-    order: number;
-    constructor(options?: CORSOptions<T>);
-    init(options: StandardHandlerOptions<T>): void;
-}
-
-interface SimpleCsrfProtectionHandlerPluginOptions<T extends Context> {
-    /**
-     * The name of the header to check.
-     *
-     * @default 'x-csrf-token'
-     */
-    headerName?: Value<Promisable<string>, [options: StandardHandlerInterceptorOptions<T>]>;
-    /**
-     * The value of the header to check.
-     *
-     * @default 'orpc'
-     *
-     */
-    headerValue?: Value<Promisable<string>, [options: StandardHandlerInterceptorOptions<T>]>;
-    /**
-     * Exclude a procedure from the plugin.
-     *
-     * @default false
-     *
-     */
-    exclude?: Value<Promisable<boolean>, [
-        options: ProcedureClientInterceptorOptions<T, Record<never, never>, Meta>
-    ]>;
-    /**
-     * The error thrown when the CSRF token is invalid.
-     *
-     * @default new ORPCError('CSRF_TOKEN_MISMATCH', {
-     *   status: 403,
-     *   message: 'Invalid CSRF token',
-     * })
-     */
-    error?: InstanceType<typeof ORPCError>;
-}
-/**
- * This plugin adds basic Cross-Site Request Forgery (CSRF) protection to your oRPC application.
- * It helps ensure that requests to your procedures originate from JavaScript code,
- * not from other sources like standard HTML forms or direct browser navigation.
- *
- * @see {@link https://orpc.unnoq.com/docs/plugins/simple-csrf-protection Simple CSRF Protection Plugin Docs}
- */
-declare class SimpleCsrfProtectionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    private readonly headerName;
-    private readonly headerValue;
-    private readonly exclude;
-    private readonly error;
-    constructor(options?: SimpleCsrfProtectionHandlerPluginOptions<T>);
-    order: number;
-    init(options: StandardHandlerOptions<T>): void;
-}
-
-export { CORSPlugin, SimpleCsrfProtectionHandlerPlugin };
-export type { CORSOptions, SimpleCsrfProtectionHandlerPluginOptions };