@kaito-http/core 4.0.0-beta.3 → 4.0.0-beta.30

package/dist/index.d.cts

@@ -1,5 +1,7 @@
-import { z } from 'zod';
-import { KaitoSSEResponse } from './stream/stream.cjs';
+import { JSONValue, BaseSchema, AnySchemaFor } from './schema/schema.cjs';
+export { ArrayChecks, ArrayDef, BaseSchemaDef, BooleanDef, Issue, JSONPrimitive, KArray, KBoolean, KLazy, KLiteral, KNativeEnum, KNull, KNumber, KObject, KObjectFromURLSearchParams, KRecord, KRef, KScalar, KString, KUnion, LazyDef, LiteralDef, NativeEnumDef, NullDef, NumberChecks, NumberDef, NumberFormat, ObjectDef, ParseContext, ParseResult, RecordDef, RefDef, STRING_FORMAT_REGEXES, ScalarDef, ScalarOptions, SchemaError, StringChecks, StringDef, StringFormat, UnionDef, isPrimitiveJSONValue, k } from './schema/schema.cjs';
+import * as OpenAPI from 'openapi3-ts/oas31';
+import { KaitoSSEResponse, SSEEvent } from './stream/stream.cjs';
 
 declare class WrappedError<T> extends Error {
     static maybe<T>(maybeError: T): (T & Error) | WrappedError<T>;
@@ -21,14 +23,12 @@ declare class KaitoRequest {
     arrayBuffer(): Promise<ArrayBuffer>;
     blob(): Promise<Blob>;
     formData(): Promise<FormData>;
-    bytes(): Promise<Uint8Array>;
+    bytes(): Promise<Uint8Array<ArrayBuffer>>;
     json(): Promise<unknown>;
     text(): Promise<string>;
     get request(): Request;
 }
 
-type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
-
 /**
  * This class is merely a wrapper around a `Headers` object and a status code.
  * It's used while the router is executing a route to store any mutations to the status
@@ -67,139 +67,168 @@ declare class KaitoHead {
      * @param body The Kaito JSON format to be sent as the response body
      * @returns A Response instance, ready to be sent
      */
-    toResponse<T>(body: APIResponse<T>): Response;
+    toResponse<T extends JSONValue>(data: T): Response;
     /**
      * Whether this KaitoHead instance has been touched/modified
      */
     get touched(): boolean;
 }
 
-/**
- * A helper to check if the environment is Node.js-like and the NODE_ENV is development
- */
-declare const isNodeLikeDev: boolean;
-type ErroredAPIResponse = {
-    success: false;
-    data: null;
-    message: string;
-};
-type SuccessfulAPIResponse<T> = {
-    success: true;
-    data: T;
+type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextFrom, infer ContextTo, infer RouterInput, infer ResultOutput, infer Path, infer AdditionalParams, infer Method, infer Query, infer BodyOutput> ? Route<ContextFrom, ContextTo, RouterInput, ResultOutput, `${Prefix}${Path extends '/' ? '' : Path}`, AdditionalParams, Method, Query, BodyOutput> : never;
+type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;
+type RouterState<ContextFrom, ContextTo, RequiredParams extends string, Routes extends AnyRoute, Input extends readonly unknown[]> = {
+    routes: Set<Routes>;
+    through: (context: ContextFrom, params: Record<RequiredParams, string>) => Promise<ContextTo> | ContextTo;
+    config: KaitoConfig<ContextFrom, Input>;
 };
-type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
-type AnyResponse = APIResponse<unknown>;
-type MakeOptional<T, K extends keyof T> = T extends T ? Omit<T, K> & Partial<Pick<T, K>> : never;
-type MaybePromise<T> = T | Promise<T>;
-type ExtractRouteParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}:${infer Param}/${infer Rest}` ? {
-    [k in Param | keyof ExtractRouteParams<Rest>]: string;
-} : T extends `${string}:${infer Param}` ? {
-    [k in Param]: string;
-} : {};
-/**
- * A function that is called to get the context for a request.
- *
- * This is useful for things like authentication, to pass in a database connection, etc.
- *
- * It's fine for this function to throw; if it does, the error is passed to the `onError` function.
- *
- * @param req - The kaito request object, which contains the request method, url, headers, etc
- * @param head - The kaito head object, which contains getters and setters for headers and status
- * @returns The context for your routes
- */
-type GetContext<Result> = (req: KaitoRequest, head: KaitoHead) => MaybePromise<Result>;
+declare class Router<ContextFrom, ContextTo, RequiredParams extends string, Routes extends AnyRoute, Input extends readonly unknown[]> {
+    #private;
+    static create: <Context = null, Input_1 extends readonly unknown[] = []>(config?: KaitoConfig<Context, Input_1>) => Router<Context, Context, never, never, Input_1>;
+    protected constructor(state: RouterState<ContextFrom, ContextTo, RequiredParams, Routes, Input>);
+    get routes(): Set<Routes>;
+    private readonly add;
+    readonly params: [RequiredParams] extends [never] ? <NextParams extends string>() => Router<ContextFrom, ContextTo, NextParams, Routes, Input> : () => Router<ContextFrom, ContextTo, RequiredParams, Routes, Input>;
+    readonly merge: <PathPrefix extends `/${string}`, NextRequiredParams extends string, OtherRoutes extends AnyRoute>(pathPrefix: [NextRequiredParams] extends [ExtractRouteParams<PathPrefix> | RequiredParams] ? PathPrefix : `/:${Exclude<NextRequiredParams, ExtractRouteParams<PathPrefix> | RequiredParams>}`, other: Router<ContextFrom, ContextTo, NextRequiredParams, OtherRoutes, Input>) => Router<ContextFrom, ContextTo, RequiredParams, Routes | PrefixRoutesPath<PathPrefix, OtherRoutes>, Input>;
+    protected static getFindRoute: <R>(routes: Map<KaitoMethod, Map<string, R>>) => (method: KaitoMethod, path: string) => {
+        route?: never;
+        params?: never;
+    } | {
+        route: R;
+        params: Record<string, string>;
+    };
+    serve: () => (request: Request, ...args: Input) => Promise<Response>;
+    /**
+     * Create a `/openapi.json` route on this router.
+     *
+     * Any routes defined AFTER this method call will NOT be included in the
+     * file. This is because all methods in Kaito are immutable, so there's no
+     * way for the router to know about routes that were created in the future
+     * on another router.
+     *
+     * @example
+     * ```ts
+     * router.get("/", () => "hey").openapi({
+     * 	info: {
+     * 		title: "My API",
+     * 		version: "1.0.0",
+     * 	},
+     * });
+     * ```
+     *
+     * @param options Options object
+     * @returns
+     */
+    openapi: ({ info, servers, }: {
+        info: OpenAPI.InfoObject;
+        servers?: Partial<Record<(`https://` | `http://`) | ({} & string), string>>;
+    }) => Router<ContextFrom, ContextTo, RequiredParams, Routes | Route<ContextFrom, ContextTo, Input, Response, "/openapi.json", RequiredParams, "GET", {}, never>, Input>;
+    private readonly method;
+    readonly get: <Path extends string, ResultOutput = never, Query extends AnyQuery = {}, Body extends JSONValue = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => ResultOutput | Promise<ResultOutput>) | (Omit<Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "GET", Query, Body>, "body" | "path" | "method" | "router" | "openapi"> & {
+        openapi?: OpenAPISpecFor<ResultOutput>;
+    })) => Router<ContextFrom, ContextTo, RequiredParams, Routes | Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "GET", Query, Body>, Input>;
+    readonly post: <Path extends string, ResultOutput = never, Query extends AnyQuery = {}, Body extends JSONValue = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => ResultOutput | Promise<ResultOutput>) | (Omit<Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "POST", Query, Body>, "path" | "method" | "router" | "openapi"> & {
+        openapi?: OpenAPISpecFor<ResultOutput>;
+    })) => Router<ContextFrom, ContextTo, RequiredParams, Routes | Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "POST", Query, Body>, Input>;
+    readonly put: <Path extends string, ResultOutput = never, Query extends AnyQuery = {}, Body extends JSONValue = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => ResultOutput | Promise<ResultOutput>) | (Omit<Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "PUT", Query, Body>, "path" | "method" | "router" | "openapi"> & {
+        openapi?: OpenAPISpecFor<ResultOutput>;
+    })) => Router<ContextFrom, ContextTo, RequiredParams, Routes | Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "PUT", Query, Body>, Input>;
+    readonly patch: <Path extends string, ResultOutput = never, Query extends AnyQuery = {}, Body extends JSONValue = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => ResultOutput | Promise<ResultOutput>) | (Omit<Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "PATCH", Query, Body>, "path" | "method" | "router" | "openapi"> & {
+        openapi?: OpenAPISpecFor<ResultOutput>;
+    })) => Router<ContextFrom, ContextTo, RequiredParams, Routes | Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "PATCH", Query, Body>, Input>;
+    readonly delete: <Path extends string, ResultOutput = never, Query extends AnyQuery = {}, Body extends JSONValue = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => ResultOutput | Promise<ResultOutput>) | (Omit<Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "DELETE", Query, Body>, "path" | "method" | "router" | "openapi"> & {
+        openapi?: OpenAPISpecFor<ResultOutput>;
+    })) => Router<ContextFrom, ContextTo, RequiredParams, Routes | Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "DELETE", Query, Body>, Input>;
+    readonly head: <Path extends string, ResultOutput = never, Query extends AnyQuery = {}, Body extends JSONValue = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => ResultOutput | Promise<ResultOutput>) | (Omit<Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "HEAD", Query, Body>, "path" | "method" | "router" | "openapi"> & {
+        openapi?: OpenAPISpecFor<ResultOutput>;
+    })) => Router<ContextFrom, ContextTo, RequiredParams, Routes | Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "HEAD", Query, Body>, Input>;
+    readonly options: <Path extends string, ResultOutput = never, Query extends AnyQuery = {}, Body extends JSONValue = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => ResultOutput | Promise<ResultOutput>) | (Omit<Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "OPTIONS", Query, Body>, "path" | "method" | "router" | "openapi"> & {
+        openapi?: OpenAPISpecFor<ResultOutput>;
+    })) => Router<ContextFrom, ContextTo, RequiredParams, Routes | Route<ContextFrom, ContextTo, Input, ResultOutput, Path, RequiredParams, "OPTIONS", Query, Body>, Input>;
+    through: <NextContext>(through: (context: ContextTo, params: Record<RequiredParams, string>) => MaybePromise<NextContext>) => Router<ContextFrom, NextContext, RequiredParams, Routes, Input>;
+}
 
-type RouteRunData<Path extends string, Context, QueryOutput, BodyOutput> = {
+type RouteRunData<Params extends string, Context, QueryOutput, BodyOutput> = {
+    params: Record<Params, string>;
     ctx: Context;
-    body: BodyOutput;
     query: QueryOutput;
-    params: ExtractRouteParams<Path>;
+    body: BodyOutput;
 };
 type AnyQuery = {
     [key in string]: any;
 };
-type Through<From, To> = (context: From) => Promise<To>;
-type SSEOutputSpec<Result> = {
+type Through<From, To, RequiredParams extends string> = (context: From, params: Record<RequiredParams, string>) => Promise<To>;
+type SSEOutputSpecWithSchema = {
     type: 'sse';
-    schema: z.Schema<Result>;
-    description?: string;
+    schema: BaseSchema<any, any, any>;
+    description?: string | undefined;
+};
+type SSEOutputSpecWithoutSchema = {
+    type: 'sse';
+    schema?: undefined;
+    description?: string | undefined;
 };
-type JSONOutputSpec<Result> = {
+type SSEOutputSpec = SSEOutputSpecWithSchema | SSEOutputSpecWithoutSchema;
+type JSONOutputSpec = {
     type: 'json';
-    schema: z.Schema<Result>;
-    description?: string;
+    schema: BaseSchema<any, any, any>;
+    description?: string | undefined;
+};
+type ResponseOutputSpec = {
+    type: 'response';
+    description?: string | undefined;
 };
-type OutputSpec<Result> = {
+type OutputSpec = SSEOutputSpec | JSONOutputSpec | ResponseOutputSpec;
+type OpenAPISpec<Body extends OutputSpec = OutputSpec> = {
+    summary?: string;
     description?: string;
-    body: NoInfer<Result extends KaitoSSEResponse<infer R> ? SSEOutputSpec<R> : JSONOutputSpec<Result>>;
+    body: Body;
 };
-type Route<ContextTo, Result, Path extends string, Method extends KaitoMethod, Query, Body> = {
-    through: Through<unknown, ContextTo>;
-    body?: z.Schema<Body>;
+type OpenAPISpecFor<ResultOutput> = 0 extends 1 & ResultOutput ? OpenAPISpec : [ResultOutput] extends [never] ? OpenAPISpec : [ResultOutput] extends [KaitoSSEResponse<any>] ? [ResultOutput extends KaitoSSEResponse<SSEEvent<infer U, any>> ? U : never] extends [JSONValue] ? OpenAPISpec<SSEOutputSpec> : OpenAPISpec<SSEOutputSpecWithSchema> : [ResultOutput] extends [Response] ? OpenAPISpec<ResponseOutputSpec> : OpenAPISpec<JSONOutputSpec>;
+type Route<ContextFrom, ContextTo, RouterInput extends readonly unknown[], ResultOutput, Path extends string, AdditionalParams extends string, Method extends KaitoMethod, Query extends Record<string, JSONValue>, Body extends JSONValue> = {
+    body?: AnySchemaFor<Body>;
     query?: {
-        [Key in keyof Query]: z.Schema<Query[Key]>;
+        [Key in keyof Query]: AnySchemaFor<Query[Key]>;
     };
     path: Path;
     method: Method;
-    openapi?: OutputSpec<NoInfer<Result>>;
-    run(data: RouteRunData<Path, ContextTo, Query, Body>): Promise<Result> | Result;
+    openapi?: OpenAPISpec;
+    router: Router<ContextFrom, ContextTo, AdditionalParams, AnyRoute, RouterInput>;
+    run(data: RouteRunData<ExtractRouteParams<Path> | AdditionalParams, ContextTo, Query, Body>): Promise<ResultOutput> | ResultOutput;
 };
-type AnyRoute = Route<any, any, any, any, any, any>;
+type AnyRoute = Route<any, any, any, unknown, any, any, any, any, any>;
 
-type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput> ? Route<ContextTo, Result, `${Prefix}${Path}`, Method, Query, BodyOutput> : never;
-type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;
-type RouterState<ContextFrom, ContextTo, Routes extends AnyRoute> = {
-    routes: Set<Routes>;
-    through: (context: unknown) => Promise<ContextTo>;
-    config: KaitoConfig<ContextFrom>;
-};
+/**
+ * A helper to check if the environment is Node.js-like and the `NODE_ENV` environment variable is set to `'development'`
+ */
+declare const isNodeLikeDev: boolean;
+type MaybePromise<T> = T | Promise<T>;
+type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+type ExtractRouteParams<T extends string> = string extends T ? string : T extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractRouteParams<Rest> : T extends `${string}:${infer Param}` ? Param : never;
 /**
  * Accepts a router instance, and returns a union of all the routes in the router
  *
  * @example
  * ```ts
- * const app = router().get('/', () => 'Hello, world!');
+ * const app = router.get('/', () => 'Hello, world!');
  *
  * type Routes = InferRoutes<typeof app>;
  * ```
  */
-type InferRoutes<R extends Router<any, any, any>> = R extends Router<any, any, infer R extends AnyRoute> ? R : never;
-declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
-    private readonly state;
-    static create: <Context>(config: KaitoConfig<Context>) => Router<Context, Context, never>;
-    constructor(state: RouterState<ContextFrom, ContextTo, R>);
-    get routes(): Set<R>;
-    private add;
-    readonly merge: <PathPrefix extends `/${string}`, OtherRoutes extends AnyRoute>(pathPrefix: PathPrefix, other: Router<ContextFrom, unknown, OtherRoutes>) => Router<ContextFrom, ContextTo, Extract<R | PrefixRoutesPath<PathPrefix, Extract<OtherRoutes, AnyRoute>>, AnyRoute>>;
-    protected static getFindRoute: <R_1>(routes: Map<KaitoMethod, Map<string, R_1>>) => (method: KaitoMethod, path: string) => {
-        route?: never;
-        params?: never;
-    } | {
-        route: R_1;
-        params: Record<string, string>;
-    };
-    private static buildQuerySchema;
-    serve: () => (request: Request) => Promise<Response>;
-    openapi: (highLevelSpec: {
-        info: {
-            version: string;
-            title: string;
-            description?: string;
-        };
-        servers?: Partial<Record<(`https://` | `http://`) | ({} & string), string>>;
-    }) => Router<ContextFrom, ContextTo, R | Route<ContextTo, Response, "/openapi.json", "GET", AnyQuery, unknown>>;
-    private readonly method;
-    get: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<Path, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, "GET", Query, Body>, "body" | "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextTo, Result, Path, "GET", Query, Body>>;
-    post: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<Path, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, "POST", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextTo, Result, Path, "POST", Query, Body>>;
-    put: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<Path, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, "PUT", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextTo, Result, Path, "PUT", Query, Body>>;
-    patch: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<Path, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, "PATCH", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextTo, Result, Path, "PATCH", Query, Body>>;
-    delete: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<Path, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, "DELETE", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextTo, Result, Path, "DELETE", Query, Body>>;
-    head: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<Path, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, "HEAD", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextTo, Result, Path, "HEAD", Query, Body>>;
-    options: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<Path, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, "OPTIONS", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextTo, Result, Path, "OPTIONS", Query, Body>>;
-    through: <NextContext>(through: (context: ContextTo) => MaybePromise<NextContext>) => Router<ContextFrom, NextContext, R>;
-}
+type InferRoutes<R extends Router<never, never, never, never, never>> = R extends Router<any, any, any, infer R extends AnyRoute, any> ? R : never;
+/**
+ * A function that is called to get the context for a request.
+ *
+ * This is useful for things like authentication, to pass in a database connection, etc.
+ *
+ * It's fine for this function to throw; if it does, the error is passed to the `onError` function.
+ *
+ * @param req - The kaito request object, which contains the request method, url, headers, etc
+ * @param head - The kaito head object, which contains getters and setters for headers and status
+ * @returns The context for your routes
+ */
+type GetContext<Result, Input extends readonly unknown[]> = (req: KaitoRequest, head: KaitoHead, ...args: Input) => MaybePromise<Result>;
 
-type KaitoConfig<ContextFrom> = {
+interface KaitoConfig<ContextFrom, Input extends readonly unknown[]> {
     /**
      * A function that is called to get the context for a request.
      *
@@ -207,7 +236,7 @@ type KaitoConfig<ContextFrom> = {
      *
      * It's fine for this function to throw; if it does, the error is passed to the `onError` function.
      */
-    getContext?: GetContext<ContextFrom>;
+    getContext?: GetContext<ContextFrom, Input>;
     /**
      * A function that is called when an error occurs inside a route handler.
      *
@@ -256,15 +285,16 @@ type KaitoConfig<ContextFrom> = {
      * ```
      */
     transform?: (req: Request, res: Response) => MaybePromise<Response | void | undefined>;
-};
+}
+
 /**
- * Create a helper function for instantiating a Kaito router
+ * Helper function for instantiating a Kaito router
  *
  * This is the starting point for any Kaito application
  *
  * @param config - The configuration for the router
  * @returns A new Kaito router
  */
-declare function create<Context = null>(config?: KaitoConfig<Context>): () => Router<Context, Context, never>;
+declare const create: <Context = null, Input extends readonly unknown[] = []>(config?: KaitoConfig<Context, Input>) => Router<Context, Context, never, never, Input>;
 
-export { type APIResponse, type AnyQuery, type AnyResponse, type AnyRoute, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferRoutes, type JSONOutputSpec, type KaitoConfig, KaitoError, type KaitoMethod, KaitoRequest, type MakeOptional, type MaybePromise, type OutputSpec, type Route, type RouteRunData, Router, type RouterState, type SSEOutputSpec, type SuccessfulAPIResponse, type Through, WrappedError, create, isNodeLikeDev };
+export { type AnyQuery, type AnyRoute, AnySchemaFor, BaseSchema, type ExtractRouteParams, type GetContext, type InferRoutes, type JSONOutputSpec, JSONValue, type KaitoConfig, KaitoError, KaitoHead, type KaitoMethod, KaitoRequest, type MaybePromise, type OpenAPISpec, type OpenAPISpecFor, type OutputSpec, type ResponseOutputSpec, type Route, type RouteRunData, Router, type RouterState, type SSEOutputSpec, type SSEOutputSpecWithSchema, type SSEOutputSpecWithoutSchema, type Through, WrappedError, create, isNodeLikeDev };