@tanstack/start-client-core 1.132.0-alpha.9 → 1.132.0

package/dist/esm/{serializer → client}/ServerFunctionSerializationAdapter.js

@@ -1,10 +1,10 @@
 import { createSerializationAdapter } from "@tanstack/router-core";
-import { createClientRpc } from "../createClientRpc.js";
 import { TSS_SERVER_FUNCTION } from "../constants.js";
+import { createClientRpc } from "./createClientRpc.js";
 const ServerFunctionSerializationAdapter = createSerializationAdapter({
   key: "$TSS/serverfn",
   test: (v) => {
-    if (typeof v !== "object" || v === null) return false;
+    if (typeof v !== "function") return false;
     if (!(TSS_SERVER_FUNCTION in v)) return false;
     return !!v[TSS_SERVER_FUNCTION];
   },

package/dist/esm/client/ServerFunctionSerializationAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerFunctionSerializationAdapter.js","sources":["../../../src/client/ServerFunctionSerializationAdapter.ts"],"sourcesContent":["import { createSerializationAdapter } from '@tanstack/router-core'\nimport { TSS_SERVER_FUNCTION } from '../constants'\nimport { createClientRpc } from './createClientRpc'\n\nexport const ServerFunctionSerializationAdapter = createSerializationAdapter({\n  key: '$TSS/serverfn',\n  test: (v): v is { functionId: string } => {\n    if (typeof v !== 'function') return false\n\n    if (!(TSS_SERVER_FUNCTION in v)) return false\n\n    return !!v[TSS_SERVER_FUNCTION]\n  },\n  toSerializable: ({ functionId }) => ({ functionId }),\n  fromSerializable: ({ functionId }) => createClientRpc(functionId),\n})\n"],"names":[],"mappings":";;;AAIO,MAAM,qCAAqC,2BAA2B;AAAA,EAC3E,KAAK;AAAA,EACL,MAAM,CAAC,MAAmC;AACxC,QAAI,OAAO,MAAM,WAAY,QAAO;AAEpC,QAAI,EAAE,uBAAuB,GAAI,QAAO;AAExC,WAAO,CAAC,CAAC,EAAE,mBAAmB;AAAA,EAChC;AAAA,EACA,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,WAAA;AAAA,EACvC,kBAAkB,CAAC,EAAE,WAAA,MAAiB,gBAAgB,UAAU;AAClE,CAAC;"}

package/dist/esm/client/createClientRpc.d.ts

@@ -0,0 +1,6 @@
+import { TSS_SERVER_FUNCTION } from '../constants.js';
+export declare function createClientRpc(functionId: string): ((...args: Array<any>) => Promise<any>) & {
+    url: string;
+    functionId: string;
+    [TSS_SERVER_FUNCTION]: boolean;
+};

package/dist/esm/{createClientRpc.js → client/createClientRpc.js}

@@ -1,10 +1,10 @@
-import { TSS_SERVER_FUNCTION } from "./constants.js";
+import { TSS_SERVER_FUNCTION } from "../constants.js";
 import { serverFnFetcher } from "./serverFnFetcher.js";
-let baseUrl;
+var baseUrl;
 function sanitizeBase(base) {
   return base.replace(/^\/|\/$/g, "");
 }
-const createClientRpc = (functionId) => {
+function createClientRpc(functionId) {
   if (!baseUrl) {
     const sanitizedAppBase = sanitizeBase(process.env.TSS_APP_BASE || "/");
     const sanitizedServerBase = sanitizeBase(process.env.TSS_SERVER_FN_BASE);
@@ -19,7 +19,7 @@ const createClientRpc = (functionId) => {
     functionId,
     [TSS_SERVER_FUNCTION]: true
   });
-};
+}
 export {
   createClientRpc
 };

package/dist/esm/client/createClientRpc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createClientRpc.js","sources":["../../../src/client/createClientRpc.ts"],"sourcesContent":["import { TSS_SERVER_FUNCTION } from '../constants'\nimport { serverFnFetcher } from './serverFnFetcher'\n\n// make sure this get's hoisted\n// eslint-disable-next-line no-var\nvar baseUrl: string\nfunction sanitizeBase(base: string) {\n  return base.replace(/^\\/|\\/$/g, '')\n}\n\nexport function createClientRpc(functionId: string) {\n  if (!baseUrl) {\n    const sanitizedAppBase = sanitizeBase(process.env.TSS_APP_BASE || '/')\n    const sanitizedServerBase = sanitizeBase(process.env.TSS_SERVER_FN_BASE!)\n    baseUrl = `${sanitizedAppBase ? `/${sanitizedAppBase}` : ''}/${sanitizedServerBase}/`\n  }\n  const url = baseUrl + functionId\n\n  const clientFn = (...args: Array<any>) => {\n    return serverFnFetcher(url, args, fetch)\n  }\n\n  return Object.assign(clientFn, {\n    url,\n    functionId,\n    [TSS_SERVER_FUNCTION]: true,\n  })\n}\n"],"names":[],"mappings":";;AAKA,IAAI;AACJ,SAAS,aAAa,MAAc;AAClC,SAAO,KAAK,QAAQ,YAAY,EAAE;AACpC;AAEO,SAAS,gBAAgB,YAAoB;AAClD,MAAI,CAAC,SAAS;AACZ,UAAM,mBAAmB,aAAa,QAAQ,IAAI,gBAAgB,GAAG;AACrE,UAAM,sBAAsB,aAAa,QAAQ,IAAI,kBAAmB;AACxE,cAAU,GAAG,mBAAmB,IAAI,gBAAgB,KAAK,EAAE,IAAI,mBAAmB;AAAA,EACpF;AACA,QAAM,MAAM,UAAU;AAEtB,QAAM,WAAW,IAAI,SAAqB;AACxC,WAAO,gBAAgB,KAAK,MAAM,KAAK;AAAA,EACzC;AAEA,SAAO,OAAO,OAAO,UAAU;AAAA,IAC7B;AAAA,IACA;AAAA,IACA,CAAC,mBAAmB,GAAG;AAAA,EAAA,CACxB;AACH;"}

package/dist/esm/client/hydrateStart.d.ts

@@ -0,0 +1,2 @@
+import { AnyRouter } from '@tanstack/router-core';
+export declare function hydrateStart(): Promise<AnyRouter>;

package/dist/esm/client/hydrateStart.js

@@ -0,0 +1,29 @@
+import { hydrate } from "@tanstack/router-core/ssr/client";
+import { ServerFunctionSerializationAdapter } from "./ServerFunctionSerializationAdapter.js";
+import * as startEntry from "#tanstack-start-entry";
+import { getRouter } from "#tanstack-router-entry";
+async function hydrateStart() {
+  const router = await getRouter();
+  let serializationAdapters;
+  if (startEntry.startInstance) {
+    const startOptions = await startEntry.startInstance.getOptions();
+    window.__TSS_START_OPTIONS__ = startOptions;
+    serializationAdapters = startOptions.serializationAdapters;
+    router.options.defaultSsr = startOptions.defaultSsr;
+  } else {
+    serializationAdapters = [];
+    window.__TSS_START_OPTIONS__ = {
+      serializationAdapters
+    };
+  }
+  serializationAdapters.push(ServerFunctionSerializationAdapter);
+  router.options.serializationAdapters = serializationAdapters;
+  if (!router.state.matches.length) {
+    await hydrate(router);
+  }
+  return router;
+}
+export {
+  hydrateStart
+};
+//# sourceMappingURL=hydrateStart.js.map

package/dist/esm/client/hydrateStart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrateStart.js","sources":["../../../src/client/hydrateStart.ts"],"sourcesContent":["import { hydrate } from '@tanstack/router-core/ssr/client'\n\nimport { ServerFunctionSerializationAdapter } from './ServerFunctionSerializationAdapter'\nimport type { AnyStartInstanceOptions } from '../createStart'\nimport type { AnyRouter, AnySerializationAdapter } from '@tanstack/router-core'\nimport * as startEntry from '#tanstack-start-entry'\nimport { getRouter } from '#tanstack-router-entry'\n\nexport async function hydrateStart(): Promise<AnyRouter> {\n  const router = await getRouter()\n\n  let serializationAdapters: Array<AnySerializationAdapter>\n  if (startEntry.startInstance) {\n    const startOptions = await startEntry.startInstance.getOptions()\n    window.__TSS_START_OPTIONS__ = startOptions as AnyStartInstanceOptions\n    serializationAdapters = startOptions.serializationAdapters\n    router.options.defaultSsr = startOptions.defaultSsr\n  } else {\n    serializationAdapters = []\n    window.__TSS_START_OPTIONS__ = {\n      serializationAdapters,\n    } as AnyStartInstanceOptions\n  }\n\n  serializationAdapters.push(ServerFunctionSerializationAdapter)\n  router.options.serializationAdapters = serializationAdapters\n\n  if (!router.state.matches.length) {\n    await hydrate(router)\n  }\n\n  return router\n}\n"],"names":[],"mappings":";;;;AAQA,eAAsB,eAAmC;AACvD,QAAM,SAAS,MAAM,UAAA;AAErB,MAAI;AACJ,MAAI,WAAW,eAAe;AAC5B,UAAM,eAAe,MAAM,WAAW,cAAc,WAAA;AACpD,WAAO,wBAAwB;AAC/B,4BAAwB,aAAa;AACrC,WAAO,QAAQ,aAAa,aAAa;AAAA,EAC3C,OAAO;AACL,4BAAwB,CAAA;AACxB,WAAO,wBAAwB;AAAA,MAC7B;AAAA,IAAA;AAAA,EAEJ;AAEA,wBAAsB,KAAK,kCAAkC;AAC7D,SAAO,QAAQ,wBAAwB;AAEvC,MAAI,CAAC,OAAO,MAAM,QAAQ,QAAQ;AAChC,UAAM,QAAQ,MAAM;AAAA,EACtB;AAEA,SAAO;AACT;"}

package/dist/esm/client/index.d.ts

@@ -0,0 +1,2 @@
+export { createClientRpc } from './createClientRpc.js';
+export { hydrateStart } from './hydrateStart.js';

package/dist/esm/client/index.js

@@ -0,0 +1,7 @@
+import { createClientRpc } from "./createClientRpc.js";
+import { hydrateStart } from "./hydrateStart.js";
+export {
+  createClientRpc,
+  hydrateStart
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/esm/{serverFnFetcher.js → client/serverFnFetcher.js}

@@ -1,12 +1,12 @@
 import { isPlainObject, encode, parseRedirect, isNotFound } from "@tanstack/router-core";
 import { fromCrossJSON, toJSONAsync } from "seroval";
 import invariant from "tiny-invariant";
-import { getClientSerovalPlugins } from "./serializer/getClientSerovalPlugins.js";
-import { X_TSS_SERIALIZED, TSS_FORMDATA_CONTEXT } from "./constants.js";
+import { getDefaultSerovalPlugins } from "../getDefaultSerovalPlugins.js";
+import { X_TSS_SERIALIZED, TSS_FORMDATA_CONTEXT } from "../constants.js";
 let serovalPlugins = null;
 async function serverFnFetcher(url, args, handler) {
   if (!serovalPlugins) {
-    serovalPlugins = getClientSerovalPlugins();
+    serovalPlugins = getDefaultSerovalPlugins();
   }
   const _first = args[0];
   if (isPlainObject(_first) && _first.method) {
@@ -21,6 +21,9 @@ async function serverFnFetcher(url, args, handler) {
       ...first.headers instanceof Headers ? Object.fromEntries(first.headers.entries()) : first.headers
     });
     if (first.method === "GET") {
+      if (type === "formData") {
+        throw new Error("FormData is not supported with GET requests");
+      }
       const encodedPayload = encode({
         payload: await serializePayload(first)
       });
@@ -37,9 +40,6 @@ async function serverFnFetcher(url, args, handler) {
     } else {
       url += `?createServerFn`;
     }
-    if (first.response === "raw") {
-      url += `&raw`;
-    }
     return await getResponse(
       async () => handler(url, {
         method: first.method,

package/dist/esm/client/serverFnFetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverFnFetcher.js","sources":["../../../src/client/serverFnFetcher.ts"],"sourcesContent":["import {\n  encode,\n  isNotFound,\n  isPlainObject,\n  parseRedirect,\n} from '@tanstack/router-core'\nimport { fromCrossJSON, toJSONAsync } from 'seroval'\nimport invariant from 'tiny-invariant'\nimport { getDefaultSerovalPlugins } from '../getDefaultSerovalPlugins'\nimport { TSS_FORMDATA_CONTEXT, X_TSS_SERIALIZED } from '../constants'\nimport type { FunctionMiddlewareClientFnOptions } from '../createMiddleware'\nimport type { Plugin as SerovalPlugin } from 'seroval'\n\nlet serovalPlugins: Array<SerovalPlugin<any, any>> | null = null\n\nexport async function serverFnFetcher(\n  url: string,\n  args: Array<any>,\n  handler: (url: string, requestInit: RequestInit) => Promise<Response>,\n) {\n  if (!serovalPlugins) {\n    serovalPlugins = getDefaultSerovalPlugins()\n  }\n  const _first = args[0]\n\n  // If createServerFn was used to wrap the fetcher,\n  // We need to handle the arguments differently\n  if (isPlainObject(_first) && _first.method) {\n    const first = _first as FunctionMiddlewareClientFnOptions<any, any, any> & {\n      headers: HeadersInit\n    }\n    const type = first.data instanceof FormData ? 'formData' : 'payload'\n\n    // Arrange the headers\n    const headers = new Headers({\n      'x-tsr-redirect': 'manual',\n      ...(type === 'payload'\n        ? {\n            'content-type': 'application/json',\n            accept: 'application/x-ndjson, application/json',\n          }\n        : {}),\n      ...(first.headers instanceof Headers\n        ? Object.fromEntries(first.headers.entries())\n        : first.headers),\n    })\n\n    // If the method is GET, we need to move the payload to the query string\n    if (first.method === 'GET') {\n      if (type === 'formData') {\n        throw new Error('FormData is not supported with GET requests')\n      }\n      const encodedPayload = encode({\n        payload: await serializePayload(first),\n      })\n\n      if (encodedPayload) {\n        if (url.includes('?')) {\n          url += `&${encodedPayload}`\n        } else {\n          url += `?${encodedPayload}`\n        }\n      }\n    }\n\n    if (url.includes('?')) {\n      url += `&createServerFn`\n    } else {\n      url += `?createServerFn`\n    }\n\n    return await getResponse(async () =>\n      handler(url, {\n        method: first.method,\n        headers,\n        signal: first.signal,\n        ...(await getFetcherRequestOptions(first)),\n      }),\n    )\n  }\n\n  // If not a custom fetcher, it was probably\n  // a `use server` function, so just proxy the arguments\n  // through as a POST request\n  return await getResponse(() =>\n    handler(url, {\n      method: 'POST',\n      headers: {\n        Accept: 'application/json',\n        'Content-Type': 'application/json',\n      },\n      body: JSON.stringify(args),\n    }),\n  )\n}\n\nasync function serializePayload(\n  opts: FunctionMiddlewareClientFnOptions<any, any, any>,\n) {\n  const payloadToSerialize: any = {}\n  if (opts.data) {\n    payloadToSerialize['data'] = opts.data\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if (opts.context && Object.keys(opts.context).length > 0) {\n    payloadToSerialize['context'] = opts.context\n  }\n\n  return serialize(payloadToSerialize)\n}\n\nasync function serialize(data: any) {\n  return JSON.stringify(\n    await Promise.resolve(toJSONAsync(data, { plugins: serovalPlugins! })),\n  )\n}\n\nasync function getFetcherRequestOptions(\n  opts: FunctionMiddlewareClientFnOptions<any, any, any>,\n) {\n  if (opts.method === 'POST') {\n    if (opts.data instanceof FormData) {\n      opts.data.set(TSS_FORMDATA_CONTEXT, await serialize(opts.context))\n      return {\n        body: opts.data,\n      }\n    }\n\n    return {\n      body: await serializePayload(opts),\n    }\n  }\n\n  return {}\n}\n\n/**\n * Retrieves a response from a given function and manages potential errors\n * and special response types including redirects and not found errors.\n *\n * @param fn - The function to execute for obtaining the response.\n * @returns The processed response from the function.\n * @throws If the response is invalid or an error occurs during processing.\n */\nasync function getResponse(fn: () => Promise<Response>) {\n  const response = await (async () => {\n    try {\n      return await fn()\n    } catch (error) {\n      if (error instanceof Response) {\n        return error\n      }\n\n      throw error\n    }\n  })()\n\n  const contentType = response.headers.get('content-type')\n  invariant(contentType, 'expected content-type header to be set')\n  const serializedByStart = !!response.headers.get(X_TSS_SERIALIZED)\n  // If the response is not ok, throw an error\n  if (!response.ok) {\n    if (serializedByStart && contentType.includes('application/json')) {\n      const jsonPayload = await response.json()\n      const result = fromCrossJSON(jsonPayload, { plugins: serovalPlugins! })\n      throw result\n    }\n\n    throw new Error(await response.text())\n  }\n\n  if (serializedByStart) {\n    let result\n    if (contentType.includes('application/x-ndjson')) {\n      const refs = new Map()\n      result = await processServerFnResponse({\n        response,\n        onMessage: (msg) =>\n          fromCrossJSON(msg, { refs, plugins: serovalPlugins! }),\n        onError(msg, error) {\n          // TODO how could we notify consumer that an error occurred?\n          console.error(msg, error)\n        },\n      })\n    }\n    if (contentType.includes('application/json')) {\n      const jsonPayload = await response.json()\n      result = fromCrossJSON(jsonPayload, { plugins: serovalPlugins! })\n    }\n    invariant(result, 'expected result to be resolved')\n    if (result instanceof Error) {\n      throw result\n    }\n    return result\n  }\n\n  if (contentType.includes('application/json')) {\n    const jsonPayload = await response.json()\n    const redirect = parseRedirect(jsonPayload)\n    if (redirect) {\n      throw redirect\n    }\n    if (isNotFound(jsonPayload)) {\n      throw jsonPayload\n    }\n    return jsonPayload\n  }\n\n  return response\n}\n\nasync function processServerFnResponse({\n  response,\n  onMessage,\n  onError,\n}: {\n  response: Response\n  onMessage: (msg: any) => any\n  onError?: (msg: string, error?: any) => void\n}) {\n  if (!response.body) {\n    throw new Error('No response body')\n  }\n\n  const reader = response.body.pipeThrough(new TextDecoderStream()).getReader()\n\n  let buffer = ''\n  let firstRead = false\n  let firstObject\n\n  while (!firstRead) {\n    const { value, done } = await reader.read()\n    if (value) buffer += value\n\n    if (buffer.length === 0 && done) {\n      throw new Error('Stream ended before first object')\n    }\n\n    // common case: buffer ends with newline\n    if (buffer.endsWith('\\n')) {\n      const lines = buffer.split('\\n').filter(Boolean)\n      const firstLine = lines[0]\n      if (!firstLine) throw new Error('No JSON line in the first chunk')\n      firstObject = JSON.parse(firstLine)\n      firstRead = true\n      buffer = lines.slice(1).join('\\n')\n    } else {\n      // fallback: wait for a newline to parse first object safely\n      const newlineIndex = buffer.indexOf('\\n')\n      if (newlineIndex >= 0) {\n        const line = buffer.slice(0, newlineIndex).trim()\n        buffer = buffer.slice(newlineIndex + 1)\n        if (line.length > 0) {\n          firstObject = JSON.parse(line)\n          firstRead = true\n        }\n      }\n    }\n  }\n\n  // process rest of the stream asynchronously\n  ;(async () => {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      while (true) {\n        const { value, done } = await reader.read()\n        if (value) buffer += value\n\n        const lastNewline = buffer.lastIndexOf('\\n')\n        if (lastNewline >= 0) {\n          const chunk = buffer.slice(0, lastNewline)\n          buffer = buffer.slice(lastNewline + 1)\n          const lines = chunk.split('\\n').filter(Boolean)\n\n          for (const line of lines) {\n            try {\n              onMessage(JSON.parse(line))\n            } catch (e) {\n              onError?.(`Invalid JSON line: ${line}`, e)\n            }\n          }\n        }\n\n        if (done) {\n          break\n        }\n      }\n    } catch (err) {\n      onError?.('Stream processing error:', err)\n    }\n  })()\n\n  return onMessage(firstObject)\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/constants.d.ts

@@ -1,4 +1,5 @@
 export declare const TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
 export declare const TSS_SERVER_FUNCTION: unique symbol;
+export declare const TSS_SERVER_FUNCTION_FACTORY: unique symbol;
 export declare const X_TSS_SERIALIZED = "x-tss-serialized";
 export {};

package/dist/esm/constants.js

@@ -1,9 +1,13 @@
 const TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
 const TSS_SERVER_FUNCTION = Symbol.for("TSS_SERVER_FUNCTION");
+const TSS_SERVER_FUNCTION_FACTORY = Symbol.for(
+  "TSS_SERVER_FUNCTION_FACTORY"
+);
 const X_TSS_SERIALIZED = "x-tss-serialized";
 export {
   TSS_FORMDATA_CONTEXT,
   TSS_SERVER_FUNCTION,
+  TSS_SERVER_FUNCTION_FACTORY,
   X_TSS_SERIALIZED
 };
 //# sourceMappingURL=constants.js.map

package/dist/esm/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sources":["../../src/constants.ts"],"sourcesContent":["export const TSS_FORMDATA_CONTEXT = '__TSS_CONTEXT'\nexport const TSS_SERVER_FUNCTION = Symbol.for('TSS_SERVER_FUNCTION')\n\nexport const X_TSS_SERIALIZED = 'x-tss-serialized'\nexport {}\n"],"names":[],"mappings":"AAAO,MAAM,uBAAuB;AAC7B,MAAM,sBAAsB,OAAO,IAAI,qBAAqB;AAE5D,MAAM,mBAAmB;"}
+{"version":3,"file":"constants.js","sources":["../../src/constants.ts"],"sourcesContent":["export const TSS_FORMDATA_CONTEXT = '__TSS_CONTEXT'\nexport const TSS_SERVER_FUNCTION = Symbol.for('TSS_SERVER_FUNCTION')\nexport const TSS_SERVER_FUNCTION_FACTORY = Symbol.for(\n  'TSS_SERVER_FUNCTION_FACTORY',\n)\n\nexport const X_TSS_SERIALIZED = 'x-tss-serialized'\nexport {}\n"],"names":[],"mappings":"AAAO,MAAM,uBAAuB;AAC7B,MAAM,sBAAsB,OAAO,IAAI,qBAAqB;AAC5D,MAAM,8BAA8B,OAAO;AAAA,EAChD;AACF;AAEO,MAAM,mBAAmB;"}

package/dist/esm/createMiddleware.d.ts

@@ -1,125 +1,128 @@
-import { ConstrainValidator, Method, ServerFnResponseType } from './createServerFn.js';
-import { AnyRouter, Assign, Constrain, Expand, IntersectAssign, Register, RegisteredRouter, ResolveValidatorInput, ResolveValidatorOutput, ValidateSerializableInput } from '@tanstack/router-core';
-export declare function createMiddleware<TRegister extends Register, TType extends MiddlewareType>(options: {
-    type: TType;
-    validateClient?: boolean;
-}, __opts?: FunctionMiddlewareOptions<TRegister, unknown, undefined, undefined, undefined, ServerFnResponseType>): CreateMiddlewareResult<TRegister, TType>;
+import { StartInstanceOptions } from './createStart.js';
+import { AnyServerFn, ConstrainValidator, Method } from './createServerFn.js';
+import { AnyContext, Assign, Constrain, Expand, IntersectAssign, Register, ResolveValidatorInput, ResolveValidatorOutput, ValidateSerializableInput } from '@tanstack/router-core';
+export type CreateMiddlewareFn<TRegister> = <TType extends MiddlewareType>(options?: {
+    type?: TType;
+}, __opts?: FunctionMiddlewareOptions<TRegister, unknown, undefined, undefined, undefined>) => CreateMiddlewareResult<TRegister, TType>;
+export declare const createMiddleware: CreateMiddlewareFn<{}>;
 export type MiddlewareType = 'request' | 'function';
-export type CreateMiddlewareResult<TRegister extends Register, TType extends MiddlewareType> = 'function' extends TType ? FunctionMiddleware<TRegister, ServerFnResponseType> : RequestMiddleware;
-export interface FunctionMiddleware<TRegister extends Register, TServerFnResponseType extends ServerFnResponseType> extends FunctionMiddlewareAfterMiddleware<TRegister, unknown, TServerFnResponseType> {
-    middleware: <const TNewMiddlewares = undefined>(middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyFunctionMiddleware>>) => FunctionMiddlewareAfterMiddleware<TRegister, TNewMiddlewares, TServerFnResponseType>;
+export type CreateMiddlewareResult<TRegister, TType extends MiddlewareType> = 'request' extends TType ? RequestMiddleware<TRegister> : FunctionMiddleware<TRegister>;
+export interface FunctionMiddleware<TRegister> extends FunctionMiddlewareAfterMiddleware<TRegister, unknown> {
+    middleware: <const TNewMiddlewares = undefined>(middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyRequestMiddleware | AnyFunctionMiddleware>>) => FunctionMiddlewareAfterMiddleware<TRegister, TNewMiddlewares>;
 }
-export interface FunctionMiddlewareAfterMiddleware<TRegister extends Register, TMiddlewares, TServerFnResponseType extends ServerFnResponseType> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, undefined, undefined, undefined, undefined, undefined, TServerFnResponseType>, FunctionMiddlewareServer<TRegister, TMiddlewares, undefined, undefined, undefined, TServerFnResponseType>, FunctionMiddlewareClient<TRegister, TMiddlewares, undefined, TServerFnResponseType>, FunctionMiddlewareValidator<TRegister, TMiddlewares, TServerFnResponseType> {
+export interface FunctionMiddlewareAfterMiddleware<TRegister, TMiddlewares> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, undefined, undefined, undefined, undefined, undefined>, FunctionMiddlewareServer<TRegister, TMiddlewares, undefined, undefined, undefined>, FunctionMiddlewareClient<TRegister, TMiddlewares, undefined>, FunctionMiddlewareValidator<TRegister, TMiddlewares> {
 }
-export interface FunctionMiddlewareWithTypes<TRegister extends Register, TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext, TServerFnResponseType extends ServerFnResponseType> {
-    _types: FunctionMiddlewareTypes<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext>;
-    options: FunctionMiddlewareOptions<TRegister, TMiddlewares, TValidator, TServerContext, TClientContext, TServerFnResponseType>;
+export interface FunctionMiddlewareWithTypes<TRegister, TMiddlewares, TInputValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext> {
+    _types: FunctionMiddlewareTypes<TRegister, TMiddlewares, TInputValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext>;
+    options: FunctionMiddlewareOptions<TRegister, TMiddlewares, TInputValidator, TServerContext, TClientContext>;
 }
-export interface FunctionMiddlewareTypes<in out TMiddlewares, in out TValidator, in out TServerContext, in out TServerSendContext, in out TClientContext, in out TClientSendContext> {
+export interface FunctionMiddlewareTypes<in out TRegister, in out TMiddlewares, in out TInputValidator, in out TServerContext, in out TServerSendContext, in out TClientContext, in out TClientSendContext> {
     type: 'function';
     middlewares: TMiddlewares;
-    input: ResolveValidatorInput<TValidator>;
-    allInput: IntersectAllValidatorInputs<TMiddlewares, TValidator>;
-    output: ResolveValidatorOutput<TValidator>;
-    allOutput: IntersectAllValidatorOutputs<TMiddlewares, TValidator>;
+    input: ResolveValidatorInput<TInputValidator>;
+    allInput: IntersectAllValidatorInputs<TMiddlewares, TInputValidator>;
+    output: ResolveValidatorOutput<TInputValidator>;
+    allOutput: IntersectAllValidatorOutputs<TMiddlewares, TInputValidator>;
     clientContext: TClientContext;
     allClientContextBeforeNext: AssignAllClientContextBeforeNext<TMiddlewares, TClientContext>;
     allClientContextAfterNext: AssignAllClientContextAfterNext<TMiddlewares, TClientContext, TClientSendContext>;
     serverContext: TServerContext;
     serverSendContext: TServerSendContext;
     allServerSendContext: AssignAllServerSendContext<TMiddlewares, TServerSendContext>;
-    allServerContext: AssignAllServerContext<TMiddlewares, TServerSendContext, TServerContext>;
+    allServerContext: AssignAllServerFnContext<TRegister, TMiddlewares, TServerSendContext, TServerContext>;
     clientSendContext: TClientSendContext;
     allClientSendContext: AssignAllClientSendContext<TMiddlewares, TClientSendContext>;
-    validator: TValidator;
+    inputValidator: TInputValidator;
 }
 /**
  * Recursively resolve the input type produced by a sequence of middleware
  */
-export type IntersectAllValidatorInputs<TMiddlewares, TValidator> = unknown extends TValidator ? TValidator : TValidator extends undefined ? IntersectAllMiddleware<TMiddlewares, 'allInput'> : IntersectAssign<IntersectAllMiddleware<TMiddlewares, 'allInput'>, ResolveValidatorInput<TValidator>>;
-export type IntersectAllMiddleware<TMiddlewares, TType extends keyof AnyFunctionMiddleware['_types'] | keyof AnyRequestMiddleware['_types'], TAcc = undefined> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware ? IntersectAllMiddleware<TRest, TType, IntersectAssign<TAcc, TMiddleware['_types'][TType & keyof TMiddleware['_types']]>> : TAcc : TAcc;
-export type AnyFunctionMiddleware = FunctionMiddlewareWithTypes<any, any, any, any, any, any, any, any>;
+export type IntersectAllValidatorInputs<TMiddlewares, TInputValidator> = unknown extends TInputValidator ? TInputValidator : TInputValidator extends undefined ? IntersectAllMiddleware<TMiddlewares, 'allInput'> : IntersectAssign<IntersectAllMiddleware<TMiddlewares, 'allInput'>, ResolveValidatorInput<TInputValidator>>;
+export type IntersectAllMiddleware<TMiddlewares, TType extends keyof AnyFunctionMiddleware['_types'] | keyof AnyRequestMiddleware['_types'] | keyof AnyServerFn['_types'], TAcc = undefined> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware | AnyServerFn ? IntersectAllMiddleware<TRest, TType, IntersectAssign<TAcc, TMiddleware['_types'][TType & keyof TMiddleware['_types']]>> : TAcc : TAcc;
+export type AnyFunctionMiddleware = FunctionMiddlewareWithTypes<any, any, any, any, any, any, any>;
 /**
  * Recursively merge the output type produced by a sequence of middleware
  */
-export type IntersectAllValidatorOutputs<TMiddlewares, TValidator> = unknown extends TValidator ? TValidator : TValidator extends undefined ? IntersectAllMiddleware<TMiddlewares, 'allOutput'> : IntersectAssign<IntersectAllMiddleware<TMiddlewares, 'allOutput'>, ResolveValidatorOutput<TValidator>>;
+export type IntersectAllValidatorOutputs<TMiddlewares, TInputValidator> = unknown extends TInputValidator ? TInputValidator : TInputValidator extends undefined ? IntersectAllMiddleware<TMiddlewares, 'allOutput'> : IntersectAssign<IntersectAllMiddleware<TMiddlewares, 'allOutput'>, ResolveValidatorOutput<TInputValidator>>;
 /**
  * Recursively resolve the client context type produced by a sequence of middleware
  */
 export type AssignAllClientContextBeforeNext<TMiddlewares, TClientContext = undefined> = unknown extends TClientContext ? TClientContext : Assign<AssignAllMiddleware<TMiddlewares, 'allClientContextBeforeNext'>, TClientContext>;
-export type AssignAllMiddleware<TMiddlewares, TType extends keyof AnyFunctionMiddleware['_types'] | keyof AnyRequestMiddleware['_types'], TAcc = undefined> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware ? AssignAllMiddleware<TRest, TType, Assign<TAcc, TMiddleware['_types'][TType & keyof TMiddleware['_types']]>> : TAcc : TAcc;
+export type AssignAllMiddleware<TMiddlewares, TType extends keyof AnyFunctionMiddleware['_types'] | keyof AnyRequestMiddleware['_types'] | keyof AnyServerFn['_types'], TAcc = undefined> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware | AnyServerFn ? AssignAllMiddleware<TRest, TType, Assign<TAcc, TMiddleware['_types'][TType & keyof TMiddleware['_types']]>> : TAcc : TAcc;
 export type AssignAllClientContextAfterNext<TMiddlewares, TClientContext = undefined, TSendContext = undefined> = unknown extends TClientContext ? Assign<TClientContext, TSendContext> : Assign<AssignAllMiddleware<TMiddlewares, 'allClientContextAfterNext'>, Assign<TClientContext, TSendContext>>;
 export type AssignAllServerSendContext<TMiddlewares, TSendContext = undefined> = unknown extends TSendContext ? TSendContext : Assign<AssignAllMiddleware<TMiddlewares, 'allServerSendContext'>, TSendContext>;
-/**
- * Recursively resolve the server context type produced by a sequence of middleware
- */
-export type AssignAllServerContext<TMiddlewares, TSendContext = undefined, TServerContext = undefined> = unknown extends TSendContext ? Assign<TSendContext, TServerContext> : Assign<AssignAllMiddleware<TMiddlewares, 'allServerContext'>, Assign<TSendContext, TServerContext>>;
+export type AssignAllServerRequestContext<TRegister, TMiddlewares, TSendContext = undefined, TServerContext = undefined> = Assign<GlobalFetchRequestContext, Assign<GlobalServerRequestContext<TRegister>, // TODO: This enabled global middleware
+__AssignAllServerRequestContext<TMiddlewares, TSendContext, TServerContext>>>;
+export type GlobalFetchRequestContext = Register extends {
+    server: {
+        requestContext: infer TRequestContext;
+    };
+} ? TRequestContext : AnyContext;
+export type GlobalServerRequestContext<TRegister> = TRegister extends {
+    config: StartInstanceOptions<any, any, infer TRequestMiddlewares, any>;
+} ? AssignAllMiddleware<TRequestMiddlewares, 'allServerContext'> : AnyContext;
+type __AssignAllServerRequestContext<TMiddlewares, TSendContext = undefined, TServerContext = undefined> = unknown extends TSendContext ? Assign<TSendContext, TServerContext> : Assign<AssignAllMiddleware<TMiddlewares, 'allServerContext'>, Assign<TSendContext, TServerContext>>;
+export type AssignAllServerFnContext<TRegister, TMiddlewares, TSendContext = undefined, TServerContext = undefined> = Assign<GlobalFetchRequestContext, Assign<GlobalServerRequestContext<TRegister>, // TODO: This enabled global middleware
+Assign<GlobalServerFnContext<TRegister>, // TODO: This enabled global middleware
+__AssignAllServerFnContext<TMiddlewares, TSendContext, TServerContext>>>>;
+type GlobalServerFnContext<TRegister> = TRegister extends {
+    config: StartInstanceOptions<any, any, any, infer TFunctionMiddlewares>;
+} ? AssignAllMiddleware<TFunctionMiddlewares, 'allServerContext'> : AnyContext;
+type __AssignAllServerFnContext<TMiddlewares, TSendContext = undefined, TServerContext = undefined> = unknown extends TSendContext ? Assign<TSendContext, TServerContext> : Assign<AssignAllMiddleware<TMiddlewares, 'allServerContext'>, Assign<TSendContext, TServerContext>>;
 export type AssignAllClientSendContext<TMiddlewares, TSendContext = undefined> = unknown extends TSendContext ? TSendContext : Assign<AssignAllMiddleware<TMiddlewares, 'allClientSendContext'>, TSendContext>;
-export interface FunctionMiddlewareOptions<in out TRegister extends Register, in out TMiddlewares, in out TValidator, in out TServerContext, in out TClientContext, in out TServerFnResponseType extends ServerFnResponseType> {
-    validateClient?: boolean;
+export interface FunctionMiddlewareOptions<in out TRegister, in out TMiddlewares, in out TInputValidator, in out TServerContext, in out TClientContext> {
     middleware?: TMiddlewares;
-    validator?: ConstrainValidator<TRegister, TValidator>;
-    client?: FunctionMiddlewareClientFn<TRegister, TMiddlewares, TValidator, TServerContext, TClientContext, TServerFnResponseType>;
-    server?: FunctionMiddlewareServerFn<TRegister, TMiddlewares, TValidator, TServerContext, unknown, unknown, TServerFnResponseType>;
+    inputValidator?: ConstrainValidator<TRegister, 'GET', TInputValidator>;
+    client?: FunctionMiddlewareClientFn<TRegister, TMiddlewares, TInputValidator, TServerContext, TClientContext>;
+    server?: FunctionMiddlewareServerFn<TRegister, TMiddlewares, TInputValidator, TServerContext, unknown, unknown>;
 }
-export type FunctionMiddlewareClientNextFn<TRegister extends Register, TMiddlewares> = <TSendContext = undefined, TNewClientContext = undefined>(ctx?: {
+export type FunctionMiddlewareClientNextFn<TRegister, TMiddlewares> = <TSendContext = undefined, TNewClientContext = undefined>(ctx?: {
     context?: TNewClientContext;
     sendContext?: ValidateSerializableInput<TRegister, TSendContext>;
     headers?: HeadersInit;
 }) => Promise<FunctionClientResultWithContext<TMiddlewares, TSendContext, TNewClientContext>>;
-export interface FunctionMiddlewareServer<TRegister extends Register, TMiddlewares, TValidator, TServerSendContext, TClientContext, TServerFnResponseType extends ServerFnResponseType> {
-    server: <TNewServerContext = undefined, TSendContext = undefined>(server: FunctionMiddlewareServerFn<TRegister, TMiddlewares, TValidator, TServerSendContext, TNewServerContext, TSendContext, TServerFnResponseType>) => FunctionMiddlewareAfterServer<TRegister, TMiddlewares, TValidator, TNewServerContext, TServerSendContext, TClientContext, TSendContext, ServerFnResponseType>;
+export interface FunctionMiddlewareServer<TRegister, TMiddlewares, TInputValidator, TServerSendContext, TClientContext> {
+    server: <TNewServerContext = undefined, TSendContext = undefined>(server: FunctionMiddlewareServerFn<TRegister, TMiddlewares, TInputValidator, TServerSendContext, TNewServerContext, TSendContext>) => FunctionMiddlewareAfterServer<TRegister, TMiddlewares, TInputValidator, TNewServerContext, TServerSendContext, TClientContext, TSendContext>;
 }
-export type FunctionMiddlewareServerFn<TRegister extends Register, TMiddlewares, TValidator, TServerSendContext, TNewServerContext, TSendContext, TServerFnResponseType extends ServerFnResponseType> = (options: FunctionMiddlewareServerFnOptions<TRegister, TMiddlewares, TValidator, TServerSendContext, TServerFnResponseType>) => FunctionMiddlewareServerFnResult<TMiddlewares, TServerSendContext, TNewServerContext, TSendContext>;
-export interface RequestMiddlewareServerFnOptions<in out TRegister extends Register, in out TMiddlewares, in out TServerSendContext> {
-    request: Request;
-    context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>;
-    next: FunctionMiddlewareServerNextFn<TRegister, TMiddlewares, TServerSendContext>;
-    response: Response;
-    method: Method;
-    signal: AbortSignal;
-}
-export type FunctionMiddlewareServerNextFn<TRegister extends Register, TMiddlewares, TServerSendContext> = <TNewServerContext = undefined, TSendContext = undefined>(ctx?: {
+export type FunctionMiddlewareServerFn<TRegister, TMiddlewares, TInputValidator, TServerSendContext, TNewServerContext, TSendContext> = (options: FunctionMiddlewareServerFnOptions<TRegister, TMiddlewares, TInputValidator, TServerSendContext>) => FunctionMiddlewareServerFnResult<TRegister, TMiddlewares, TServerSendContext, TNewServerContext, TSendContext>;
+export type FunctionMiddlewareServerNextFn<TRegister, TMiddlewares, TServerSendContext> = <TNewServerContext = undefined, TSendContext = undefined>(ctx?: {
     context?: TNewServerContext;
     sendContext?: ValidateSerializableInput<TRegister, TSendContext>;
-}) => Promise<FunctionServerResultWithContext<TMiddlewares, TServerSendContext, TNewServerContext, TSendContext>>;
-export type FunctionServerResultWithContext<in out TMiddlewares, in out TServerSendContext, in out TServerContext, in out TSendContext> = {
+}) => Promise<FunctionServerResultWithContext<TRegister, TMiddlewares, TServerSendContext, TNewServerContext, TSendContext>>;
+export type FunctionServerResultWithContext<in out TRegister, in out TMiddlewares, in out TServerSendContext, in out TServerContext, in out TSendContext> = {
     'use functions must return the result of next()': true;
     _types: {
         context: TServerContext;
         sendContext: TSendContext;
     };
-    context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext, TServerContext>>;
+    context: Expand<AssignAllServerFnContext<TRegister, TMiddlewares, TServerSendContext, TServerContext>>;
     sendContext: Expand<AssignAllClientSendContext<TMiddlewares, TSendContext>>;
 };
-export interface FunctionMiddlewareServerFnOptions<in out TRegister extends Register, in out TMiddlewares, in out TValidator, in out TServerSendContext, in out TServerFnResponseType> {
-    data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>;
-    context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>;
+export interface FunctionMiddlewareServerFnOptions<in out TRegister, in out TMiddlewares, in out TInputValidator, in out TServerSendContext> {
+    data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TInputValidator>>;
+    context: Expand<AssignAllServerFnContext<TRegister, TMiddlewares, TServerSendContext>>;
     next: FunctionMiddlewareServerNextFn<TRegister, TMiddlewares, TServerSendContext>;
-    response: TServerFnResponseType;
     method: Method;
     filename: string;
     functionId: string;
     signal: AbortSignal;
 }
-export type FunctionMiddlewareServerFnResult<TMiddlewares, TServerSendContext, TServerContext, TSendContext> = Promise<FunctionServerResultWithContext<TMiddlewares, TServerSendContext, TServerContext, TSendContext>> | FunctionServerResultWithContext<TMiddlewares, TServerSendContext, TServerContext, TSendContext>;
-export interface FunctionMiddlewareAfterServer<TRegister extends Register, TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext, TServerFnResponseType extends ServerFnResponseType> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext, TServerFnResponseType> {
+export type FunctionMiddlewareServerFnResult<TRegister, TMiddlewares, TServerSendContext, TServerContext, TSendContext> = Promise<FunctionServerResultWithContext<TRegister, TMiddlewares, TServerSendContext, TServerContext, TSendContext>> | FunctionServerResultWithContext<TRegister, TMiddlewares, TServerSendContext, TServerContext, TSendContext>;
+export interface FunctionMiddlewareAfterServer<TRegister, TMiddlewares, TInputValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, TInputValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext> {
 }
-export interface FunctionMiddlewareClient<TRegister extends Register, TMiddlewares, TValidator, TServerFnResponseType extends ServerFnResponseType, TRouter extends AnyRouter = RegisteredRouter> {
-    client: <TSendServerContext = undefined, TNewClientContext = undefined>(client: FunctionMiddlewareClientFn<TRegister, TMiddlewares, TValidator, TSendServerContext, TNewClientContext, TServerFnResponseType, TRouter>) => FunctionMiddlewareAfterClient<TRegister, TMiddlewares, TValidator, TSendServerContext, TNewClientContext, ServerFnResponseType>;
+export interface FunctionMiddlewareClient<TRegister, TMiddlewares, TInputValidator> {
+    client: <TSendServerContext = undefined, TNewClientContext = undefined>(client: FunctionMiddlewareClientFn<TRegister, TMiddlewares, TInputValidator, TSendServerContext, TNewClientContext>) => FunctionMiddlewareAfterClient<TRegister, TMiddlewares, TInputValidator, TSendServerContext, TNewClientContext>;
 }
-export type FunctionMiddlewareClientFn<TRegister extends Register, TMiddlewares, TValidator, TSendContext, TClientContext, TServerFnResponseType extends ServerFnResponseType, TRouter extends AnyRouter = RegisteredRouter> = (options: FunctionMiddlewareClientFnOptions<TRegister, TMiddlewares, TValidator, TServerFnResponseType, TRouter>) => FunctionMiddlewareClientFnResult<TMiddlewares, TSendContext, TClientContext>;
-export interface FunctionMiddlewareClientFnOptions<in out TRegister extends Register, in out TMiddlewares, in out TValidator, in out TServerFnResponseType extends ServerFnResponseType, in out TRouter extends AnyRouter> {
-    data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>;
+export type FunctionMiddlewareClientFn<TRegister, TMiddlewares, TInputValidator, TSendContext, TClientContext> = (options: FunctionMiddlewareClientFnOptions<TRegister, TMiddlewares, TInputValidator>) => FunctionMiddlewareClientFnResult<TMiddlewares, TSendContext, TClientContext>;
+export interface FunctionMiddlewareClientFnOptions<in out TRegister, in out TMiddlewares, in out TInputValidator> {
+    data: Expand<IntersectAllValidatorInputs<TMiddlewares, TInputValidator>>;
     context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>;
     sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>;
     method: Method;
-    response: TServerFnResponseType;
     signal: AbortSignal;
     next: FunctionMiddlewareClientNextFn<TRegister, TMiddlewares>;
     filename: string;
     functionId: string;
-    router: TRouter;
 }
 export type FunctionMiddlewareClientFnResult<TMiddlewares, TSendContext, TClientContext> = Promise<FunctionClientResultWithContext<TMiddlewares, TSendContext, TClientContext>> | FunctionClientResultWithContext<TMiddlewares, TSendContext, TClientContext>;
 export type FunctionClientResultWithContext<in out TMiddlewares, in out TSendContext, in out TClientContext> = {
@@ -128,48 +131,54 @@ export type FunctionClientResultWithContext<in out TMiddlewares, in out TSendCon
     sendContext: Expand<AssignAllServerSendContext<TMiddlewares, TSendContext>>;
     headers: HeadersInit;
 };
-export interface FunctionMiddlewareAfterClient<TRegister extends Register, TMiddlewares, TValidator, TServerSendContext, TClientContext, TServerFnResponseType extends ServerFnResponseType> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, TValidator, undefined, TServerSendContext, TClientContext, undefined, TServerFnResponseType>, FunctionMiddlewareServer<TRegister, TMiddlewares, TValidator, TServerSendContext, TClientContext, TServerFnResponseType> {
+export interface FunctionMiddlewareAfterClient<TRegister, TMiddlewares, TInputValidator, TServerSendContext, TClientContext> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, TInputValidator, undefined, TServerSendContext, TClientContext, undefined>, FunctionMiddlewareServer<TRegister, TMiddlewares, TInputValidator, TServerSendContext, TClientContext> {
 }
-export interface FunctionMiddlewareValidator<TRegister extends Register, TMiddlewares, TServerFnResponseType extends ServerFnResponseType> {
-    validator: <TNewValidator>(input: ConstrainValidator<TRegister, TNewValidator>) => FunctionMiddlewareAfterValidator<TRegister, TMiddlewares, TNewValidator, TServerFnResponseType>;
+export interface FunctionMiddlewareValidator<TRegister, TMiddlewares> {
+    inputValidator: <TNewValidator>(inputValidator: ConstrainValidator<TRegister, 'GET', TNewValidator>) => FunctionMiddlewareAfterValidator<TRegister, TMiddlewares, TNewValidator>;
 }
-export interface FunctionMiddlewareAfterValidator<TRegister extends Register, TMiddlewares, TValidator, TServerFnResponseType extends ServerFnResponseType> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, TValidator, undefined, undefined, undefined, undefined, ServerFnResponseType>, FunctionMiddlewareServer<TRegister, TMiddlewares, TValidator, undefined, undefined, TServerFnResponseType>, FunctionMiddlewareClient<TRegister, TMiddlewares, TValidator, ServerFnResponseType> {
+export interface FunctionMiddlewareAfterValidator<TRegister, TMiddlewares, TInputValidator> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, TInputValidator, undefined, undefined, undefined, undefined>, FunctionMiddlewareServer<TRegister, TMiddlewares, TInputValidator, undefined, undefined>, FunctionMiddlewareClient<TRegister, TMiddlewares, TInputValidator> {
 }
-export interface RequestMiddleware extends RequestMiddlewareAfterMiddleware<undefined> {
-    middleware: <const TMiddlewares = undefined>(middlewares: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>) => RequestMiddlewareAfterMiddleware<TMiddlewares>;
+export interface RequestMiddleware<TRegister> extends RequestMiddlewareAfterMiddleware<TRegister, undefined> {
+    middleware: <const TMiddlewares = undefined>(middlewares: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>) => RequestMiddlewareAfterMiddleware<TRegister, TMiddlewares>;
 }
-export type AnyRequestMiddleware = RequestMiddlewareWithTypes<any, any>;
-export interface RequestMiddlewareWithTypes<TMiddlewares, TServerContext> {
-    _types: RequestMiddlewareTypes<TMiddlewares, TServerContext>;
+export type AnyRequestMiddleware = RequestMiddlewareWithTypes<any, any, any>;
+export interface RequestMiddlewareWithTypes<TRegister, TMiddlewares, TServerContext> {
+    _types: RequestMiddlewareTypes<TRegister, TMiddlewares, TServerContext>;
+    options: RequestMiddlewareOptions<TRegister, TMiddlewares, TServerContext>;
+}
+export interface RequestMiddlewareOptions<in out TRegister, in out TMiddlewares, in out TServerContext> {
+    middleware?: TMiddlewares;
+    server?: RequestServerFn<TRegister, TMiddlewares, TServerContext>;
 }
-export interface RequestMiddlewareTypes<TMiddlewares, TServerContext> {
+export interface RequestMiddlewareTypes<TRegister, TMiddlewares, TServerContext> {
     type: 'request';
     middlewares: TMiddlewares;
     serverContext: TServerContext;
-    allServerContext: AssignAllServerContext<TMiddlewares, undefined, TServerContext>;
+    allServerContext: AssignAllServerRequestContext<TRegister, TMiddlewares, undefined, TServerContext>;
 }
-export interface RequestMiddlewareAfterMiddleware<TMiddlewares> extends RequestMiddlewareWithTypes<TMiddlewares, undefined>, RequestMiddlewareServer<TMiddlewares> {
+export interface RequestMiddlewareAfterMiddleware<TRegister, TMiddlewares> extends RequestMiddlewareWithTypes<TRegister, TMiddlewares, undefined>, RequestMiddlewareServer<TRegister, TMiddlewares> {
 }
-export interface RequestMiddlewareServer<TMiddlewares> {
-    server: <TServerContext = undefined>(fn: RequestServerFn<TMiddlewares, TServerContext>) => RequestMiddlewareAfterServer<TMiddlewares, TServerContext>;
+export interface RequestMiddlewareServer<TRegister, TMiddlewares> {
+    server: <TServerContext = undefined>(fn: RequestServerFn<TRegister, TMiddlewares, TServerContext>) => RequestMiddlewareAfterServer<TRegister, TMiddlewares, TServerContext>;
 }
-export type RequestServerFn<TMiddlewares, TServerContext> = (options: RequestServerOptions<TMiddlewares>) => RequestMiddlewareServerFnResult<TMiddlewares, TServerContext>;
-export interface RequestServerOptions<TMiddlewares> {
+export type RequestServerFn<TRegister, TMiddlewares, TServerContext> = (options: RequestServerOptions<TRegister, TMiddlewares>) => RequestMiddlewareServerFnResult<TRegister, TMiddlewares, TServerContext>;
+export interface RequestServerOptions<TRegister, TMiddlewares> {
     request: Request;
     pathname: string;
-    context: AssignAllServerContext<TMiddlewares>;
-    next: RequestServerNextFn<TMiddlewares>;
+    context: Expand<AssignAllServerRequestContext<TRegister, TMiddlewares>>;
+    next: RequestServerNextFn<TRegister, TMiddlewares>;
 }
-export type RequestServerNextFn<TMiddlewares> = <TServerContext = undefined>(options?: RequestServerNextFnOptions<TServerContext>) => RequestMiddlewareServerFnResult<TMiddlewares, TServerContext>;
+export type RequestServerNextFn<TRegister, TMiddlewares> = <TServerContext = undefined>(options?: RequestServerNextFnOptions<TServerContext>) => RequestMiddlewareServerFnResult<TRegister, TMiddlewares, TServerContext>;
 export interface RequestServerNextFnOptions<TServerContext> {
     context?: TServerContext;
 }
-export type RequestMiddlewareServerFnResult<TMiddlewares, TServerContext> = Promise<RequestServerResult<TMiddlewares, TServerContext>> | RequestServerResult<TMiddlewares, TServerContext>;
-export interface RequestServerResult<TMiddlewares, TServerContext> {
+export type RequestMiddlewareServerFnResult<TRegister, TMiddlewares, TServerContext> = Promise<RequestServerResult<TRegister, TMiddlewares, TServerContext>> | RequestServerResult<TRegister, TMiddlewares, TServerContext>;
+export interface RequestServerResult<TRegister, TMiddlewares, TServerContext> {
     request: Request;
     pathname: string;
-    context: Expand<AssignAllServerContext<TMiddlewares, undefined, TServerContext>>;
+    context: Expand<AssignAllServerRequestContext<TRegister, TMiddlewares, undefined, TServerContext>>;
     response: Response;
 }
-export interface RequestMiddlewareAfterServer<TMiddlewares, TServerContext> extends RequestMiddlewareWithTypes<TMiddlewares, TServerContext> {
+export interface RequestMiddlewareAfterServer<TRegister, TMiddlewares, TServerContext> extends RequestMiddlewareWithTypes<TRegister, TMiddlewares, TServerContext> {
 }
+export {};

package/dist/esm/createMiddleware.js

@@ -1,6 +1,6 @@
-function createMiddleware(options, __opts) {
+const createMiddleware = (options, __opts) => {
   const resolvedOptions = {
-    type: "function",
+    type: "request",
     ...__opts || options
   };
   return {
@@ -11,10 +11,10 @@ function createMiddleware(options, __opts) {
         Object.assign(resolvedOptions, { middleware })
       );
     },
-    validator: (validator) => {
+    inputValidator: (inputValidator) => {
       return createMiddleware(
         {},
-        Object.assign(resolvedOptions, { validator })
+        Object.assign(resolvedOptions, { inputValidator })
       );
     },
     client: (client) => {
@@ -30,7 +30,7 @@ function createMiddleware(options, __opts) {
       );
     }
   };
-}
+};
 export {
   createMiddleware
 };