@kaito-http/core 3.0.0-beta.7 → 3.0.1

package/dist/index.d.ts

@@ -1,11 +1,3 @@
-import * as find_my_way from 'find-my-way';
-import find_my_way__default, { HTTPMethod } from 'find-my-way';
-export { HTTPMethod } from 'find-my-way';
-import * as http from 'http';
-import * as http$1 from 'node:http';
-import { IncomingMessage, ServerResponse } from 'node:http';
-import { CookieSerializeOptions } from 'cookie';
-
 declare class WrappedError<T> extends Error {
     readonly data: T;
     static maybe<T>(maybeError: T): (T & Error) | WrappedError<T>;
@@ -18,36 +10,72 @@ declare class KaitoError extends Error {
 }
 
 declare class KaitoRequest {
-    readonly raw: IncomingMessage;
-    private _url;
-    constructor(raw: IncomingMessage);
-    /**
-     * The full URL of the request, including the protocol, hostname, and path.
-     * Note: does not include the query string or hash
-     */
-    get fullURL(): string;
-    /**
-     * A new URL instance for the full URL of the request.
-     */
-    get url(): URL;
+    readonly url: URL;
+    private readonly _request;
+    constructor(url: URL, request: Request);
+    get headers(): Headers;
+    get method(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    formData(): Promise<FormData>;
+    bytes(): Promise<Uint8Array>;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+    get request(): Request;
+}
+
+type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
+
+/**
+ * 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
+ * code or headers that the developer may want to make.
+ *
+ * This exists because there's otherwise no way to indicate back to Kaito that
+ * the developer wants to change the status code or headers.
+ *
+ * @example
+ * ```ts
+ * const response = new KaitoHead();
+ *
+ * response.status(200);
+ * response.headers.set('Content-Type', 'application/json');
+ *
+ * console.log(response.headers); // Headers {'content-type': 'application/json'}
+ * ```
+ */
+declare class KaitoHead {
+    private _headers;
+    private _status;
+    constructor();
+    get headers(): Headers;
     /**
-     * The HTTP method of the request.
+     * Gets the status code of this KaitoHead instance
+     * @returns The status code
      */
-    get method(): HTTPMethod;
+    status(): number;
     /**
-     * The protocol of the request, either `http` or `https`.
+     * Sets the status code of this KaitoHead instance
+     * @param status The status code to set
+     * @returns This KaitoHead instance
      */
-    get protocol(): 'http' | 'https';
+    status(status: number): this;
     /**
-     * The request headers
+     * Turn this KaitoHead instance into a Response instance
+     * @param body The Kaito JSON format to be sent as the response body
+     * @returns A Response instance, ready to be sent
      */
-    get headers(): http.IncomingHttpHeaders;
+    toResponse<T>(body: APIResponse<T>): Response;
     /**
-     * The hostname of the request.
+     * Whether this KaitoHead instance has been touched/modified
      */
-    get hostname(): string;
+    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;
@@ -60,120 +88,24 @@ type SuccessfulAPIResponse<T> = {
 };
 type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
 type AnyResponse = APIResponse<unknown>;
-declare class KaitoResponse<T = unknown> {
-    readonly raw: ServerResponse;
-    constructor(raw: ServerResponse);
-    /**
-     * Send a response
-     * @param key The key of the header
-     * @param value The value of the header
-     * @returns The response object
-     */
-    header(key: string, value: string | readonly string[]): this;
-    /**
-     * Set the status code of the response
-     * @param code The status code
-     * @returns The response object
-     */
-    status(code: number): this;
-    /**
-     * Set a cookie
-     * @param name The name of the cookie
-     * @param value The value of the cookie
-     * @param options The options for the cookie
-     * @returns The response object
-     */
-    cookie(name: string, value: string, options: CookieSerializeOptions): this;
-    /**
-     * Send a JSON APIResponse body
-     * @param data The data to send
-     * @returns The response object
-     */
-    json(data: APIResponse<T>): this;
-}
-
-type Before<BeforeAfterContext> = (req: http$1.IncomingMessage, res: http$1.ServerResponse) => Promise<BeforeAfterContext>;
-type HandlerResult = {
-    success: true;
-    data: unknown;
-} | {
-    success: false;
-    data: {
-        status: number;
-        message: string;
-    };
-};
-type After<BeforeAfterContext> = (ctx: BeforeAfterContext, result: HandlerResult) => Promise<void>;
-type ServerConfigWithBefore<BeforeAfterContext> = {
-    before: Before<BeforeAfterContext>;
-    after?: After<BeforeAfterContext>;
-} | {
-    before?: undefined;
-};
-type ServerConfig<ContextFrom, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
-    router: Router<ContextFrom, unknown, any>;
-    getContext: GetContext<ContextFrom>;
-    rawRoutes?: Partial<Record<KaitoMethod, Array<{
-        path: string;
-        handler: (request: http$1.IncomingMessage, response: http$1.ServerResponse) => unknown;
-    }>>>;
-    onError(arg: {
-        error: Error;
-        req: KaitoRequest;
-        res: KaitoResponse;
-    }): Promise<KaitoError | {
-        status: number;
-        message: string;
-    }>;
-};
-declare function createFMWServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): {
-    readonly server: http$1.Server<typeof http$1.IncomingMessage, typeof http$1.ServerResponse>;
-    readonly fmw: find_my_way.Instance<find_my_way.HTTPVersion.V1>;
-};
-declare function createServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): http$1.Server<typeof http$1.IncomingMessage, typeof http$1.ServerResponse>;
-
-type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextFrom, infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput> ? Route<ContextFrom, ContextTo, Result, `${Prefix}${Path}`, Method, Query, BodyOutput> : never;
-type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;
-type RouterOptions<ContextFrom, ContextTo> = {
-    through: (context: ContextFrom) => Promise<ContextTo>;
-};
-type InferRoutes<R extends Router<any, any, any>> = R extends Router<any, any, infer R> ? R : never;
-declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
-    private readonly routerOptions;
-    readonly routes: Set<R>;
-    static create: <Context>() => Router<Context, Context, never>;
-    private static parseQuery;
-    private static handle;
-    constructor(routes: Iterable<R>, options: RouterOptions<ContextFrom, ContextTo>);
-    /**
-     * Adds a new route to the router
-     * @deprecated Use the method-specific methods instead
-     */
-    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(method: Method, path: Path, route: (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "body" | "path" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "path" | "method" | "through">) | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>["run"]) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>>;
-    readonly merge: <PathPrefix extends `/${string}`, OtherRoutes extends AnyRoute>(pathPrefix: PathPrefix, other: Router<ContextFrom, unknown, OtherRoutes>) => Router<ContextFrom, ContextTo, Extract<R | PrefixRoutesPath<PathPrefix, OtherRoutes>, AnyRoute>>;
-    freeze: (server: ServerConfig<ContextFrom, any>) => find_my_way__default.Instance<find_my_way__default.HTTPVersion.V1>;
-    private readonly method;
-    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>, "body" | "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>>;
-    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>>;
-    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>>;
-    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>>;
-    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>>;
-    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>>;
-    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>>;
-    through: <NextContext>(transform: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
-}
-
+type MakeOptional<T, K extends keyof T> = T extends T ? Omit<T, K> & Partial<Pick<T, K>> : never;
 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;
 } : {};
-type KaitoMethod = HTTPMethod | '*';
-type GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
 /**
- * @deprecated use `createUtilities` instead
+ * 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
  */
-declare function createGetContext<Context>(callback: GetContext<Context>): GetContext<Context>;
+type GetContext<Result> = (req: KaitoRequest, head: KaitoHead) => Promise<Result>;
 /**
  * A helper function to create typed necessary functions
  *
@@ -185,7 +117,7 @@ declare function createGetContext<Context>(callback: GetContext<Context>): GetCo
  *
  * const app = router().get('/', async () => "hello");
  *
- * const server = createServer({
+ * const server = createKaitoHandler({
  *   router: app,
  *   getContext,
  *   // ...
@@ -196,8 +128,6 @@ declare function createUtilities<Context>(getContext: GetContext<Context>): {
     getContext: GetContext<Context>;
     router: () => Router<Context, Context, never>;
 };
-type InferContext<T> = T extends (req: KaitoRequest, res: KaitoResponse) => Promise<infer U> ? U : never;
-declare function getLastEntryInMultiHeaderValue(headerValue: string | string[]): string;
 interface Parsable<Output = any, Input = Output> {
     _input: Input;
     parse: (value: unknown) => Output;
@@ -207,12 +137,6 @@ type InferParsable<T> = T extends Parsable<infer Output, infer Input> ? {
     output: Output;
 } : never;
 declare function parsable<T>(parse: (value: unknown) => T): Parsable<T, T>;
-type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
-type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U}` : `/${T}`;
-type NormalizePath<T extends string> = AddStartSlashes<RemoveEndSlashes<T>>;
-type Values<T> = T[keyof T];
-type NoEmpty<T> = [keyof T] extends [never] ? never : T;
-declare function getBody(req: KaitoRequest): Promise<unknown>;
 
 type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
     ctx: Context;
@@ -221,9 +145,9 @@ type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
     params: ExtractRouteParams<Path>;
 };
 type AnyQueryDefinition = Record<string, Parsable<any, string | undefined>>;
-type RouteRunner<Result, Path extends string, Context, QueryOutput, BodyOutput> = (args: RouteArgument<Path, Context, QueryOutput, BodyOutput>) => Promise<Result>;
+type Through<From, To> = (context: From) => Promise<To>;
 type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition, Body extends Parsable> = {
-    through: (context: ContextFrom) => Promise<ContextTo>;
+    through: Through<ContextFrom, ContextTo>;
     body?: Body;
     query?: Query;
     path: Path;
@@ -232,6 +156,100 @@ type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends K
         [Key in keyof Query]: InferParsable<Query[Key]>['output'];
     }, InferParsable<Body>['output']>): Promise<Result>;
 };
-type AnyRoute<FromContext = any, ToContext = any> = Route<FromContext, ToContext, any, any, any, AnyQueryDefinition, any>;
+type AnyRoute<ContextFrom = any, ContextTo = any> = Route<ContextFrom, ContextTo, any, any, any, AnyQueryDefinition, any>;
+
+type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextFrom, infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput> ? Route<ContextFrom, 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<Routes extends AnyRoute, ContextFrom, ContextTo> = {
+    routes: Set<Routes>;
+    through: (context: ContextFrom) => Promise<ContextTo>;
+};
+type InferRoutes<R extends Router<any, any, any>> = R extends Router<any, any, infer R> ? R : never;
+declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
+    private readonly state;
+    static create: <Context>() => Router<Context, Context, never>;
+    private static parseQuery;
+    constructor(options: RouterState<R, ContextFrom, ContextTo>);
+    get routes(): Set<R>;
+    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(method: Method, path: Path, route: (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "body" | "path" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "path" | "method" | "through">) | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>["run"]) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>>;
+    readonly merge: <PathPrefix extends `/${string}`, OtherRoutes extends AnyRoute>(pathPrefix: PathPrefix, other: Router<ContextFrom, unknown, OtherRoutes>) => Router<ContextFrom, ContextTo, Extract<R | PrefixRoutesPath<PathPrefix, OtherRoutes>, AnyRoute>>;
+    freeze: (server: Omit<HandlerConfig<ContextFrom>, "router">) => (req: Request) => Promise<Response>;
+    private readonly method;
+    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>, "body" | "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>>;
+    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>>;
+    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>>;
+    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>>;
+    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>>;
+    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>>;
+    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>>;
+    through: <NextContext>(through: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
+}
+
+type HandlerConfig<ContextFrom> = {
+    /**
+     * The root router to mount on this handler.
+     */
+    router: Router<ContextFrom, unknown, any>;
+    /**
+     * 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.
+     */
+    getContext: GetContext<ContextFrom>;
+    /**
+     * A function that is called when an error occurs inside a route handler.
+     *
+     * The result of this function is used to determine the response status and message, and is
+     * always sent to the client. You could include logic to check for production vs development
+     * environments here, and this would also be a good place to include error tracking
+     * like Sentry or Rollbar.
+     *
+     * @param arg - The error thrown, and the KaitoRequest instance
+     * @returns A KaitoError or an object with a status and message
+     */
+    onError: (arg: {
+        error: Error;
+        req: KaitoRequest;
+    }) => Promise<KaitoError | {
+        status: number;
+        message: string;
+    }>;
+    /**
+     * A function that is called before every request. Most useful for bailing out early in the case of an OPTIONS request.
+     *
+     * @example
+     * ```ts
+     * before: async req => {
+     * 	if (req.method === 'OPTIONS') {
+     * 		return new Response(null, {status: 204});
+     * 	}
+     * }
+     * ```
+     */
+    before?: (req: Request) => Promise<Response | void | undefined>;
+    /**
+     * Transforms the response before it is sent to the client. Very useful for settings headers like CORS.
+     *
+     * You can also return a new response in this function, or just mutate the current one.
+     *
+     * This function WILL receive the result of `.before()` if you return a response from it. This means
+     *  you only need to define headers in a single place.
+     *
+     * @example
+     * ```ts
+     * transform: async (req, res) => {
+     * 	res.headers.set('Access-Control-Allow-Origin', 'http://localhost:3000');
+     * 	res.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+     * 	res.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+     * 	res.headers.set('Access-Control-Max-Age', '86400');
+     * 	res.headers.set('Access-Control-Allow-Credentials', 'true');
+     * }
+     * ```
+     */
+    transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
+};
+declare function createKaitoHandler<Context>(config: HandlerConfig<Context>): (request: Request) => Promise<Response>;
 
-export { type APIResponse, type AddStartSlashes, type After, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type HandlerResult, type InferContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, KaitoResponse, type NoEmpty, type NormalizePath, type Parsable, type RemoveEndSlashes, type Route, type RouteArgument, type RouteRunner, Router, type RouterOptions, type ServerConfig, type ServerConfigWithBefore, type SuccessfulAPIResponse, type Values, WrappedError, createFMWServer, createGetContext, createServer, createUtilities, getBody, getLastEntryInMultiHeaderValue, parsable };
+export { type APIResponse, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type HandlerConfig, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type MakeOptional, type Parsable, type Route, type RouteArgument, Router, type RouterState, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, isNodeLikeDev, parsable };