@temporary-name/server 1.9.3-alpha.26612c2cf6a7177d2b500d984d282309d8320ca3 → 1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827

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

@@ -0,0 +1,226 @@
+import { Promisable, StandardLazyRequest, HTTPPath } from '@temporary-name/shared';
+import { Meta, Schemas, Route, InferProcedureClientInputs, InferSchemaOutput, EnhanceRouteOptions } from '@temporary-name/contract';
+
+type Context = Record<PropertyKey, any>;
+type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
+type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+type BuildContextWithAuth<TContext extends Context, TAuthContext> = MergedCurrentContext<TContext, {
+    auth: TAuthContext | ('auth' extends keyof TContext ? TContext['auth'] : never);
+}>;
+declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = {}>(options?: {
+        context?: U;
+    }): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TMeta extends Meta> extends ProcedureHandlerOptions<TInContext, TMeta> {
+    next: MiddlewareNextFn<TOutput>;
+}
+/**
+ * A function that represents a middleware.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+ */
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+type DefaultProcedureHandlerOptions = ProcedureHandlerOptions<Context, Meta>;
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TMeta extends Meta> {
+    context: TCurrentContext;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, Schemas, TMeta>;
+    signal?: AbortSignal;
+    request?: StandardLazyRequest;
+    lastEventId: string | undefined;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput extends {
+    path: any;
+    query: any;
+    body: any;
+}, THandlerOutput, TMeta extends Meta> {
+    (input: TInput, opt: ProcedureHandlerOptions<TCurrentContext, TMeta>): Promisable<THandlerOutput>;
+}
+interface ContractDef<TInitialContext extends Context, TSchemas extends Schemas, TMeta extends Meta> {
+    meta: TMeta;
+    route: Route;
+    schemas: TSchemas;
+    middlewares: readonly Middleware<TInitialContext, any, any, any, any>[];
+    authConfigs: TypedAuthConfig[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+}
+type AnyContractDef = ContractDef<Context, Schemas, Meta>;
+declare class Contract<TDef extends AnyContractDef = AnyContractDef> {
+    /**
+     * This property holds the defined options.
+     */
+    '~orpc': TDef;
+    constructor(def: TDef);
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TMeta extends Meta> extends ContractDef<TInitialContext, TSchemas, TMeta> {
+    handler: ProcedureHandler<TCurrentContext, any, any, any>;
+}
+/**
+ * This class represents a procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
+ */
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TMeta extends Meta> extends Contract<ProcedureDef<TInitialContext, TCurrentContext, TSchemas, TMeta>> {
+}
+type AnyProcedure = Procedure<any, any, Schemas, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type ValidatedAuthContext = {};
+interface BasicAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> {
+    tokenPrefix?: string;
+    validate: (username: string, password: string, options: ProcedureHandlerOptions<TCurrentContext, TMeta>) => Promisable<TAuthContext>;
+}
+interface TokenAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> {
+    tokenPrefix?: string;
+    validate: (token: string, options: ProcedureHandlerOptions<TCurrentContext, TMeta>) => Promisable<TAuthContext>;
+}
+interface NamedTokenAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> extends TokenAuthConfig<TAuthContext, TCurrentContext, TMeta> {
+    name: string;
+}
+type AuthType = 'header' | 'query' | 'cookie' | 'bearer' | 'basic' | 'none';
+type AuthConfig<TAuthType extends AuthType, TAuthContext extends ValidatedAuthContext = ValidatedAuthContext, TCurrentContext extends Context = Context, TMeta extends Meta = Meta> = TAuthType extends 'basic' ? BasicAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'bearer' ? TokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'header' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'query' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'cookie' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'none' ? {} : never;
+type TypedAuthConfig<TAuthType extends AuthType = AuthType> = {
+    type: TAuthType;
+} & AuthConfig<TAuthType, object>;
+
+type ContractRouter = Contract | {
+    [k: string]: ContractRouter;
+};
+/**
+ * Represents a router, which defines a hierarchical structure of procedures.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#contract-router Contract Router Docs}
+ */
+type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any> | {
+    [k: string]: Lazyable<Router<TInitialContext>>;
+};
+type AnyRouter = Router<any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer UInitialContext> ? UInitialContext : never;
+/**
+ * Infer all initial context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, 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.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any> ? UCurrentContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
+};
+/**
+ * Infer all router inputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any> ? InferProcedureClientInputs<USchemas> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
+};
+/**
+ * Infer all router outputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any> ? InferSchemaOutput<USchemas['outputSchema']> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
+};
+
+declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
+type AccessibleLazyRouter<T extends Lazyable<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : T extends AnyProcedure | undefined ? Lazy<T> : Lazy<T> & {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? AccessibleLazyRouter<T[K]> : never;
+};
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+type EnhancedRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext>> : T extends Procedure<infer UInitialContext, infer UCurrentContext, infer USchemas, infer UMeta> ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, USchemas, UMeta> : {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? EnhancedRouter<T[K], TInitialContext, TCurrentContext> : never;
+};
+interface EnhanceRouterOptions extends EnhanceRouteOptions {
+    middlewares: readonly AnyMiddleware[];
+    dedupeLeadingMiddlewares: boolean;
+}
+declare function enhanceRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context>(router: T, options: EnhanceRouterOptions): EnhancedRouter<T, TInitialContext, TCurrentContext>;
+interface TraverseContractProceduresOptions {
+    router: ContractRouter | AnyRouter;
+    path: readonly string[];
+}
+interface TraverseContractProcedureCallbackOptions {
+    contract: Contract;
+    path: readonly string[];
+}
+/**
+ * @deprecated Use `TraverseContractProcedureCallbackOptions` instead.
+ */
+type ContractProcedureCallbackOptions = TraverseContractProcedureCallbackOptions;
+interface LazyTraverseContractProceduresOptions {
+    router: Lazy<AnyRouter>;
+    path: readonly string[];
+}
+declare function traverseContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void, lazyOptions?: LazyTraverseContractProceduresOptions[]): LazyTraverseContractProceduresOptions[];
+declare function resolveContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void): Promise<void>;
+type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
+};
+declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
+
+declare const LAZY_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_SYMBOL]: {
+        loader: () => Promise<{
+            default: T;
+        }>;
+        meta: LazyMeta;
+    };
+}
+type Lazyable<T> = T | Lazy<T>;
+/**
+ * @internal
+ */
+declare function lazyInternal<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+/**
+ * Creates a lazy-loaded item.
+ *
+ * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazyRoute(...)` instead.
+ */
+declare function lazy<T extends Router<any>>(prefix: HTTPPath, loader: () => Promise<{
+    default: T;
+}>): EnhancedRouter<Lazy<T>, {}, {}>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+export { traverseContractProcedures as $, isProcedure as H, Procedure as P, getRouter as S, createAccessibleLazyRouter as U, enhanceRouter as W, Contract as a, resolveContractProcedures as a0, unlazyRouter as a2, mergeCurrentContext as m, LAZY_SYMBOL as n, lazyInternal as p, lazy as q, isLazy as r, getLazyMeta as s, unlazy as u, middlewareOutputFn as y };
+export type { AuthType as A, BuildContextWithAuth as B, Context as C, DefaultProcedureHandlerOptions as D, EnhanceRouterOptions as E, AnyContractDef as F, ProcedureDef as G, InferRouterInitialContext as I, ContractRouter as J, InferRouterInitialContexts as K, Lazyable as L, Middleware as M, InferRouterCurrentContexts as N, InferRouterInputs as O, InferRouterOutputs as Q, Router as R, AccessibleLazyRouter as T, ValidatedAuthContext as V, TraverseContractProceduresOptions as X, TraverseContractProcedureCallbackOptions as Y, ContractProcedureCallbackOptions as Z, LazyTraverseContractProceduresOptions as _, UnlaziedRouter as a1, MergedInitialContext as b, MergedCurrentContext as c, AuthConfig as d, ProcedureHandler as e, EnhancedRouter as f, MapInputMiddleware as g, ContractDef as h, AnyMiddleware as i, Lazy as j, AnyProcedure as k, AnyRouter as l, LazyMeta as o, MiddlewareResult as t, MiddlewareNextFn as v, MiddlewareOutputFn as w, MiddlewareOptions as x, ProcedureHandlerOptions as z };

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

@@ -0,0 +1,41 @@
+import { HTTPPath, StandardResponse, StandardLazyRequest } from '@temporary-name/shared';
+import { C as Context, R as Router } from './server.DPD7R7h_.js';
+
+interface StandardHandleOptions<T extends Context> {
+    prefix?: HTTPPath;
+    context: T;
+}
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface StandardHandlerOptions<TContext extends Context> {
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    constructor(router: Router<T>, _options: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
+}
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+/**
+ * {@link https://github.com/unjs/rou3}
+ *
+ * @internal
+ */
+declare function toRou3Pattern(path: HTTPPath): string;
+/**
+ * @internal
+ */
+declare function decodeParams(params: Record<string, string>): Record<string, string>;
+
+export { StandardHandler as c, decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };
+export type { FriendlyStandardHandleOptions as F, StandardHandleOptions as S, StandardHandleResult as a, StandardHandlerOptions as b };

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

@@ -0,0 +1,41 @@
+import { HTTPPath, StandardResponse, StandardLazyRequest } from '@temporary-name/shared';
+import { C as Context, R as Router } from './server.DPD7R7h_.mjs';
+
+interface StandardHandleOptions<T extends Context> {
+    prefix?: HTTPPath;
+    context: T;
+}
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface StandardHandlerOptions<TContext extends Context> {
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    constructor(router: Router<T>, _options: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
+}
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+/**
+ * {@link https://github.com/unjs/rou3}
+ *
+ * @internal
+ */
+declare function toRou3Pattern(path: HTTPPath): string;
+/**
+ * @internal
+ */
+declare function decodeParams(params: Record<string, string>): Record<string, string>;
+
+export { StandardHandler as c, decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };
+export type { FriendlyStandardHandleOptions as F, StandardHandleOptions as S, StandardHandleResult as a, StandardHandlerOptions as b };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@temporary-name/server",
   "type": "module",
-  "version": "1.9.3-alpha.26612c2cf6a7177d2b500d984d282309d8320ca3",
+  "version": "1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827",
   "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,19 @@
   "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.26612c2cf6a7177d2b500d984d282309d8320ca3",
-    "@temporary-name/shared": "1.9.3-alpha.26612c2cf6a7177d2b500d984d282309d8320ca3",
-    "@temporary-name/json-schema": "1.9.3-alpha.26612c2cf6a7177d2b500d984d282309d8320ca3",
-    "@temporary-name/standard-server": "1.9.3-alpha.26612c2cf6a7177d2b500d984d282309d8320ca3",
-    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.26612c2cf6a7177d2b500d984d282309d8320ca3",
-    "@temporary-name/interop": "1.9.3-alpha.26612c2cf6a7177d2b500d984d282309d8320ca3",
-    "@temporary-name/standard-server-fetch": "1.9.3-alpha.26612c2cf6a7177d2b500d984d282309d8320ca3",
-    "@temporary-name/zod": "1.9.3-alpha.26612c2cf6a7177d2b500d984d282309d8320ca3",
-    "@temporary-name/standard-server-node": "1.9.3-alpha.26612c2cf6a7177d2b500d984d282309d8320ca3"
+    "@temporary-name/contract": "1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827",
+    "@temporary-name/interop": "1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827",
+    "@temporary-name/json-schema": "1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827",
+    "@temporary-name/shared": "1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827",
+    "@temporary-name/standard-server": "1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827",
+    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827",
+    "@temporary-name/standard-server-node": "1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827",
+    "@temporary-name/standard-server-fetch": "1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827",
+    "@temporary-name/zod": "1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827"
   },
   "devDependencies": {
     "@types/supertest": "^6.0.3",

package/dist/plugins/index.d.mts

@@ -1,160 +0,0 @@
-import { Value, Promisable, ORPCError } from '@temporary-name/shared';
-import { StandardRequest, StandardHeaders } from '@temporary-name/standard-server';
-import { BatchResponseBodyItem } from '@temporary-name/standard-server/batch';
-import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.BlJrjUA9.mjs';
-import { C as Context, H as ProcedureClientInterceptorOptions } from '../shared/server.WsFQIubj.mjs';
-import { Meta } from '@temporary-name/contract';
-
-interface BatchHandlerOptions<T extends Context> {
-    /**
-     * The max size of the batch allowed.
-     *
-     * @default 10
-     */
-    maxSize?: Value<Promisable<number>, [StandardHandlerInterceptorOptions<T>]>;
-    /**
-     * Map the request before processing it.
-     *
-     * @default merged back batch request headers into the request
-     */
-    mapRequestItem?(request: StandardRequest, batchOptions: StandardHandlerInterceptorOptions<T>): StandardRequest;
-    /**
-     * Success batch response status code.
-     *
-     * @default 207
-     */
-    successStatus?: Value<Promisable<number>, [
-        responses: Promise<BatchResponseBodyItem>[],
-        batchOptions: StandardHandlerInterceptorOptions<T>
-    ]>;
-    /**
-     * success batch response headers.
-     *
-     * @default {}
-     */
-    headers?: Value<Promisable<StandardHeaders>, [
-        responses: Promise<BatchResponseBodyItem>[],
-        batchOptions: StandardHandlerInterceptorOptions<T>
-    ]>;
-}
-/**
- * The Batch Requests Plugin allows you to combine multiple requests and responses into a single batch,
- * reducing the overhead of sending each one separately.
- *
- * @see {@link https://orpc.unnoq.com/docs/plugins/batch-requests Batch Requests Plugin Docs}
- */
-declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    private readonly maxSize;
-    private readonly mapRequestItem;
-    private readonly successStatus;
-    private readonly headers;
-    order: number;
-    constructor(options?: BatchHandlerOptions<T>);
-    init(options: StandardHandlerOptions<T>): void;
-}
-
-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 RequestHeadersPluginContext {
-    reqHeaders?: Headers;
-}
-/**
- * The Request Headers Plugin injects a `reqHeaders` instance into the context,
- * allowing access to request headers in oRPC.
- *
- * @see {@link https://orpc.unnoq.com/docs/plugins/request-headers Request Headers Plugin Docs}
- */
-declare class RequestHeadersPlugin<T extends RequestHeadersPluginContext> implements StandardHandlerPlugin<T> {
-    init(options: StandardHandlerOptions<T>): void;
-}
-
-interface ResponseHeadersPluginContext {
-    resHeaders?: Headers;
-}
-/**
- * The Response Headers Plugin allows you to set response headers in oRPC.
- * It injects a resHeaders instance into the context, enabling you to modify response headers easily.
- *
- * @see {@link https://orpc.unnoq.com/docs/plugins/response-headers Response Headers Plugin Docs}
- */
-declare class ResponseHeadersPlugin<T extends ResponseHeadersPluginContext> implements StandardHandlerPlugin<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 { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
-export type { BatchHandlerOptions, CORSOptions, RequestHeadersPluginContext, ResponseHeadersPluginContext, SimpleCsrfProtectionHandlerPluginOptions };