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

package/dist/index.cjs

@@ -0,0 +1,290 @@
+"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,
+  apiresponse: () => apiresponse,
+  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 {
+  request;
+  _url;
+  constructor(request) {
+    this.request = request;
+  }
+  get headers() {
+    return this.request.headers;
+  }
+  get method() {
+    return this.request.method;
+  }
+  get url() {
+    return this.request.url;
+  }
+  parseURL() {
+    if (!this._url) {
+      this._url = new URL(this.url);
+    }
+    return this._url;
+  }
+  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();
+  }
+};
+
+// src/util.ts
+function apiresponse(status, response) {
+  return Response.json(response, {
+    status
+  });
+}
+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) {
+        return apiresponse(404, {
+          success: false,
+          data: null,
+          message: `Cannot ${method} ${url.pathname}`
+        });
+      }
+      const request = new KaitoRequest(req);
+      try {
+        const rootCtx = await server.getContext(request);
+        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
+        });
+        return apiresponse(200, {
+          success: true,
+          data: result,
+          message: "OK"
+        });
+      } catch (e) {
+        const error = WrappedError.maybe(e);
+        if (error instanceof KaitoError) {
+          return apiresponse(error.status, {
+            success: false,
+            data: null,
+            message: error.message
+          });
+        }
+        const { status, message } = await server.onError({ error, req: request }).catch(() => ({ status: 500, message: "Internal Server Error" }));
+        return apiresponse(status, {
+          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,
+  apiresponse,
+  createKaitoHandler,
+  createUtilities,
+  parsable
+});

package/dist/index.d.cts

@@ -0,0 +1,149 @@
+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 {
+    private readonly request;
+    private _url;
+    constructor(request: Request);
+    get headers(): Headers;
+    get method(): string;
+    get url(): string;
+    parseURL(): URL;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    formData(): Promise<FormData>;
+    bytes(): Promise<Uint8Array>;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}
+
+type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
+
+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: ServerConfig<ContextFrom, any>) => (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>;
+declare function apiresponse<T>(status: number, response: APIResponse<T>): Response;
+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) => 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, apiresponse, createKaitoHandler, createUtilities, parsable };

package/dist/index.d.ts

@@ -0,0 +1,149 @@
+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 {
+    private readonly request;
+    private _url;
+    constructor(request: Request);
+    get headers(): Headers;
+    get method(): string;
+    get url(): string;
+    parseURL(): URL;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    formData(): Promise<FormData>;
+    bytes(): Promise<Uint8Array>;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}
+
+type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
+
+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: ServerConfig<ContextFrom, any>) => (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>;
+declare function apiresponse<T>(status: number, response: APIResponse<T>): Response;
+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) => 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, apiresponse, createKaitoHandler, createUtilities, parsable };