@kaito-http/core 3.0.0-beta.1 → 3.0.0-beta.11

package/dist/index.cjs

@@ -0,0 +1,317 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  KaitoError: () => KaitoError,
+  KaitoRequest: () => KaitoRequest,
+  Router: () => Router,
+  WrappedError: () => WrappedError,
+  createKaitoHandler: () => createKaitoHandler,
+  createUtilities: () => createUtilities,
+  parsable: () => parsable
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/error.ts
+var WrappedError = class _WrappedError extends Error {
+  constructor(data) {
+    super("Something was thrown, but it was not an instance of Error, so a WrappedError was created.");
+    this.data = data;
+  }
+  static maybe(maybeError) {
+    if (maybeError instanceof Error) {
+      return maybeError;
+    }
+    return _WrappedError.from(maybeError);
+  }
+  static from(data) {
+    return new _WrappedError(data);
+  }
+};
+var KaitoError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+};
+
+// src/request.ts
+var KaitoRequest = class {
+  url;
+  _request;
+  constructor(url, request) {
+    this._request = request;
+    this.url = url;
+  }
+  get headers() {
+    return this._request.headers;
+  }
+  get method() {
+    return this._request.method;
+  }
+  async arrayBuffer() {
+    return this._request.arrayBuffer();
+  }
+  async blob() {
+    return this._request.blob();
+  }
+  async formData() {
+    return this._request.formData();
+  }
+  async bytes() {
+    const buffer = await this.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  async json() {
+    return this._request.json();
+  }
+  async text() {
+    return this._request.text();
+  }
+  get request() {
+    return this._request;
+  }
+};
+
+// src/response.ts
+var KaitoResponse = class {
+  _headers;
+  _status;
+  constructor() {
+    this._headers = null;
+    this._status = 200;
+  }
+  get headers() {
+    if (this._headers === null) {
+      this._headers = new Headers();
+    }
+    return this._headers;
+  }
+  status(status) {
+    this._status = status;
+    return this;
+  }
+  /**
+   * Turn this KaitoResponse 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
+   */
+  toResponse(body) {
+    const init = {
+      status: this._status
+    };
+    if (this._headers) {
+      init.headers = this._headers;
+    }
+    return Response.json(body, init);
+  }
+};
+
+// src/util.ts
+function createUtilities(getContext) {
+  return {
+    getContext,
+    router: () => Router.create()
+  };
+}
+function parsable(parse) {
+  return {
+    parse
+  };
+}
+
+// src/router/router.ts
+var Router = class _Router {
+  state;
+  static create = () => new _Router({
+    through: async (context) => context,
+    routes: /* @__PURE__ */ new Set()
+  });
+  static parseQuery(schema, url) {
+    if (!schema) {
+      return {};
+    }
+    const result = {};
+    for (const [key, parsable2] of Object.entries(schema)) {
+      const value = url.searchParams.get(key);
+      result[key] = parsable2.parse(value);
+    }
+    return result;
+  }
+  constructor(options) {
+    this.state = options;
+  }
+  get routes() {
+    return this.state.routes;
+  }
+  add = (method, path, route) => {
+    const merged = {
+      ...typeof route === "object" ? route : { run: route },
+      method,
+      path,
+      through: this.state.through
+    };
+    return new _Router({
+      ...this.state,
+      routes: /* @__PURE__ */ new Set([...this.state.routes, merged])
+    });
+  };
+  merge = (pathPrefix, other) => {
+    const newRoutes = [...other.state.routes].map((route) => ({
+      ...route,
+      path: `${pathPrefix}${route.path}`
+    }));
+    return new _Router({
+      ...this.state,
+      routes: /* @__PURE__ */ new Set([...this.state.routes, ...newRoutes])
+    });
+  };
+  freeze = (server) => {
+    const routes = /* @__PURE__ */ new Map();
+    for (const route of this.state.routes) {
+      if (!routes.has(route.path)) {
+        routes.set(route.path, /* @__PURE__ */ new Map());
+      }
+      routes.get(route.path).set(route.method, route);
+    }
+    const findRoute = (method, path) => {
+      const params = {};
+      const pathParts = path.split("/").filter(Boolean);
+      for (const [routePath, methodHandlers] of routes) {
+        const routeParts = routePath.split("/").filter(Boolean);
+        if (routeParts.length !== pathParts.length) continue;
+        let matches = true;
+        for (let i = 0; i < routeParts.length; i++) {
+          const routePart = routeParts[i];
+          const pathPart = pathParts[i];
+          if (routePart && pathPart && routePart.startsWith(":")) {
+            params[routePart.slice(1)] = pathPart;
+          } else if (routePart !== pathPart) {
+            matches = false;
+            break;
+          }
+        }
+        if (matches) {
+          const route = methodHandlers.get(method);
+          if (route) return { route, params };
+        }
+      }
+      return { params };
+    };
+    return async (req) => {
+      const url = new URL(req.url);
+      const method = req.method;
+      const { route, params } = findRoute(method, url.pathname);
+      if (!route) {
+        const body = {
+          success: false,
+          data: null,
+          message: `Cannot ${method} ${url.pathname}`
+        };
+        return Response.json(body, { status: 404 });
+      }
+      const request = new KaitoRequest(url, req);
+      const response = new KaitoResponse();
+      try {
+        const rootCtx = await server.getContext(request, response);
+        const ctx = await route.through(rootCtx);
+        const body = route.body ? await route.body.parse(await req.json()) : void 0;
+        const query = _Router.parseQuery(route.query, url);
+        const result = await route.run({
+          ctx,
+          body,
+          query,
+          params
+        });
+        if (result instanceof Response) {
+          return result;
+        }
+        return response.toResponse({
+          success: true,
+          data: result,
+          message: "OK"
+        });
+      } catch (e) {
+        const error = WrappedError.maybe(e);
+        if (error instanceof KaitoError) {
+          return response.status(error.status).toResponse({
+            success: false,
+            data: null,
+            message: error.message
+          });
+        }
+        const { status, message } = await server.onError({ error, req: request }).catch(() => ({ status: 500, message: "Internal Server Error" }));
+        return response.status(status).toResponse({
+          success: false,
+          data: null,
+          message
+        });
+      }
+    };
+  };
+  method = (method) => (path, route) => {
+    return this.add(method, path, route);
+  };
+  get = this.method("GET");
+  post = this.method("POST");
+  put = this.method("PUT");
+  patch = this.method("PATCH");
+  delete = this.method("DELETE");
+  head = this.method("HEAD");
+  options = this.method("OPTIONS");
+  through = (transform) => new _Router({
+    routes: this.state.routes,
+    through: async (context) => {
+      const fromCurrentRouter = await this.state.through(context);
+      return transform(fromCurrentRouter);
+    }
+  });
+};
+
+// src/server.ts
+function createKaitoHandler(config) {
+  const match = config.router.freeze(config);
+  return async (request) => {
+    let before = void 0;
+    if (config.before) {
+      const result = await config.before(request);
+      if (result instanceof Response) {
+        return result;
+      }
+      before = result;
+    }
+    const response = await match(request);
+    if ("after" in config && config.after) {
+      await config.after(before, response);
+    }
+    return response;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KaitoError,
+  KaitoRequest,
+  Router,
+  WrappedError,
+  createKaitoHandler,
+  createUtilities,
+  parsable
+});

package/dist/index.d.cts

@@ -0,0 +1,175 @@
+declare class WrappedError<T> extends Error {
+    readonly data: T;
+    static maybe<T>(maybeError: T): (T & Error) | WrappedError<T>;
+    static from<T>(data: T): WrappedError<T>;
+    private constructor();
+}
+declare class KaitoError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+
+declare class KaitoRequest {
+    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 similar to a `Response` object from the Web Fetch API, but
+ * this with no body stream, and is only used for setting status codes/headers.
+ *
+ * @example
+ * ```ts
+ * const response = new KaitoResponse();
+ *
+ * response.status = 200;
+ * response.header('Content-Type', 'application/json');
+ *
+ * console.log(response.headers); // Headers { 'content-type': 'application/json' }
+ * ```
+ */
+declare class KaitoResponse {
+    private _headers;
+    private _status;
+    constructor();
+    get headers(): Headers;
+    status(status: number): this;
+    /**
+     * Turn this KaitoResponse 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
+     */
+    toResponse<T>(body: APIResponse<T>): Response;
+}
+
+type Before<BeforeAfterContext> = (req: Request) => Promise<BeforeAfterContext | Response>;
+type After<BeforeAfterContext> = (ctx: BeforeAfterContext, response: Response) => 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>;
+    onError(arg: {
+        error: Error;
+        req: KaitoRequest;
+    }): Promise<KaitoError | {
+        status: number;
+        message: string;
+    }>;
+};
+declare function createKaitoHandler<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): (request: Request) => Promise<Response>;
+
+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<ServerConfig<ContextFrom, any>, "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>(transform: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
+}
+
+type ErroredAPIResponse = {
+    success: false;
+    data: null;
+    message: string;
+};
+type SuccessfulAPIResponse<T> = {
+    success: true;
+    data: T;
+    message: 'OK';
+};
+type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
+type AnyResponse = APIResponse<unknown>;
+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 GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
+/**
+ * A helper function to create typed necessary functions
+ *
+ * @example
+ * ```ts
+ * const {router, getContext} = createUtilities(async (req, res) => {
+ *   // Return context here
+ * })
+ *
+ * const app = router().get('/', async () => "hello");
+ *
+ * const server = createServer({
+ *   router: app,
+ *   getContext,
+ *   // ...
+ * });
+ * ```
+ */
+declare function createUtilities<Context>(getContext: GetContext<Context>): {
+    getContext: GetContext<Context>;
+    router: () => Router<Context, Context, never>;
+};
+interface Parsable<Output = any, Input = Output> {
+    _input: Input;
+    parse: (value: unknown) => Output;
+}
+type InferParsable<T> = T extends Parsable<infer Output, infer Input> ? {
+    input: Input;
+    output: Output;
+} : never;
+declare function parsable<T>(parse: (value: unknown) => T): Parsable<T, T>;
+
+type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
+    ctx: Context;
+    body: BodyOutput;
+    query: QueryOutput;
+    params: ExtractRouteParams<Path>;
+};
+type AnyQueryDefinition = Record<string, Parsable<any, string | undefined>>;
+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: Through<ContextFrom, ContextTo>;
+    body?: Body;
+    query?: Query;
+    path: Path;
+    method: Method;
+    run(arg: RouteArgument<Path, ContextTo, {
+        [Key in keyof Query]: InferParsable<Query[Key]>['output'];
+    }, InferParsable<Body>['output']>): Promise<Result>;
+};
+type AnyRoute<ContextFrom = any, ContextTo = any> = Route<ContextFrom, ContextTo, any, any, any, AnyQueryDefinition, any>;
+
+export { type APIResponse, type After, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type Parsable, type Route, type RouteArgument, Router, type RouterState, type ServerConfig, type ServerConfigWithBefore, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, parsable };

package/dist/index.d.ts

@@ -0,0 +1,175 @@
+declare class WrappedError<T> extends Error {
+    readonly data: T;
+    static maybe<T>(maybeError: T): (T & Error) | WrappedError<T>;
+    static from<T>(data: T): WrappedError<T>;
+    private constructor();
+}
+declare class KaitoError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+
+declare class KaitoRequest {
+    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 similar to a `Response` object from the Web Fetch API, but
+ * this with no body stream, and is only used for setting status codes/headers.
+ *
+ * @example
+ * ```ts
+ * const response = new KaitoResponse();
+ *
+ * response.status = 200;
+ * response.header('Content-Type', 'application/json');
+ *
+ * console.log(response.headers); // Headers { 'content-type': 'application/json' }
+ * ```
+ */
+declare class KaitoResponse {
+    private _headers;
+    private _status;
+    constructor();
+    get headers(): Headers;
+    status(status: number): this;
+    /**
+     * Turn this KaitoResponse 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
+     */
+    toResponse<T>(body: APIResponse<T>): Response;
+}
+
+type Before<BeforeAfterContext> = (req: Request) => Promise<BeforeAfterContext | Response>;
+type After<BeforeAfterContext> = (ctx: BeforeAfterContext, response: Response) => 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>;
+    onError(arg: {
+        error: Error;
+        req: KaitoRequest;
+    }): Promise<KaitoError | {
+        status: number;
+        message: string;
+    }>;
+};
+declare function createKaitoHandler<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): (request: Request) => Promise<Response>;
+
+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<ServerConfig<ContextFrom, any>, "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>(transform: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
+}
+
+type ErroredAPIResponse = {
+    success: false;
+    data: null;
+    message: string;
+};
+type SuccessfulAPIResponse<T> = {
+    success: true;
+    data: T;
+    message: 'OK';
+};
+type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
+type AnyResponse = APIResponse<unknown>;
+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 GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
+/**
+ * A helper function to create typed necessary functions
+ *
+ * @example
+ * ```ts
+ * const {router, getContext} = createUtilities(async (req, res) => {
+ *   // Return context here
+ * })
+ *
+ * const app = router().get('/', async () => "hello");
+ *
+ * const server = createServer({
+ *   router: app,
+ *   getContext,
+ *   // ...
+ * });
+ * ```
+ */
+declare function createUtilities<Context>(getContext: GetContext<Context>): {
+    getContext: GetContext<Context>;
+    router: () => Router<Context, Context, never>;
+};
+interface Parsable<Output = any, Input = Output> {
+    _input: Input;
+    parse: (value: unknown) => Output;
+}
+type InferParsable<T> = T extends Parsable<infer Output, infer Input> ? {
+    input: Input;
+    output: Output;
+} : never;
+declare function parsable<T>(parse: (value: unknown) => T): Parsable<T, T>;
+
+type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
+    ctx: Context;
+    body: BodyOutput;
+    query: QueryOutput;
+    params: ExtractRouteParams<Path>;
+};
+type AnyQueryDefinition = Record<string, Parsable<any, string | undefined>>;
+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: Through<ContextFrom, ContextTo>;
+    body?: Body;
+    query?: Query;
+    path: Path;
+    method: Method;
+    run(arg: RouteArgument<Path, ContextTo, {
+        [Key in keyof Query]: InferParsable<Query[Key]>['output'];
+    }, InferParsable<Body>['output']>): Promise<Result>;
+};
+type AnyRoute<ContextFrom = any, ContextTo = any> = Route<ContextFrom, ContextTo, any, any, any, AnyQueryDefinition, any>;
+
+export { type APIResponse, type After, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type Parsable, type Route, type RouteArgument, Router, type RouterState, type ServerConfig, type ServerConfigWithBefore, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, parsable };