@kosmojs/api 0.0.11 → 0.0.21

package/pkg/routes.d.ts

@@ -0,0 +1,5 @@
+import type { CreateRouteMiddleware, MiddlewareDefinition, Route, RouteSource } from "./types";
+export declare const createRoutes: <MiddlewareT, MiddlewareR>(routeSources: Array<RouteSource<MiddlewareT>>, { globalMiddleware, createRouteMiddleware, }: {
+    globalMiddleware: Array<MiddlewareDefinition<MiddlewareT>>;
+    createRouteMiddleware: CreateRouteMiddleware<MiddlewareT>;
+}) => Array<Route<MiddlewareR>>;

package/pkg/types.d.ts

@@ -0,0 +1,285 @@
+import type { ValidationErrorEntry } from "./errors/types";
+export declare enum HTTPMethods {
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS",
+    GET = "GET",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    POST = "POST",
+    DELETE = "DELETE"
+}
+export type HTTPMethod = keyof typeof HTTPMethods;
+export type MiddlewareDefinition<MiddlewareT> = {
+    kind: "middleware";
+    middleware: Array<MiddlewareT>;
+    options?: UseOptions | undefined;
+};
+export type HandlerDefinition<MiddlewareT> = {
+    kind: "handler";
+    middleware: Array<MiddlewareT>;
+    method: HTTPMethod;
+};
+export type RouteDefinitionItem<MiddlewareT> = MiddlewareDefinition<MiddlewareT> | HandlerDefinition<MiddlewareT>;
+export interface UseSlots {
+    errorHandler: string;
+    extendContext: string;
+    bodyparser: string;
+    "validate:params": string;
+    "validate:query": string;
+    "validate:headers": string;
+    "validate:cookies": string;
+    "validate:json": string;
+    "validate:form": string;
+    "validate:raw": string;
+    "validate:response": string;
+}
+export type UseOptions = {
+    on?: Array<HTTPMethod>;
+    slot?: keyof UseSlots;
+    debug?: string | undefined;
+};
+export type RouteSource<MiddlewareT> = {
+    name: string;
+    path: string;
+    pathPattern: string;
+    file: string;
+    cascadingMiddleware: [...a: Array<MiddlewareDefinition<MiddlewareT>>];
+    definitionItems: Array<RouteDefinitionItem<MiddlewareT>>;
+    params: Array<string>;
+    numericParams: Array<string>;
+    validationSchemas: ValidationSchemas;
+    meta?: Record<string, unknown>;
+};
+export type Route<MiddlewareT> = {
+    name: string;
+    path: string;
+    file: string;
+    methods: Array<string>;
+    middleware: Array<MiddlewareT>;
+    debug: {
+        headline: string;
+        methods: string;
+        middleware: string;
+        handler: string;
+        full: string;
+    };
+};
+export type DevSetup = {
+    /**
+     * API request handler for development mode.
+     *
+     * In dev mode, incoming requests are routed based on URL:
+     * - Requests matching apiurl routed to this handler (your API)
+     * - All other requests routed to Vite dev server (pages/assets)
+     *
+     * Returns a function that processes API requests.
+     * */
+    requestHandler: () => (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse) => Promise<void>;
+    /**
+     * Custom function to determine if a request should be handled by the API.
+     *
+     * By default, requests are routed to the API handler if their URL starts with `apiurl`.
+     * Use this to implement custom heuristics for detecting API requests.
+     * */
+    requestMatcher?: (req: import("node:http").IncomingMessage) => boolean;
+    /**
+     * In dev mode, perform cleanup operations before reloading the API handler.
+     * */
+    teardownHandler?: () => void | Promise<void>;
+};
+export type AppFactory<App, AppOptions = unknown> = (factory: (a: {
+    createApp: (o?: AppOptions) => App;
+}) => App) => App;
+export type RouterFactory<Router, RouterOptions = unknown> = (factory: (a: {
+    createRouter: (o?: RouterOptions) => Router;
+}) => Router) => Router;
+export type CreateRouteMiddleware<MiddlewareT> = (routeSource: RouteSource<MiddlewareT>) => Array<MiddlewareDefinition<MiddlewareT>>;
+export type CreateServer<App, Server> = (app: App, opt?: {
+    port?: number;
+    sock?: string;
+    callback?: () => void | Promise<void>;
+}) => Promise<Server>;
+export type ServerFactory<App, Server> = (factory: (a: {
+    createServer: CreateServer<App, Server>;
+}) => void) => void;
+/**
+ * Request metadata validation targets.
+ * */
+export declare const RequestMetadataTargets: {
+    readonly query: "URL query parameters";
+    readonly headers: "HTTP request headers";
+    readonly cookies: "HTTP cookies";
+};
+/**
+ * Request body validation targets.
+ *
+ * Body formats are mutually exclusive - only one should be specified per handler.
+ *
+ * **Development behavior:**
+ * - If multiple formats are defined, the builder displays a warning and
+ *   disables validation schemas for the affected handler.
+ * - If an unsuitable target is defined (e.g., `json`, `form`)
+ *   for a method without a body like GET, HEAD), a warning is displayed and
+ *   validation schemas are disabled for that handler.
+ *
+ * This ensures misconfigurations are detected during development
+ * for runtime to execute without false positive validation failures.
+ *
+ * Always define exactly one target that is suitable for current handler.
+ * */
+export declare const RequestBodyTargets: {
+    readonly json: "JSON request body";
+    readonly form: "URL-encoded or Multipart form";
+    readonly raw: "Raw body format (string/Buffer/ArrayBuffer/Blob)";
+};
+export declare const RequestValidationTargets: {
+    readonly json: "JSON request body";
+    readonly form: "URL-encoded or Multipart form";
+    readonly raw: "Raw body format (string/Buffer/ArrayBuffer/Blob)";
+    readonly query: "URL query parameters";
+    readonly headers: "HTTP request headers";
+    readonly cookies: "HTTP cookies";
+};
+export type RequestMetadataTarget = keyof typeof RequestMetadataTargets;
+export type RequestBodyTarget = keyof typeof RequestBodyTargets;
+export type RequestValidationTarget = keyof typeof RequestValidationTargets;
+export type ValidationTarget = RequestValidationTarget | "params" | "response";
+export type ValidationDefmap = Partial<{
+    /**
+     * Request metadata targets.
+     * */
+    query: Record<string, unknown>;
+    headers: Record<string, string>;
+    cookies: Record<string, unknown>;
+    /**
+     * Request body targets. One target per handler.
+     *
+     * POST<
+     *   json: { id: number }
+     *   // or form/raw
+     * >((ctx) => {})
+     * */
+    json: unknown;
+    form: Record<string, unknown>;
+    raw: string | Buffer | ArrayBuffer | Blob;
+    /**
+     * Response variants.
+     * Multiple variants can be specified via unions.
+     *
+     * POST<
+     *   response:
+     *     | [200, "json", User]
+     *     | [201, "json"]
+     *     | [301]
+     * >((ctx) => {})
+     * */
+    response: [
+        /**
+         * HTTP status code to send with the response.
+         * Common values: 200 (OK), 400 (Bad Request), 404 (Not Found), 500 (Internal Server Error)
+         * */
+        status: number,
+        /**
+         * Content-Type header for the response. Supports shorthand notation that gets
+         * resolved via mime-types lookup (e.g., "json" becomes "application/json",
+         * "html" becomes "text/html", "png" becomes "image/png")
+         * */
+        contentType?: string | undefined,
+        /** The response body schema */
+        body?: unknown
+    ];
+}>;
+export type ValidationCustomErrors = {
+    /**
+     * Custom error messages for validation failures.
+     *
+     * Use `error` to set a general error message for the entire validation target.
+     * Use `error.<fieldName>` to set specific error messages for individual fields.
+     *
+     * @example Override validation error messages
+     * POST<{
+     *   json: {
+     *     id: number;
+     *     email: string;
+     *     age: number;
+     *   }
+     * }, {
+     *   json: {
+     *     error: "Invalid user data provided",
+     *     "error.id": "User ID must be a valid number",
+     *     "error.email": "Please provide a valid email address",
+     *     "error.age": "Age must be a number"
+     *   }
+     * }>
+     * */
+    error?: string;
+} & {
+    [E in `error.${string}`]?: string;
+};
+export type ValidationOptions = {
+    /**
+     * Controls runtime validation for this target.
+     *
+     * By default, all validation targets are validated at runtime. Set this to
+     * `false` if you only need compile-time type checking without runtime validation.
+     *
+     * @example Disable runtime validation for JSON payload
+     * POST<{
+     *   json: Payload<User>
+     * }, {
+     *   json: {
+     *     runtimeValidation: false
+     *   }
+     * }>
+     * */
+    runtimeValidation?: boolean | undefined;
+    /**
+     * Specifies the request Content-Type for OpenAPI schema generation.
+     *
+     * When the validation target is `form`, the OpenAPI generator will include
+     * both `application/x-www-form-urlencoded` and `multipart/form-data` in the
+     * request body content types by default. This indicates the handler accepts
+     * either format, which may not be accurate for your use case.
+     *
+     * Use this option to explicitly declare which content type your handler expects.
+     * */
+    contentType?: string;
+} & ValidationCustomErrors;
+export type ValidationOptmap = {
+    [K in ValidationTarget]?: ValidationOptions;
+};
+export declare const StateKey: unique symbol;
+export type ExtendContext<ParamsT, VDefs extends ValidationDefmap, VOpts extends ValidationOptmap, BodyparserOptions extends Record<RequestBodyTarget, unknown>> = {
+    [StateKey]: Map<ValidationTarget, unknown>;
+    bodyparser: {
+        [T in RequestBodyTarget]: <R = unknown>(opts?: BodyparserOptions[T]) => Promise<R>;
+    };
+    validated: {
+        [K in keyof VDefs as K extends RequestValidationTarget ? VOpts[K] extends {
+            runtimeValidation: false;
+        } ? never : K : never]: VDefs[K];
+    } & {
+        params: ParamsT;
+    };
+};
+export type ValidationSchema = {
+    check: (data: unknown) => boolean;
+    errors: (data: unknown) => Array<ValidationErrorEntry>;
+    errorMessage: (data: unknown) => string;
+    errorSummary: (data: unknown) => string;
+    validate: (data: unknown) => void;
+};
+export type ValidationSchemas<Extend = object> = {
+    [T in RequestValidationTarget]?: Record<string, ValidationSchema & Extend & {
+        runtimeValidation?: boolean;
+        customErrors?: ValidationCustomErrors;
+    }>;
+} & {
+    params?: ValidationSchema & Extend;
+    response?: Record<string, Array<ValidationSchema & Extend & {
+        status: number;
+        contentType?: string;
+        runtimeValidation?: boolean;
+        customErrors?: ValidationCustomErrors;
+    }>>;
+};

package/pkg/bodyparser/index.js

@@ -1,111 +0,0 @@
-// src/bodyparser/index.ts
-import zlib from "node:zlib";
-import IncomingForm from "formidable";
-import rawParser from "raw-body";
-
-// src/bodyparser/config.ts
-var json = {
-  limit: 1024 ** 2,
-  trim: ["*"]
-};
-var form = {
-  limit: 1024 ** 2
-};
-var raw = {
-  limit: 1024 ** 2
-};
-var config_default = {
-  json,
-  form,
-  raw
-};
-
-// src/bodyparser/index.ts
-var bodyparser_default = { json: json2, form: form2, raw: raw2 };
-function json2(opts = {}) {
-  return [
-    async function useJSONBodyparser(ctx, next) {
-      const form3 = IncomingForm({
-        maxFieldsSize: opts.limit || config_default.json.limit,
-        ...opts
-      });
-      const trimmer = trimmerFactory(opts.trim);
-      ctx.request.body = await new Promise((resolve, reject) => {
-        form3.parse(ctx.request.req, (err, fields) => {
-          if (err) {
-            return reject(err);
-          }
-          resolve(trimmer ? trimmer(fields) : fields);
-        });
-      });
-      return next();
-    }
-  ];
-}
-function form2(opts = {}) {
-  return [
-    async function useFormBodyparser(ctx, next) {
-      const form3 = IncomingForm({
-        maxFieldsSize: opts.limit || config_default.form.limit,
-        maxFileSize: opts.limit || config_default.form.limit,
-        ...opts
-      });
-      let trimmer = trimmerFactory(opts.trim);
-      if (opts.multipart || opts.urlencoded) {
-        trimmer = void 0;
-      }
-      ctx.request.body = await new Promise((resolve, reject) => {
-        form3.parse(ctx.request.req, (err, fields, files) => {
-          if (err) {
-            return reject(err);
-          }
-          resolve({
-            fields: trimmer ? trimmer(fields) : fields,
-            files
-          });
-        });
-      });
-      return next();
-    }
-  ];
-}
-function raw2(opts = {}) {
-  return [
-    async function useRawBodyparser(ctx, next) {
-      const { chunkSize, ...rawParserOptions } = { ...config_default.raw, ...opts };
-      const stream = ctx.request.req.pipe(zlib.createUnzip({ chunkSize }));
-      ctx.request.body = await rawParser(stream, rawParserOptions);
-      return next();
-    }
-  ];
-}
-function trimmerFactory(trimOption) {
-  if (!Array.isArray(trimOption) || !trimOption.length) {
-    return;
-  }
-  const trimableKeys = trimOption.reduce((m, k) => {
-    m[k] = true;
-    return m;
-  }, {});
-  const trim = (key, val) => {
-    return typeof val === "string" ? trimableKeys[key] || trimableKeys["*"] ? val.trim() : val : val;
-  };
-  const reducer = (memo, [key, val]) => {
-    memo[key] = trim(key, val);
-    return memo;
-  };
-  return (payload) => Object.entries(payload).reduce(
-    reducer,
-    // accumulator is set to payload intentionally, to avoid duplication of big strings.
-    // if using a new object for accumulator then trimmed strings will be duplicated?
-    payload
-  );
-}
-export {
-  config_default as config,
-  bodyparser_default as default,
-  form2 as form,
-  json2 as json,
-  raw2 as raw
-};
-//# sourceMappingURL=index.js.map

package/pkg/bodyparser/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/bodyparser/index.ts", "../../src/bodyparser/config.ts"],
-  "sourcesContent": ["import zlib from \"node:zlib\";\n\nimport IncomingForm from \"formidable\";\nimport rawParser from \"raw-body\";\n\nimport type { ParameterizedMiddleware } from \"@kosmojs/api\";\n\nimport config from \"./config\";\nimport type {\n  FormOptions,\n  JsonOptions,\n  RawOptions,\n  Trimmer,\n  TrimOption,\n} from \"./types\";\n\nexport * from \"./types\";\nexport { config };\nexport default { json, form, raw };\n\nexport function json(opts: JsonOptions = {}): Array<ParameterizedMiddleware> {\n  return [\n    async function useJSONBodyparser(ctx, next) {\n      const form = IncomingForm({\n        maxFieldsSize: opts.limit || config.json.limit,\n        ...opts,\n      });\n\n      const trimmer = trimmerFactory(opts.trim);\n\n      ctx.request.body = await new Promise((resolve, reject) => {\n        form.parse(ctx.request.req, (err, fields) => {\n          if (err) {\n            return reject(err);\n          }\n\n          resolve(trimmer ? trimmer(fields) : fields);\n        });\n      });\n\n      return next();\n    },\n  ];\n}\n\nexport function form(opts: FormOptions = {}): Array<ParameterizedMiddleware> {\n  return [\n    async function useFormBodyparser(ctx, next) {\n      const form = IncomingForm({\n        maxFieldsSize: opts.limit || config.form.limit,\n        maxFileSize: opts.limit || config.form.limit,\n        ...opts,\n      });\n\n      let trimmer = trimmerFactory(opts.trim);\n\n      if (opts.multipart || opts.urlencoded) {\n        trimmer = undefined;\n      }\n\n      ctx.request.body = await new Promise((resolve, reject) => {\n        form.parse(ctx.request.req, (err, fields, files) => {\n          if (err) {\n            return reject(err);\n          }\n\n          resolve({\n            fields: trimmer ? trimmer(fields) : fields,\n            files,\n          });\n        });\n      });\n\n      return next();\n    },\n  ];\n}\n\nexport function raw(opts: RawOptions = {}): Array<ParameterizedMiddleware> {\n  return [\n    async function useRawBodyparser(ctx, next) {\n      const { chunkSize, ...rawParserOptions } = { ...config.raw, ...opts };\n\n      const stream = ctx.request.req.pipe(zlib.createUnzip({ chunkSize }));\n      ctx.request.body = await rawParser(stream, rawParserOptions);\n\n      return next();\n    },\n  ];\n}\n\nfunction trimmerFactory(\n  trimOption: TrimOption | undefined,\n): Trimmer | undefined {\n  if (!Array.isArray(trimOption) || !trimOption.length) {\n    return;\n  }\n\n  const trimableKeys: {\n    [key: string]: boolean;\n  } = trimOption.reduce((m: Record<string, boolean>, k) => {\n    m[k] = true;\n    return m;\n  }, {});\n\n  const trim = (key: string, val: unknown) => {\n    return typeof val === \"string\"\n      ? trimableKeys[key] || trimableKeys[\"*\"]\n        ? val.trim()\n        : val\n      : val;\n  };\n\n  const reducer = (\n    memo: Record<string, unknown>,\n    [key, val]: [string, unknown],\n  ) => {\n    memo[key] = trim(key, val);\n    return memo;\n  };\n\n  return (payload) =>\n    Object.entries(payload).reduce(\n      reducer,\n      // accumulator is set to payload intentionally, to avoid duplication of big strings.\n      // if using a new object for accumulator then trimmed strings will be duplicated?\n      payload,\n    );\n}\n", "import type { FormOptions, JsonOptions, RawOptions } from \"./types\";\n\nexport const json: JsonOptions = {\n  limit: 1024 ** 2,\n  trim: [\"*\"],\n};\n\nexport const form: FormOptions = {\n  limit: 1024 ** 2,\n};\n\nexport const raw: RawOptions = {\n  limit: 1024 ** 2,\n};\n\nexport default {\n  json,\n  form,\n  raw,\n};\n"],
-  "mappings": "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",
-  "names": ["json", "form", "raw"]
-}

package/pkg/queryparser/index.js

@@ -1,37 +0,0 @@
-// src/queryparser/index.ts
-import { parse, stringify } from "qs";
-var queryparser_default = (app, _parseOptions = {}, _stringifyOptions = {}) => {
-  const parseOptions = {
-    ignoreQueryPrefix: true,
-    parseArrays: true,
-    arrayLimit: 100,
-    parameterLimit: 100,
-    depth: 5,
-    ..._parseOptions
-  };
-  const stringifyOptions = {
-    encodeValuesOnly: true,
-    arrayFormat: "brackets",
-    ..._stringifyOptions
-  };
-  const obj = {
-    get query() {
-      return parse(this.querystring || "", parseOptions);
-    },
-    set query(obj2) {
-      this.querystring = stringify(obj2, stringifyOptions);
-    }
-  };
-  const entries = Object.getOwnPropertyNames(obj).map((name) => [
-    name,
-    Object.getOwnPropertyDescriptor(obj, name)
-  ]);
-  for (const [name, desc] of entries) {
-    Object.defineProperty(app.request, name, desc);
-  }
-  return app;
-};
-export {
-  queryparser_default as default
-};
-//# sourceMappingURL=index.js.map

package/pkg/queryparser/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/queryparser/index.ts"],
-  "sourcesContent": ["import type Koa from \"koa\";\nimport type { IParseOptions, IStringifyOptions } from \"qs\";\nimport { parse, stringify } from \"qs\";\n\nimport type { DefaultContext, DefaultState } from \"@/types\";\n\nexport default <\n  T extends InstanceType<typeof Koa<DefaultState, DefaultContext>> = never,\n>(\n  app: T,\n  _parseOptions: IParseOptions = {},\n  _stringifyOptions: IStringifyOptions = {},\n) => {\n  const parseOptions = {\n    ignoreQueryPrefix: true,\n    parseArrays: true,\n    arrayLimit: 100,\n    parameterLimit: 100,\n    depth: 5,\n    ..._parseOptions,\n  };\n\n  const stringifyOptions = {\n    encodeValuesOnly: true,\n    arrayFormat: \"brackets\",\n    ..._stringifyOptions,\n  } as const;\n\n  const obj = {\n    get query() {\n      return parse((this as Koa.Request).querystring || \"\", parseOptions);\n    },\n\n    set query(obj: object) {\n      (this as Koa.Request).querystring = stringify(obj, stringifyOptions);\n    },\n  };\n\n  const entries = Object.getOwnPropertyNames(obj).map((name) => [\n    name,\n    Object.getOwnPropertyDescriptor(obj, name),\n  ]) as [name: string, desc: PropertyDescriptor][];\n\n  for (const [name, desc] of entries) {\n    Object.defineProperty(app.request, name, desc);\n  }\n\n  return app;\n};\n"],
-  "mappings": ";AAEA,SAAS,OAAO,iBAAiB;AAIjC,IAAO,sBAAQ,CAGb,KACA,gBAA+B,CAAC,GAChC,oBAAuC,CAAC,MACrC;AACH,QAAM,eAAe;AAAA,IACnB,mBAAmB;AAAA,IACnB,aAAa;AAAA,IACb,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB,OAAO;AAAA,IACP,GAAG;AAAA,EACL;AAEA,QAAM,mBAAmB;AAAA,IACvB,kBAAkB;AAAA,IAClB,aAAa;AAAA,IACb,GAAG;AAAA,EACL;AAEA,QAAM,MAAM;AAAA,IACV,IAAI,QAAQ;AACV,aAAO,MAAO,KAAqB,eAAe,IAAI,YAAY;AAAA,IACpE;AAAA,IAEA,IAAI,MAAMA,MAAa;AACrB,MAAC,KAAqB,cAAc,UAAUA,MAAK,gBAAgB;AAAA,IACrE;AAAA,EACF;AAEA,QAAM,UAAU,OAAO,oBAAoB,GAAG,EAAE,IAAI,CAAC,SAAS;AAAA,IAC5D;AAAA,IACA,OAAO,yBAAyB,KAAK,IAAI;AAAA,EAC3C,CAAC;AAED,aAAW,CAAC,MAAM,IAAI,KAAK,SAAS;AAClC,WAAO,eAAe,IAAI,SAAS,MAAM,IAAI;AAAA,EAC/C;AAEA,SAAO;AACT;",
-  "names": ["obj"]
-}

package/pkg/src/app.d.ts

@@ -1,2 +0,0 @@
-import type { CreateApp } from "./types";
-export declare const createApp: CreateApp;

package/pkg/src/bodyparser/config.d.ts

@@ -1,10 +0,0 @@
-import type { FormOptions, JsonOptions, RawOptions } from "./types";
-export declare const json: JsonOptions;
-export declare const form: FormOptions;
-export declare const raw: RawOptions;
-declare const _default: {
-    json: JsonOptions;
-    form: FormOptions;
-    raw: RawOptions;
-};
-export default _default;

package/pkg/src/bodyparser/index.d.ts

@@ -1,14 +0,0 @@
-import type { ParameterizedMiddleware } from "@kosmojs/api";
-import config from "./config";
-import type { FormOptions, JsonOptions, RawOptions } from "./types";
-export * from "./types";
-export { config };
-declare const _default: {
-    json: typeof json;
-    form: typeof form;
-    raw: typeof raw;
-};
-export default _default;
-export declare function json(opts?: JsonOptions): Array<ParameterizedMiddleware>;
-export declare function form(opts?: FormOptions): Array<ParameterizedMiddleware>;
-export declare function raw(opts?: RawOptions): Array<ParameterizedMiddleware>;

package/pkg/src/bodyparser/types.d.ts

@@ -1,39 +0,0 @@
-import type { Options as FormidableOptions } from "formidable";
-export type TrimOption = Array<string>;
-export type Trimmer = (fields: Record<string, unknown>) => Record<string, unknown>;
-type GenericOptions = {
-    limit?: number;
-    trim?: TrimOption;
-};
-export type JsonOptions = FormidableOptions & GenericOptions;
-export type FormOptions = FormidableOptions & GenericOptions & {
-    uploadDir?: string;
-    multipart?: boolean;
-    urlencoded?: boolean;
-};
-export type RawOptions = {
-    /**
-     * The byte limit of the body.
-     * If the body ends up being larger than this limit, a 413 error code is returned.
-     * */
-    limit?: number;
-    /**
-     * The length of the stream.
-     * If the contents of the stream do not add up to this length,
-     * an 400 error code is returned
-     * */
-    length?: number;
-    /**
-     * The encoding to use to decode the body into a string.
-     * By default, a Buffer instance will be returned when no encoding is specified.
-     * utf-8 would decode as plain text.
-     * use any encoding supported by iconv-lite.
-     * */
-    encoding?: string;
-    /**
-     * zlib options
-     * */
-    chunkSize?: number;
-};
-export type Options = JsonOptions | FormOptions | RawOptions;
-export {};

package/pkg/src/debug.d.ts

@@ -1,10 +0,0 @@
-import type { HandlerDefinition, MiddlewareDefinition, RouterRoute } from "./types";
-declare const _default: (entry: {
-    name: string;
-    path: string;
-    file: string;
-    methods: Array<string>;
-    middleware: Array<MiddlewareDefinition>;
-    handler: HandlerDefinition;
-}) => RouterRoute["debug"];
-export default _default;

package/pkg/src/errors.d.ts

@@ -1,19 +0,0 @@
-import type { ParameterizedMiddleware, ValidationErrorData, ValidationErrorEntry, ValidationErrorScope } from "./types";
-/**
- * Standardized error wrapper used by validation generators.
- *
- * Instances of this class are thrown whenever validation fails,
- * carrying both the error scope (e.g. `"params"`, `"payload"`)
- * and the list of validation error details.
- */
-export declare class ValidationError extends Error {
-    scope: ValidationErrorScope;
-    errors: Array<ValidationErrorEntry>;
-    errorMessage: string;
-    errorSummary: string;
-    constructor([scope, { errors, errorMessage, errorSummary }]: [
-        ValidationErrorScope,
-        ValidationErrorData
-    ]);
-}
-export declare const createErrorHandler: (handler: ParameterizedMiddleware) => ParameterizedMiddleware;

package/pkg/src/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./app";
-export * from "./errors";
-export * from "./router";
-export * from "./types";
-export * from "./use";

package/pkg/src/queryparser/index.d.ts

@@ -1,5 +0,0 @@
-import type Koa from "koa";
-import type { IParseOptions, IStringifyOptions } from "qs";
-import type { DefaultContext, DefaultState } from "../types";
-declare const _default: <T extends InstanceType<typeof Koa<DefaultState, DefaultContext>> = never>(app: T, _parseOptions?: IParseOptions, _stringifyOptions?: IStringifyOptions) => T;
-export default _default;

package/pkg/src/router.d.ts

@@ -1,6 +0,0 @@
-import type { CreateRouter, DefineRoute, MiddlewareDefinition, RouterRoute, RouterRouteSource } from "./types";
-export declare const createRouter: CreateRouter;
-export declare const defineRoute: DefineRoute;
-export declare const routerRoutesFactory: (routeSources: Array<RouterRouteSource>, { coreMiddleware, }: {
-    coreMiddleware: Array<MiddlewareDefinition>;
-}) => Array<RouterRoute>;