@temporary-name/server 1.9.3-alpha.4225889dbc4c4adc76cdbabb804a30cd075c9d7a → 1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6

package/dist/plugins/index.d.ts

@@ -1,58 +1,8 @@
 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.C-tNYmY_.js';
-import { C as Context, H as ProcedureClientInterceptorOptions } from '../shared/server.WsFQIubj.js';
+import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.DpoO_ER_.js';
+import { C as Context, G as ProcedureClientInterceptorOptions } from '../shared/server.BL2R5jcp.js';
 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,
@@ -80,32 +30,6 @@ declare class CORSPlugin<T extends Context> implements StandardHandlerPlugin<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.
@@ -156,5 +80,5 @@ declare class SimpleCsrfProtectionHandlerPlugin<T extends Context> implements St
     init(options: StandardHandlerOptions<T>): void;
 }
 
-export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
-export type { BatchHandlerOptions, CORSOptions, RequestHeadersPluginContext, ResponseHeadersPluginContext, SimpleCsrfProtectionHandlerPluginOptions };
+export { CORSPlugin, SimpleCsrfProtectionHandlerPlugin };
+export type { CORSOptions, SimpleCsrfProtectionHandlerPluginOptions };

package/dist/plugins/index.mjs

@@ -1,119 +1,5 @@
-import { runWithSpan, value, setSpanError, isAsyncIteratorObject, AsyncIteratorClass, clone, ORPCError } from '@temporary-name/shared';
-import { flattenHeader } from '@temporary-name/standard-server';
-import { parseBatchRequest, toBatchResponse } from '@temporary-name/standard-server/batch';
-import { toFetchHeaders } from '@temporary-name/standard-server-fetch';
-
-class BatchHandlerPlugin {
-  maxSize;
-  mapRequestItem;
-  successStatus;
-  headers;
-  order = 5e6;
-  constructor(options = {}) {
-    this.maxSize = options.maxSize ?? 10;
-    this.mapRequestItem = options.mapRequestItem ?? ((request, { request: batchRequest }) => ({
-      ...request,
-      headers: {
-        ...batchRequest.headers,
-        ...request.headers
-      }
-    }));
-    this.successStatus = options.successStatus ?? 207;
-    this.headers = options.headers ?? {};
-  }
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.rootInterceptors.unshift(async (options2) => {
-      const xHeader = flattenHeader(options2.request.headers["x-orpc-batch"]);
-      if (xHeader === void 0) {
-        return options2.next();
-      }
-      let isParsing = false;
-      try {
-        return await runWithSpan({ name: "handle_batch_request" }, async (span) => {
-          const mode = xHeader === "buffered" ? "buffered" : "streaming";
-          isParsing = true;
-          const parsed = parseBatchRequest({ ...options2.request, body: await options2.request.body() });
-          isParsing = false;
-          span?.setAttribute("batch.mode", mode);
-          span?.setAttribute("batch.size", parsed.length);
-          const maxSize = await value(this.maxSize, options2);
-          if (parsed.length > maxSize) {
-            const message = "Batch request size exceeds the maximum allowed size";
-            setSpanError(span, message);
-            return {
-              matched: true,
-              response: {
-                status: 413,
-                headers: {},
-                body: message
-              }
-            };
-          }
-          const responses = parsed.map((request, index) => {
-            const mapped = this.mapRequestItem(request, options2);
-            return options2.next({ ...options2, request: { ...mapped, body: () => Promise.resolve(mapped.body) } }).then(({ response: response2, matched }) => {
-              span?.addEvent(`response.${index}.${matched ? "success" : "not_matched"}`);
-              if (matched) {
-                if (response2.body instanceof Blob || response2.body instanceof FormData || isAsyncIteratorObject(response2.body)) {
-                  return {
-                    index,
-                    status: 500,
-                    headers: {},
-                    body: "Batch responses do not support file/blob, or event-iterator. Please call this procedure separately outside of the batch request."
-                  };
-                }
-                return { ...response2, index };
-              }
-              return { index, status: 404, headers: {}, body: "No procedure matched" };
-            }).catch((err) => {
-              Promise.reject(err);
-              return { index, status: 500, headers: {}, body: "Internal server error" };
-            });
-          });
-          await Promise.race(responses);
-          const status = await value(this.successStatus, responses, options2);
-          const headers = await value(this.headers, responses, options2);
-          const promises = [...responses];
-          const response = await toBatchResponse({
-            status,
-            headers,
-            mode,
-            body: new AsyncIteratorClass(
-              async () => {
-                const handling = promises.filter((p) => p !== void 0);
-                if (handling.length <= 0) {
-                  return { done: true, value: void 0 };
-                }
-                const value2 = await Promise.race(handling);
-                promises[value2.index] = void 0;
-                return { done: false, value: value2 };
-              },
-              async () => {
-              }
-            )
-          });
-          return {
-            matched: true,
-            response
-          };
-        });
-      } catch (cause) {
-        if (isParsing) {
-          return {
-            matched: true,
-            response: {
-              status: 400,
-              headers: {},
-              body: "Invalid batch request, this could be caused by a malformed request body or a missing header"
-            }
-          };
-        }
-        throw cause;
-      }
-    });
-  }
-}
+import { value, ORPCError } from '@temporary-name/shared';
+import { maybeSetHeader } from '@temporary-name/standard-server';
 
 class CORSPlugin {
   options;
@@ -132,17 +18,13 @@ class CORSPlugin {
     options.rootInterceptors ??= [];
     options.rootInterceptors.unshift(async (interceptorOptions) => {
       if (interceptorOptions.request.method === "OPTIONS") {
-        const resHeaders = {};
+        const resHeaders = new Headers();
         if (this.options.maxAge !== void 0) {
-          resHeaders["access-control-max-age"] = this.options.maxAge.toString();
-        }
-        if (this.options.allowMethods?.length) {
-          resHeaders["access-control-allow-methods"] = flattenHeader(this.options.allowMethods);
-        }
-        const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers["access-control-request-headers"];
-        if (typeof allowHeaders === "string" || allowHeaders?.length) {
-          resHeaders["access-control-allow-headers"] = flattenHeader(allowHeaders);
+          resHeaders.set("access-control-max-age", this.options.maxAge.toString());
         }
+        maybeSetHeader(resHeaders, "access-control-allow-methods", this.options.allowMethods);
+        const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers.get("access-control-request-headers");
+        maybeSetHeader(resHeaders, "access-control-allow-headers", allowHeaders);
         return {
           matched: true,
           response: {
@@ -159,87 +41,33 @@ class CORSPlugin {
       if (!result.matched) {
         return result;
       }
-      const origin = flattenHeader(interceptorOptions.request.headers.origin) ?? "";
+      const origin = interceptorOptions.request.headers.get("origin") ?? "";
       const allowedOrigin = await value(this.options.origin, origin, interceptorOptions);
       const allowedOriginArr = Array.isArray(allowedOrigin) ? allowedOrigin : [allowedOrigin];
       if (allowedOriginArr.includes("*")) {
-        result.response.headers["access-control-allow-origin"] = "*";
+        result.response.headers.set("access-control-allow-origin", "*");
       } else {
         if (allowedOriginArr.includes(origin)) {
-          result.response.headers["access-control-allow-origin"] = origin;
+          result.response.headers.set("access-control-allow-origin", origin);
         }
-        result.response.headers.vary = interceptorOptions.request.headers.vary ?? "origin";
+        result.response.headers.set("vary", interceptorOptions.request.headers.get("vary") ?? "origin");
       }
       const allowedTimingOrigin = await value(this.options.timingOrigin, origin, interceptorOptions);
       const allowedTimingOriginArr = Array.isArray(allowedTimingOrigin) ? allowedTimingOrigin : [allowedTimingOrigin];
       if (allowedTimingOriginArr.includes("*")) {
-        result.response.headers["timing-allow-origin"] = "*";
+        result.response.headers.set("timing-allow-origin", "*");
       } else if (allowedTimingOriginArr.includes(origin)) {
-        result.response.headers["timing-allow-origin"] = origin;
+        result.response.headers.set("timing-allow-origin", origin);
       }
       if (this.options.credentials) {
-        result.response.headers["access-control-allow-credentials"] = "true";
-      }
-      if (this.options.exposeHeaders?.length) {
-        result.response.headers["access-control-expose-headers"] = flattenHeader(this.options.exposeHeaders);
+        result.response.headers.set("access-control-allow-credentials", "true");
       }
+      maybeSetHeader(result.response.headers, "access-control-expose-headers", this.options.exposeHeaders);
       return result;
     });
   }
 }
 
-class RequestHeadersPlugin {
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.rootInterceptors.push((interceptorOptions) => {
-      const reqHeaders = interceptorOptions.context.reqHeaders ?? toFetchHeaders(interceptorOptions.request.headers);
-      return interceptorOptions.next({
-        ...interceptorOptions,
-        context: {
-          ...interceptorOptions.context,
-          reqHeaders
-        }
-      });
-    });
-  }
-}
-
-class ResponseHeadersPlugin {
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.rootInterceptors.push(async (interceptorOptions) => {
-      const resHeaders = interceptorOptions.context.resHeaders ?? new Headers();
-      const result = await interceptorOptions.next({
-        ...interceptorOptions,
-        context: {
-          ...interceptorOptions.context,
-          resHeaders
-        }
-      });
-      if (!result.matched) {
-        return result;
-      }
-      const responseHeaders = clone(result.response.headers);
-      for (const [key, value] of resHeaders) {
-        if (Array.isArray(responseHeaders[key])) {
-          responseHeaders[key].push(value);
-        } else if (responseHeaders[key] !== void 0) {
-          responseHeaders[key] = [responseHeaders[key], value];
-        } else {
-          responseHeaders[key] = value;
-        }
-      }
-      return {
-        ...result,
-        response: {
-          ...result.response,
-          headers: responseHeaders
-        }
-      };
-    });
-  }
-}
-
 const SIMPLE_CSRF_PROTECTION_CONTEXT_SYMBOL = Symbol("SIMPLE_CSRF_PROTECTION_CONTEXT");
 class SimpleCsrfProtectionHandlerPlugin {
   headerName;
@@ -266,7 +94,7 @@ class SimpleCsrfProtectionHandlerPlugin {
         ...options2,
         context: {
           ...options2.context,
-          [SIMPLE_CSRF_PROTECTION_CONTEXT_SYMBOL]: options2.request.headers[headerName] === headerValue
+          [SIMPLE_CSRF_PROTECTION_CONTEXT_SYMBOL]: options2.request.headers.get(headerName) === headerValue
         }
       });
     });
@@ -285,4 +113,4 @@ class SimpleCsrfProtectionHandlerPlugin {
   }
 }
 
-export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
+export { CORSPlugin, SimpleCsrfProtectionHandlerPlugin };

package/dist/shared/{server.BYnDyuDL.d.mts → server.7aL9gcoU.d.mts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.WsFQIubj.mjs';
-import { c as StandardHandleOptions } from './server.BlJrjUA9.mjs';
+import { C as Context } from './server.BL2R5jcp.mjs';
+import { c as StandardHandleOptions } from './server.D6Qs_UcF.mjs';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.WsFQIubj.d.mts → server.BL2R5jcp.d.mts}

@@ -1,5 +1,5 @@
-import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, AnyContractRouter, ContractProcedure, InferSchemaOutput, EnhanceRouteOptions, MergedErrorMap, AnyContractProcedure, ContractRouter, ErrorFromErrorMap } from '@temporary-name/contract';
-import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, Promisable, HTTPPath, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, Meta, Schemas, ContractProcedureDef, AnyContractRouter, ContractProcedure, InferProcedureClientInputs, InferSchemaOutput, EnhanceRouteOptions, MergedErrorMap, AnyContractProcedure, ContractRouter, AnySchema, ErrorFromErrorMap } from '@temporary-name/contract';
+import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, Promisable, StandardLazyRequest, HTTPPath, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
 
 type Context = Record<PropertyKey, any>;
 type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
@@ -13,19 +13,23 @@ type ORPCErrorConstructorMap<T extends ErrorMap> = {
 };
 declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
 
-interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     context: TCurrentContext;
-    input: TInput;
     path: readonly string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    procedure: Procedure<Context, Context, Schemas, ErrorMap, TMeta>;
     signal?: AbortSignal;
+    request?: StandardLazyRequest;
     lastEventId: string | undefined;
     errors: TErrorConstructorMap;
 }
-interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
+interface ProcedureHandler<TCurrentContext extends Context, TInput extends {
+    path: any;
+    query: any;
+    body: any;
+}, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (input: TInput, opt: ProcedureHandlerOptions<TCurrentContext, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
 }
-interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TSchemas, TErrorMap, TMeta> {
     __initialContext?: (type: TInitialContext) => unknown;
     middlewares: readonly AnyMiddleware[];
     inputValidationIndex: number;
@@ -37,39 +41,30 @@ interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends
  *
  * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
  */
-declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> {
     /**
      * This property holds the defined options.
      */
-    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta>);
 }
-type AnyProcedure = Procedure<any, any, AnySchema, AnySchema, any, any>;
+type AnyProcedure = Procedure<any, any, Schemas, any, any>;
 declare function isProcedure(item: unknown): item is AnyProcedure;
 
 type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
     output: TOutput;
     context: TOutContext;
 }>;
-type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
-    context?: TOutContext;
-} : {
-    context: TOutContext;
-};
 interface MiddlewareNextFn<TOutput> {
-    <U extends Context = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, 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, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
-    context: TInContext;
-    path: readonly string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
-    signal?: AbortSignal;
-    lastEventId: string | undefined;
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> extends ProcedureHandlerOptions<TInContext, TErrorConstructorMap, TMeta> {
     next: MiddlewareNextFn<TOutput>;
-    errors: TErrorConstructorMap;
 }
 /**
  * A function that represents a middleware.
@@ -91,7 +86,7 @@ declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<
  * @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<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
+type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer USchemas, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, USchemas, UErrorMap, UMeta> : {
     [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
 };
 type AnyRouter = Router<any, any>;
@@ -102,7 +97,7 @@ type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infe
  * @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, any, any> ? UInitialContext : {
+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;
 };
 /**
@@ -111,7 +106,7 @@ type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer
  * @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, any, any> ? UCurrentContext : {
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any> ? UCurrentContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
 };
 /**
@@ -120,7 +115,7 @@ type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any,
  * @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 UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any, any> ? InferProcedureClientInputs<USchemas> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
 };
 /**
@@ -129,7 +124,7 @@ type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infe
  * @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, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any, any> ? InferSchemaOutput<USchemas['outputSchema']> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 
@@ -138,7 +133,7 @@ type AccessibleLazyRouter<T extends Lazyable<AnyRouter | undefined>> = T extends
     [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, TErrorMap extends ErrorMap> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext, TErrorMap>> : T extends (Procedure<infer UInitialContext, infer UCurrentContext, infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta>) ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, UInputSchema, UOutputSchema, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+type EnhancedRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext, TErrorMap>> : T extends (Procedure<infer UInitialContext, infer UCurrentContext, infer USchemas, infer UErrorMap, infer UMeta>) ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, USchemas, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
     [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? EnhancedRouter<T[K], TInitialContext, TCurrentContext, TErrorMap> : never;
 };
 interface EnhanceRouterOptions<TErrorMap extends ErrorMap> extends EnhanceRouteOptions {
@@ -203,15 +198,13 @@ declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
     default: T extends Lazy<infer U> ? U : T;
 }>;
 
-type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
-interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    context: TInitialContext;
-    input: unknown;
-    errors: ORPCErrorConstructorMap<TErrorMap>;
-    path: readonly string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
-    signal?: AbortSignal;
-    lastEventId: string | undefined;
+type ProcedureClient<TClientContext extends ClientContext, TSchemas extends Schemas, TErrorMap extends ErrorMap> = Client<TClientContext, InferProcedureClientInputs<TSchemas>, InferSchemaOutput<TSchemas['outputSchema']>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> extends ProcedureHandlerOptions<TInitialContext, ORPCErrorConstructorMap<TErrorMap>, TMeta> {
+    input: {
+        path: unknown;
+        query: unknown;
+        body: unknown;
+    };
 }
 type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
     /**
@@ -229,7 +222,7 @@ type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema
  *
  * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
  */
-declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+declare function createProcedureClient<TInitialContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TSchemas, TErrorMap, TMeta>>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TSchemas['outputSchema'], TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TSchemas, TErrorMap>;
 
-export { traverseContractProcedures as $, middlewareOutputFn as B, isProcedure as G, createProcedureClient as J, Procedure as P, getRouter as T, createAccessibleLazyRouter as V, enhanceRouter as W, resolveContractProcedures as a0, unlazyRouter as a2, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, lazyInternal as q, lazy as r, isLazy as s, getLazyMeta as t, unlazy as u };
-export type { AnyMiddleware as A, Context as C, ProcedureHandlerOptions as D, EnhanceRouterOptions as E, ProcedureDef as F, ProcedureClientInterceptorOptions as H, InferRouterInitialContext as I, InferRouterInitialContexts as K, Lazy as L, Middleware as M, InferRouterCurrentContexts as N, ORPCErrorConstructorMap as O, InferRouterInputs as Q, Router as R, InferRouterOutputs as S, AccessibleLazyRouter as U, TraverseContractProceduresOptions as X, TraverseContractProcedureCallbackOptions as Y, ContractProcedureCallbackOptions as Z, LazyTraverseContractProceduresOptions as _, CreateProcedureClientOptions as a, UnlaziedRouter as a1, ProcedureClient as b, MergedInitialContext as c, MergedCurrentContext as d, ProcedureHandler as e, EnhancedRouter as f, MapInputMiddleware as g, AnyProcedure as h, Lazyable as i, AnyRouter as j, ORPCErrorConstructorMapItemOptions as k, ORPCErrorConstructorMapItem as l, LazyMeta as p, MiddlewareResult as v, MiddlewareNextFnOptions as w, MiddlewareNextFn as x, MiddlewareOutputFn as y, MiddlewareOptions as z };
+export { resolveContractProcedures as $, isProcedure as F, createProcedureClient as H, Procedure as P, getRouter as S, createAccessibleLazyRouter as U, enhanceRouter as V, traverseContractProcedures as _, unlazyRouter as a1, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, lazyInternal as q, lazy as r, isLazy as s, getLazyMeta as t, unlazy as u, middlewareOutputFn as z };
+export type { AnyMiddleware as A, ProcedureHandlerOptions as B, Context as C, ProcedureDef as D, EnhanceRouterOptions as E, ProcedureClientInterceptorOptions as G, InferRouterInitialContext as I, InferRouterInitialContexts as J, InferRouterCurrentContexts as K, Lazy as L, Middleware as M, InferRouterInputs as N, ORPCErrorConstructorMap as O, InferRouterOutputs as Q, Router as R, AccessibleLazyRouter as T, TraverseContractProceduresOptions as W, TraverseContractProcedureCallbackOptions as X, ContractProcedureCallbackOptions as Y, LazyTraverseContractProceduresOptions as Z, CreateProcedureClientOptions as a, UnlaziedRouter as a0, ProcedureClient as b, MergedInitialContext as c, MergedCurrentContext as d, ProcedureHandler as e, EnhancedRouter as f, MapInputMiddleware as g, AnyProcedure as h, Lazyable as i, AnyRouter as j, ORPCErrorConstructorMapItemOptions as k, ORPCErrorConstructorMapItem as l, LazyMeta as p, MiddlewareResult as v, MiddlewareNextFn as w, MiddlewareOutputFn as x, MiddlewareOptions as y };