hono 4.3.11 → 4.4.0

package/dist/types/jsx/jsx-dev-runtime.d.ts

@@ -1,3 +1,8 @@
+/**
+ * @module
+ * This module provides Hono's JSX dev runtime.
+ */
 import type { JSXNode } from './base';
 export { Fragment } from './base';
+export type { JSX } from './base';
 export declare function jsxDEV(tag: string | Function, props: Record<string, unknown>, key?: string): JSXNode;

package/dist/types/jsx/jsx-runtime.d.ts

@@ -1,5 +1,10 @@
+/**
+ * @module
+ * This module provides Hono's JSX runtime.
+ */
 export { jsxDEV as jsx, Fragment } from './jsx-dev-runtime';
 export { jsxDEV as jsxs } from './jsx-dev-runtime';
+export type { JSX } from './jsx-dev-runtime';
 import { html } from '../helper/html';
 import type { HtmlEscapedString } from '../utils/html';
 export { html as jsxTemplate };

package/dist/types/jsx/streaming.d.ts

@@ -1,5 +1,9 @@
+/**
+ * @module
+ * This module enables JSX to supports streaming Response.
+ */
 import type { HtmlEscapedString } from '../utils/html';
-import type { FC, PropsWithChildren } from '.';
+import type { FC, PropsWithChildren } from './';
 /**
  * @experimental
  * `Suspense` is an experimental feature.

package/dist/types/jsx/types.d.ts

@@ -2,6 +2,7 @@
  * All types exported from "hono/jsx" are in this file.
  */
 import type { Child, JSXNode } from './base';
+import type { Hono } from './intrinsic-elements';
 export type { Child, JSXNode, FC } from './base';
 export type { RefObject } from './hooks';
 export type { Context } from './context';

package/dist/types/middleware/basic-auth/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * Basic Auth Middleware for Hono.
+ */
 import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
 type BasicAuthOptions = {
@@ -10,6 +14,37 @@ type BasicAuthOptions = {
     realm?: string;
     hashFunction?: Function;
 };
+/**
+ * Basic Auth Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/basic-auth}
+ *
+ * @param {BasicAuthOptions} options - The options for the basic authentication middleware.
+ * @param {string} options.username - The username for authentication.
+ * @param {string} options.password - The password for authentication.
+ * @param {string} [options.realm="Secure Area"] - The realm attribute for the WWW-Authenticate header.
+ * @param {Function} [options.hashFunction] - The hash function used for secure comparison.
+ * @param {Function} [options.verifyUser] - The function to verify user credentials.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ * @throws {HTTPException} If neither "username and password" nor "verifyUser" options are provided.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(
+ *   '/auth/*',
+ *   basicAuth({
+ *     username: 'hono',
+ *     password: 'acoolproject',
+ *   })
+ * )
+ *
+ * app.get('/auth/page', (c) => {
+ *   return c.text('You are authorized')
+ * })
+ * ```
+ */
 export declare const basicAuth: (options: BasicAuthOptions, ...users: {
     username: string;
     password: string;

package/dist/types/middleware/bearer-auth/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * Bearer Auth Middleware for Hono.
+ */
 import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
 type BearerAuthOptions = {
@@ -13,5 +17,34 @@ type BearerAuthOptions = {
     verifyToken: (token: string, c: Context) => boolean | Promise<boolean>;
     hashFunction?: Function;
 };
+/**
+ * Bearer Auth Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/bearer-auth}
+ *
+ * @param {BearerAuthOptions} options - The options for the bearer authentication middleware.
+ * @param {string | string[]} [options.token] - The string or array of strings to validate the incoming bearer token against.
+ * @param {Function} [options.verifyToken] - The function to verify the token.
+ * @param {string} [options.realm=""] - The domain name of the realm, as part of the returned WWW-Authenticate challenge header.
+ * @param {string} [options.prefix="Bearer"] - The prefix (or known as `schema`) for the Authorization header value.
+ * @param {string} [options.headerName=Authorization] - The header name.
+ * @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ * @throws {Error} If neither "token" nor "verifyToken" options are provided.
+ * @throws {HTTPException} If authentication fails, with 401 status code for missing or invalid token, or 400 status code for invalid request.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * const token = 'honoiscool'
+ *
+ * app.use('/api/*', bearerAuth({ token }))
+ *
+ * app.get('/api/page', (c) => {
+ *   return c.json({ message: 'You are authorized' })
+ * })
+ * ```
+ */
 export declare const bearerAuth: (options: BearerAuthOptions) => MiddlewareHandler;
 export {};

package/dist/types/middleware/body-limit/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * Body Limit Middleware for Hono.
+ */
 import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
 type OnError = (c: Context) => Response | Promise<Response>;
@@ -6,21 +10,34 @@ type BodyLimitOptions = {
     onError?: OnError;
 };
 /**
- * Body Limit Middleware
+ * Body Limit Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/body-limit}
+ *
+ * @param {BodyLimitOptions} options - The options for the body limit middleware.
+ * @param {number} options.maxSize - The maximum body size allowed.
+ * @param {OnError} [options.onError] - The error handler to be invoked if the specified body size is exceeded.
+ * @returns {MiddlewareHandler} The middleware handler function.
  *
  * @example
  * ```ts
+ * const app = new Hono()
+ *
  * app.post(
- *  '/hello',
- *  bodyLimit({
- *    maxSize: 100 * 1024, // 100kb
- *    onError: (c) => {
- *      return c.text('overflow :(', 413)
- *    }
- *  }),
- *  (c) => {
- *    return c.text('pass :)')
- *  }
+ *   '/upload',
+ *   bodyLimit({
+ *     maxSize: 50 * 1024, // 50kb
+ *     onError: (c) => {
+ *       return c.text('overflow :(', 413)
+ *     },
+ *   }),
+ *   async (c) => {
+ *     const body = await c.req.parseBody()
+ *     if (body['file'] instanceof File) {
+ *       console.log(`Got file sized: ${body['file'].size}`)
+ *     }
+ *     return c.text('pass :)')
+ *   }
  * )
  * ```
  */

package/dist/types/middleware/cache/index.d.ts

@@ -1,5 +1,34 @@
+/**
+ * @module
+ * Cache Middleware for Hono.
+ */
 import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
+/**
+ * Cache Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/cache}
+ *
+ * @param {Object} options - The options for the cache middleware.
+ * @param {string | Function} options.cacheName - The name of the cache. Can be used to store multiple caches with different identifiers.
+ * @param {boolean} [options.wait=false] - A boolean indicating if Hono should wait for the Promise of the `cache.put` function to resolve before continuing with the request. Required to be true for the Deno environment.
+ * @param {string} [options.cacheControl] - A string of directives for the `Cache-Control` header.
+ * @param {string | string[]} [options.vary] - Sets the `Vary` header in the response. If the original response header already contains a `Vary` header, the values are merged, removing any duplicates.
+ * @param {Function} [options.keyGenerator] - Generates keys for every request in the `cacheName` store. This can be used to cache data based on request parameters or context parameters.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ * @throws {Error} If the `vary` option includes "*".
+ *
+ * @example
+ * ```ts
+ * app.get(
+ *   '*',
+ *   cache({
+ *     cacheName: 'my-app',
+ *     cacheControl: 'max-age=3600',
+ *   })
+ * )
+ * ```
+ */
 export declare const cache: (options: {
     cacheName: string | ((c: Context) => Promise<string> | string);
     wait?: boolean | undefined;

package/dist/types/middleware/compress/index.d.ts

@@ -1,7 +1,27 @@
+/**
+ * @module
+ * Compress Middleware for Hono.
+ */
 import type { MiddlewareHandler } from '../../types';
 declare const ENCODING_TYPES: readonly ["gzip", "deflate"];
 interface CompressionOptions {
     encoding?: (typeof ENCODING_TYPES)[number];
 }
+/**
+ * Compress Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/compress}
+ *
+ * @param {CompressionOptions} [options] - The options for the compress middleware.
+ * @param {'gzip' | 'deflate'} [options.encoding] - The compression scheme to allow for response compression. Either 'gzip' or 'deflate'. If not defined, both are allowed and will be used based on the Accept-Encoding header. 'gzip' is prioritized if this option is not provided and the client provides both in the Accept-Encoding header.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(compress())
+ * ```
+ */
 export declare const compress: (options?: CompressionOptions) => MiddlewareHandler;
 export {};

package/dist/types/middleware/cors/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * CORS Middleware for Hono.
+ */
 import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
 type CORSOptions = {
@@ -8,5 +12,44 @@ type CORSOptions = {
     credentials?: boolean;
     exposeHeaders?: string[];
 };
+/**
+ * CORS Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/cors}
+ *
+ * @param {CORSOptions} [options] - The options for the CORS middleware.
+ * @param {string | string[] | ((origin: string, c: Context) => string | undefined | null)} [options.origin='*'] - The value of "Access-Control-Allow-Origin" CORS header.
+ * @param {string[]} [options.allowMethods=['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH']] - The value of "Access-Control-Allow-Methods" CORS header.
+ * @param {string[]} [options.allowHeaders=[]] - The value of "Access-Control-Allow-Headers" CORS header.
+ * @param {number} [options.maxAge] - The value of "Access-Control-Max-Age" CORS header.
+ * @param {boolean} [options.credentials] - The value of "Access-Control-Allow-Credentials" CORS header.
+ * @param {string[]} [options.exposeHeaders=[]] - The value of "Access-Control-Expose-Headers" CORS header.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use('/api/*', cors())
+ * app.use(
+ *   '/api2/*',
+ *   cors({
+ *     origin: 'http://example.com',
+ *     allowHeaders: ['X-Custom-Header', 'Upgrade-Insecure-Requests'],
+ *     allowMethods: ['POST', 'GET', 'OPTIONS'],
+ *     exposeHeaders: ['Content-Length', 'X-Kuma-Revision'],
+ *     maxAge: 600,
+ *     credentials: true,
+ *   })
+ * )
+ *
+ * app.all('/api/abc', (c) => {
+ *   return c.json({ success: true })
+ * })
+ * app.all('/api2/abc', (c) => {
+ *   return c.json({ success: true })
+ * })
+ * ```
+ */
 export declare const cors: (options?: CORSOptions) => MiddlewareHandler;
 export {};

package/dist/types/middleware/csrf/index.d.ts

@@ -1,8 +1,49 @@
+/**
+ * @module
+ * CSRF Protection Middleware for Hono.
+ */
 import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
 type IsAllowedOriginHandler = (origin: string, context: Context) => boolean;
 interface CSRFOptions {
     origin?: string | string[] | IsAllowedOriginHandler;
 }
+/**
+ * CSRF Protection Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/csrf}
+ *
+ * @param {CSRFOptions} [options] - The options for the CSRF protection middleware.
+ * @param {string|string[]|(origin: string, context: Context) => boolean} [options.origin] - Specify origins.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(csrf())
+ *
+ * // Specifying origins with using `origin` option
+ * // string
+ * app.use(csrf({ origin: 'myapp.example.com' }))
+ *
+ * // string[]
+ * app.use(
+ *   csrf({
+ *     origin: ['myapp.example.com', 'development.myapp.example.com'],
+ *   })
+ * )
+ *
+ * // Function
+ * // It is strongly recommended that the protocol be verified to ensure a match to `$`.
+ * // You should *never* do a forward match.
+ * app.use(
+ *   '*',
+ *   csrf({
+ *     origin: (origin) => /https:\/\/(\w+\.)?myapp\.example\.com$/.test(origin),
+ *   })
+ * )
+ * ```
+ */
 export declare const csrf: (options?: CSRFOptions) => MiddlewareHandler;
 export {};

package/dist/types/middleware/etag/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * ETag Middleware for Hono.
+ */
 import type { MiddlewareHandler } from '../../types';
 type ETagOptions = {
     retainedHeaders?: string[];
@@ -10,5 +14,25 @@ type ETagOptions = {
  * > Content-Location, Date, ETag, Expires, and Vary.
  */
 export declare const RETAINED_304_HEADERS: string[];
+/**
+ * ETag Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/etag}
+ *
+ * @param {ETagOptions} [options] - The options for the ETag middleware.
+ * @param {boolean} [options.weak=false] - Define using or not using a weak validation. If true is set, then `W/` is added to the prefix of the value.
+ * @param {string[]} [options.retainedHeaders=RETAINED_304_HEADERS] - The headers that you want to retain in the 304 Response.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use('/etag/*', etag())
+ * app.get('/etag/abc', (c) => {
+ *   return c.text('Hono is cool')
+ * })
+ * ```
+ */
 export declare const etag: (options?: ETagOptions) => MiddlewareHandler;
 export {};

package/dist/types/middleware/jsx-renderer/index.d.ts

@@ -1,6 +1,9 @@
+/**
+ * @module
+ * JSR Renderer Middleware for Hono.
+ */
 import type { Context, PropsForRenderer } from '../../context';
-import type { FC, PropsWithChildren } from '../../jsx';
-import type { Context as JSXContext } from '../../jsx';
+import type { FC, Context as JSXContext, PropsWithChildren } from '../../jsx';
 import type { Env, Input, MiddlewareHandler } from '../../types';
 import type { HtmlEscapedString } from '../../utils/html';
 export declare const RequestContext: JSXContext<Context<any, any, {}> | null>;
@@ -11,6 +14,64 @@ type RendererOptions = {
 type ComponentWithChildren = (props: PropsWithChildren<PropsForRenderer & {
     Layout: FC;
 }>, c: Context) => HtmlEscapedString | Promise<HtmlEscapedString>;
+/**
+ * JSX Renderer Middleware for hono.
+ *
+ * @see {@link{https://hono.dev/middleware/builtin/jsx-renderer}}
+ *
+ * @param {ComponentWithChildren} [component] - The component to render, which can accept children and props.
+ * @param {RendererOptions} [options] - The options for the JSX renderer middleware.
+ * @param {boolean | string} [options.docType=true] - The DOCTYPE to be added at the beginning of the HTML. If set to false, no DOCTYPE will be added.
+ * @param {boolean | Record<string, string>} [options.stream=false] - If set to true, enables streaming response with default headers. If a record is provided, custom headers will be used.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.get(
+ *   '/page/*',
+ *   jsxRenderer(({ children }) => {
+ *     return (
+ *       <html>
+ *         <body>
+ *           <header>Menu</header>
+ *           <div>{children}</div>
+ *         </body>
+ *       </html>
+ *     )
+ *   })
+ * )
+ *
+ * app.get('/page/about', (c) => {
+ *   return c.render(<h1>About me!</h1>)
+ * })
+ * ```
+ */
 export declare const jsxRenderer: (component?: ComponentWithChildren, options?: RendererOptions) => MiddlewareHandler;
+/**
+ * useRequestContext for Hono.
+ *
+ * @template E - The environment type.
+ * @template P - The parameter type.
+ * @template I - The input type.
+ * @returns {Context<E, P, I>} An instance of Context.
+ *
+ * @example
+ * ```ts
+ * const RequestUrlBadge: FC = () => {
+ *   const c = useRequestContext()
+ *   return <b>{c.req.url}</b>
+ * }
+ *
+ * app.get('/page/info', (c) => {
+ *   return c.render(
+ *     <div>
+ *       You are accessing: <RequestUrlBadge />
+ *     </div>
+ *   )
+ * })
+ * ```
+ */
 export declare const useRequestContext: <E extends Env = any, P extends string = any, I extends Input = {}>() => Context<E, P, I>;
 export {};

package/dist/types/middleware/jwt/index.d.ts

@@ -1,19 +1,7 @@
-import type { MiddlewareHandler } from '../../types';
-import '../../context';
-import type { SignatureAlgorithm } from '../../utils/jwt/jwa';
-declare module '../../context' {
-    interface ContextVariableMap {
-        jwtPayload: any;
+import type { JwtVariables } from './jwt';
+export type { JwtVariables };
+export { jwt, verify, decode, sign } from './jwt';
+declare module '../..' {
+    interface ContextVariableMap extends JwtVariables {
     }
 }
-export declare const jwt: (options: {
-    secret: string;
-    cookie?: string;
-    alg?: SignatureAlgorithm;
-}) => MiddlewareHandler;
-export declare const verify: (token: string, publicKey: import("../../utils/jwt/jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<import("../../utils/jwt/types").JWTPayload>;
-export declare const decode: (token: string) => {
-    header: import("../../utils/jwt/jwt").TokenHeader;
-    payload: import("../../utils/jwt/types").JWTPayload;
-};
-export declare const sign: (payload: import("../../utils/jwt/types").JWTPayload, privateKey: import("../../utils/jwt/jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<string>;

package/dist/types/middleware/jwt/jwt.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @module
+ * JWT Auth Middleware for Hono.
+ */
+import type { MiddlewareHandler } from '../../types';
+import '../../context';
+import type { SignatureAlgorithm } from '../../utils/jwt/jwa';
+export type JwtVariables = {
+    jwtPayload: any;
+};
+/**
+ * JWT Auth Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/jwt}
+ *
+ * @param {object} options - The options for the JWT middleware.
+ * @param {string} [options.secret] - A value of your secret key.
+ * @param {string} [options.cookie] - If this value is set, then the value is retrieved from the cookie header using that value as a key, which is then validated as a token.
+ * @param {SignatureAlgorithm} [options.alg=HS256] - An algorithm type that is used for verifying. Available types are `HS256` | `HS384` | `HS512` | `RS256` | `RS384` | `RS512` | `PS256` | `PS384` | `PS512` | `ES256` | `ES384` | `ES512` | `EdDSA`.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(
+ *   '/auth/*',
+ *   jwt({
+ *     secret: 'it-is-very-secret',
+ *   })
+ * )
+ *
+ * app.get('/auth/page', (c) => {
+ *   return c.text('You are authorized')
+ * })
+ * ```
+ */
+export declare const jwt: (options: {
+    secret: string;
+    cookie?: string;
+    alg?: SignatureAlgorithm;
+}) => MiddlewareHandler;
+export declare const verify: (token: string, publicKey: import("../../utils/jwt/jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<import("../../utils/jwt/types").JWTPayload>;
+export declare const decode: (token: string) => {
+    header: import("../../utils/jwt/jwt").TokenHeader;
+    payload: import("../../utils/jwt/types").JWTPayload;
+};
+export declare const sign: (payload: import("../../utils/jwt/types").JWTPayload, privateKey: import("../../utils/jwt/jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<string>;

package/dist/types/middleware/logger/index.d.ts

@@ -1,4 +1,24 @@
+/**
+ * @module
+ * Logger Middleware for Hono.
+ */
 import type { MiddlewareHandler } from '../../types';
 type PrintFunc = (str: string, ...rest: string[]) => void;
+/**
+ * Logger Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/logger}
+ *
+ * @param {PrintFunc} [fn=console.log] - Optional function for customized logging behavior.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(logger())
+ * app.get('/', (c) => c.text('Hello Hono!'))
+ * ```
+ */
 export declare const logger: (fn?: PrintFunc) => MiddlewareHandler;
 export {};

package/dist/types/middleware/method-override/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * Method Override Middleware for Hono.
+ */
 import type { Hono } from '../../hono';
 import type { MiddlewareHandler } from '../../types';
 type MethodOverrideOptions = {
@@ -16,21 +20,29 @@ type MethodOverrideOptions = {
     query: string;
 });
 /**
- * Method Override Middleware
+ * Method Override Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/method-override}
+ *
+ * @param {MethodOverrideOptions} options - The options for the method override middleware.
+ * @param {Hono} options.app - The instance of Hono is used in your application.
+ * @param {string} [options.form=_method] - Form key with a value containing the method name.
+ * @param {string} [options.header] - Header name with a value containing the method name.
+ * @param {string} [options.query] - Query parameter key with a value containing the method name.
+ * @returns {MiddlewareHandler} The middleware handler function.
  *
  * @example
- * // with form input method
+ * ```ts
  * const app = new Hono()
- * app.use('/books/*', methodOverride({ app })) // the default `form` value is `_method`
- * app.use('/authors/*', methodOverride({ app, form: 'method' }))
  *
- * @example
- * // with custom header
- * app.use('/books/*', methodOverride({ app, header: 'X-HTTP-METHOD-OVERRIDE' }))
+ * // If no options are specified, the value of `_method` in the form,
+ * // e.g. DELETE, is used as the method.
+ * app.use('/posts', methodOverride({ app }))
  *
- * @example
- * // with query parameter
- * app.use('/books/*', methodOverride({ app, query: '_method' }))
+ * app.delete('/posts', (c) => {
+ *   // ....
+ * })
+ * ```
  */
 export declare const methodOverride: (options: MethodOverrideOptions) => MiddlewareHandler;
 export {};

package/dist/types/middleware/powered-by/index.d.ts

@@ -1,2 +1,6 @@
+/**
+ * @module
+ * Powered By Middleware for Hono.
+ */
 import type { MiddlewareHandler } from '../../types';
 export declare const poweredBy: () => MiddlewareHandler;

package/dist/types/middleware/pretty-json/index.d.ts

@@ -1,6 +1,29 @@
+/**
+ * @module
+ * Pretty JSON Middleware for Hono.
+ */
 import type { MiddlewareHandler } from '../../types';
 type prettyOptions = {
     space: number;
 };
+/**
+ * Pretty JSON Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/middleware/builtin/pretty-json}
+ *
+ * @param {prettyOptions} [options] - The options for the pretty JSON middleware.
+ * @param {number} [options.space=2] - Number of spaces for indentation.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(prettyJSON()) // With options: prettyJSON({ space: 4 })
+ * app.get('/', (c) => {
+ *   return c.json({ message: 'Hono!' })
+ * })
+ * ```
+ */
 export declare const prettyJSON: (options?: prettyOptions) => MiddlewareHandler;
 export {};