@hono/zod-openapi 0.11.0 → 0.12.0

package/README.md

@@ -51,8 +51,7 @@ const UserSchema = z
   .openapi('User')
 ```
 
-> [!TIP]
-> `UserSchema` schema will be registered as `"#/components/schemas/User"` refs in the OpenAPI document.
+> [!TIP] > `UserSchema` schema will be registered as `"#/components/schemas/User"` refs in the OpenAPI document.
 > If you want to register the schema as referenced components, use `.openapi()` method.
 
 Next, create a route:
@@ -88,11 +87,14 @@ const app = new OpenAPIHono()
 
 app.openapi(route, (c) => {
   const { id } = c.req.valid('param')
-  return c.json({
-    id,
-    age: 20,
-    name: 'Ultra-man',
-  })
+  return c.json(
+    {
+      id,
+      age: 20,
+      name: 'Ultra-man',
+    },
+    200 // You should specify the status code even if it is 200.
+  )
 })
 
 // The OpenAPI documentation will be available at /doc
@@ -157,11 +159,14 @@ app.openapi(
   route,
   (c) => {
     const { id } = c.req.valid('param')
-    return c.json({
-      id,
-      age: 20,
-      name: 'Ultra-man',
-    })
+    return c.json(
+      {
+        id,
+        age: 20,
+        name: 'Ultra-man',
+      },
+      200
+    )
   },
   // Hook
   (result, c) => {
@@ -213,7 +218,7 @@ app.openapi(
   createBookRoute,
   (c) => {
     const { title } = c.req.valid('json')
-    return c.json({ title })
+    return c.json({ title }, 200)
   },
   (result, c) => {
     if (!result.success) {
@@ -234,8 +239,8 @@ app.openapi(
 You can generate OpenAPI v3.1 spec using the following methods:
 
 ```ts
-app.doc31('/docs', {openapi: '3.1.0'}) // new endpoint
-app.getOpenAPI31Document({openapi: '3.1.0'}) // raw json
+app.doc31('/docs', { openapi: '3.1.0' }) // new endpoint
+app.getOpenAPI31Document({ openapi: '3.1.0' }) // raw json
 ```
 
 ### The Registry
@@ -279,10 +284,7 @@ const route = createRoute({
   request: {
     params: ParamsSchema,
   },
-  middleware: [
-    prettyJSON(),
-    cache({ cacheName: 'my-cache' })
-  ],
+  middleware: [prettyJSON(), cache({ cacheName: 'my-cache' })],
   responses: {
     200: {
       content: {
@@ -305,10 +307,13 @@ import { hc } from 'hono/client'
 
 const appRoutes = app.openapi(route, (c) => {
   const data = c.req.valid('json')
-  return c.json({
-    id: data.id,
-    message: 'Success',
-  })
+  return c.json(
+    {
+      id: data.id,
+      message: 'Success',
+    },
+    200
+  )
 })
 
 const client = hc<typeof appRoutes>('http://localhost:8787/')
@@ -337,9 +342,9 @@ eg. Bearer Auth
 Register the security scheme:
 
 ```ts
-app.openAPIRegistry.registerComponent("securitySchemes", "Bearer", {
-  type: "http",
-  scheme: "bearer",
+app.openAPIRegistry.registerComponent('securitySchemes', 'Bearer', {
+  type: 'http',
+  scheme: 'bearer',
 })
 ```
 
@@ -361,7 +366,7 @@ const route = createRoute({
 You can access the context in `app.doc` as follows:
 
 ```ts
-app.doc('/doc', c => ({
+app.doc('/doc', (c) => ({
   openapi: '3.0.0',
   info: {
     version: '1.0.0',

package/dist/index.d.mts

@@ -1,9 +1,10 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
 import * as openapi3_ts_oas30 from 'openapi3-ts/oas30';
-import { ZodMediaTypeObject, OpenAPIRegistry, RouteConfig as RouteConfig$1, ZodRequestBody, ZodContentObject, ResponseConfig } from '@asteasolutions/zod-to-openapi';
+import { ZodMediaTypeObject, OpenAPIRegistry, RouteConfig as RouteConfig$1, ZodRequestBody, ZodContentObject } from '@asteasolutions/zod-to-openapi';
 import { OpenAPIObjectConfig } from '@asteasolutions/zod-to-openapi/dist/v3.0/openapi-generator';
-import { Env, Context, TypedResponse, Input, Handler, Schema, Hono, ToSchema, MiddlewareHandler } from 'hono';
+import { TypedResponse, Env, Context, Input, Handler, Schema, Hono, ToSchema, MiddlewareHandler } from 'hono';
 import { MergePath, MergeSchemaPath } from 'hono/types';
+import { StatusCode } from 'hono/utils/http-status';
 import { RemoveBlankRecord } from 'hono/utils/types';
 import { ZodError, AnyZodObject, z, ZodSchema, ZodType } from 'zod';
 export { z } from 'zod';
@@ -49,45 +50,79 @@ type InputTypeParam<R extends RouteConfig> = InputTypeBase<R, 'params', 'param'>
 type InputTypeQuery<R extends RouteConfig> = InputTypeBase<R, 'query', 'query'>;
 type InputTypeHeader<R extends RouteConfig> = InputTypeBase<R, 'headers', 'header'>;
 type InputTypeCookie<R extends RouteConfig> = InputTypeBase<R, 'cookies', 'cookie'>;
-type OutputType<R extends RouteConfig> = R['responses'] extends Record<infer _, infer C> ? C extends ResponseConfig ? C['content'] extends ZodContentObject ? IsJson<keyof C['content']> extends never ? {} : C['content'][keyof C['content']] extends Record<'schema', ZodSchema> ? z.infer<C['content'][keyof C['content']]['schema']> : {} : {} : {} : {};
-type Hook<T, E extends Env, P extends string, O> = (result: {
+type ExtractContent<T> = T extends {
+    [K in keyof T]: infer A;
+} ? A extends Record<'schema', ZodSchema> ? z.infer<A['schema']> : never : never;
+type RouteConfigToTypedResponse<R extends RouteConfig> = {
+    [Status in keyof R['responses'] & StatusCode]: IsJson<keyof R['responses'][Status]['content']> extends never ? TypedResponse<{}, Status, string> : TypedResponse<ExtractContent<R['responses'][Status]['content']>, Status, 'json'>;
+}[keyof R['responses'] & StatusCode];
+type Hook<T, E extends Env, P extends string, R> = (result: {
     success: true;
     data: T;
 } | {
     success: false;
     error: ZodError;
-}, c: Context<E, P>) => TypedResponse<O> | Promise<TypedResponse<T>> | Response | Promise<Response> | void;
+}, c: Context<E, P>) => R;
 type ConvertPathType<T extends string> = T extends `${infer Start}/{${infer Param}}${infer Rest}` ? `${Start}/:${Param}${ConvertPathType<Rest>}` : T;
-type HandlerTypedResponse<O> = TypedResponse<O> | Promise<TypedResponse<O>>;
-type HandlerAllResponse<O> = Response | Promise<Response> | TypedResponse<O> | Promise<TypedResponse<O>>;
 type OpenAPIHonoOptions<E extends Env> = {
     defaultHook?: Hook<any, E, any, any>;
 };
 type HonoInit<E extends Env> = ConstructorParameters<typeof Hono>[0] & OpenAPIHonoOptions<E>;
 type RouteHandler<R extends RouteConfig, E extends Env = Env, I extends Input = InputTypeParam<R> & InputTypeQuery<R> & InputTypeHeader<R> & InputTypeCookie<R> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R['path']>> = Handler<E, P, I, R extends {
     responses: {
-        [statusCode: string]: {
+        [statusCode: number]: {
             content: {
                 [mediaType: string]: ZodMediaTypeObject;
             };
         };
     };
-} ? HandlerTypedResponse<OutputType<R>> : HandlerAllResponse<OutputType<R>>>;
-type RouteHook<R extends RouteConfig, E extends Env = Env, I extends Input = InputTypeParam<R> & InputTypeQuery<R> & InputTypeHeader<R> & InputTypeCookie<R> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R['path']>> = Hook<I, E, P, OutputType<R>>;
+} ? RouteConfigToTypedResponse<R> : RouteConfigToTypedResponse<R> | Response | Promise<Response>>;
+type RouteHook<R extends RouteConfig, E extends Env = Env, I extends Input = InputTypeParam<R> & InputTypeQuery<R> & InputTypeHeader<R> & InputTypeCookie<R> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R['path']>> = Hook<I, E, P, RouteConfigToTypedResponse<R> | Response | Promise<Response> | void | Promise<void>>;
 type OpenAPIObjectConfigure<E extends Env, P extends string> = OpenAPIObjectConfig | ((context: Context<E, P>) => OpenAPIObjectConfig);
 declare class OpenAPIHono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> extends Hono<E, S, BasePath> {
     openAPIRegistry: OpenAPIRegistry;
     defaultHook?: OpenAPIHonoOptions<E>['defaultHook'];
     constructor(init?: HonoInit<E>);
+    /**
+     *
+     * @param {RouteConfig} route - The route definition which you create with `createRoute()`.
+     * @param {Handler} handler - The handler. If you want to return a JSON object, you should specify the status code with `c.json()`.
+     * @param {Hook} hook - Optional. The hook method defines what it should do after validation.
+     * @example
+     * app.openapi(
+     *   route,
+     *   (c) => {
+     *     // ...
+     *     return c.json(
+     *       {
+     *         age: 20,
+     *         name: 'Young man',
+     *       },
+     *       200 // You should specify the status code even if it's 200.
+     *     )
+     *   },
+     *  (result, c) => {
+     *    if (!result.success) {
+     *      return c.json(
+     *        {
+     *          code: 400,
+     *          message: 'Custom Message',
+     *        },
+     *        400
+     *      )
+     *    }
+     *  }
+     *)
+     */
     openapi: <R extends RouteConfig, I extends Input = InputTypeBase<R, "params", "param"> & InputTypeBase<R, "query", "query"> & InputTypeBase<R, "headers", "header"> & InputTypeBase<R, "cookies", "cookie"> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R["path"]>>(route: R, handler: Handler<E, P, I, R extends {
         responses: {
-            [statusCode: string]: {
+            [statusCode: number]: {
                 content: {
                     [mediaType: string]: ZodMediaTypeObject;
                 };
             };
         };
-    } ? HandlerTypedResponse<OutputType<R>> : HandlerAllResponse<OutputType<R>>>, hook?: Hook<I, E, P, OutputType<R>> | undefined) => OpenAPIHono<E, S & ToSchema<R['method'], MergePath<BasePath, P>, I['in'], OutputType<R>>, BasePath>;
+    } ? RouteConfigToTypedResponse<R> : RouteConfigToTypedResponse<R> | Response | Promise<Response>>, hook?: Hook<I, E, P, RouteConfigToTypedResponse<R> | Response | Promise<Response> | void | Promise<void>> | undefined) => OpenAPIHono<E, S & ToSchema<R['method'], MergePath<BasePath, P>, I, RouteConfigToTypedResponse<R>>, BasePath>;
     getOpenAPIDocument: (config: OpenAPIObjectConfig) => openapi3_ts_oas30.OpenAPIObject;
     getOpenAPI31Document: (config: OpenAPIObjectConfig) => openapi3_ts_oas31.OpenAPIObject;
     doc: <P extends string>(path: P, configure: OpenAPIObjectConfigure<E, P>) => OpenAPIHono<E, S & ToSchema<'get', P, {}, {}>, BasePath>;
@@ -103,4 +138,4 @@ declare const createRoute: <P extends string, R extends Omit<RouteConfig, "path"
     getRoutingPath(): RoutingPath<R['path']>;
 };
 
-export { type Hook, OpenAPIHono, type OpenAPIHonoOptions, type OpenAPIObjectConfigure, type RouteHandler, type RouteHook, createRoute };
+export { type Hook, OpenAPIHono, type OpenAPIHonoOptions, type OpenAPIObjectConfigure, type RouteConfigToTypedResponse, type RouteHandler, type RouteHook, createRoute };

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
 import * as openapi3_ts_oas30 from 'openapi3-ts/oas30';
-import { ZodMediaTypeObject, OpenAPIRegistry, RouteConfig as RouteConfig$1, ZodRequestBody, ZodContentObject, ResponseConfig } from '@asteasolutions/zod-to-openapi';
+import { ZodMediaTypeObject, OpenAPIRegistry, RouteConfig as RouteConfig$1, ZodRequestBody, ZodContentObject } from '@asteasolutions/zod-to-openapi';
 import { OpenAPIObjectConfig } from '@asteasolutions/zod-to-openapi/dist/v3.0/openapi-generator';
-import { Env, Context, TypedResponse, Input, Handler, Schema, Hono, ToSchema, MiddlewareHandler } from 'hono';
+import { TypedResponse, Env, Context, Input, Handler, Schema, Hono, ToSchema, MiddlewareHandler } from 'hono';
 import { MergePath, MergeSchemaPath } from 'hono/types';
+import { StatusCode } from 'hono/utils/http-status';
 import { RemoveBlankRecord } from 'hono/utils/types';
 import { ZodError, AnyZodObject, z, ZodSchema, ZodType } from 'zod';
 export { z } from 'zod';
@@ -49,45 +50,79 @@ type InputTypeParam<R extends RouteConfig> = InputTypeBase<R, 'params', 'param'>
 type InputTypeQuery<R extends RouteConfig> = InputTypeBase<R, 'query', 'query'>;
 type InputTypeHeader<R extends RouteConfig> = InputTypeBase<R, 'headers', 'header'>;
 type InputTypeCookie<R extends RouteConfig> = InputTypeBase<R, 'cookies', 'cookie'>;
-type OutputType<R extends RouteConfig> = R['responses'] extends Record<infer _, infer C> ? C extends ResponseConfig ? C['content'] extends ZodContentObject ? IsJson<keyof C['content']> extends never ? {} : C['content'][keyof C['content']] extends Record<'schema', ZodSchema> ? z.infer<C['content'][keyof C['content']]['schema']> : {} : {} : {} : {};
-type Hook<T, E extends Env, P extends string, O> = (result: {
+type ExtractContent<T> = T extends {
+    [K in keyof T]: infer A;
+} ? A extends Record<'schema', ZodSchema> ? z.infer<A['schema']> : never : never;
+type RouteConfigToTypedResponse<R extends RouteConfig> = {
+    [Status in keyof R['responses'] & StatusCode]: IsJson<keyof R['responses'][Status]['content']> extends never ? TypedResponse<{}, Status, string> : TypedResponse<ExtractContent<R['responses'][Status]['content']>, Status, 'json'>;
+}[keyof R['responses'] & StatusCode];
+type Hook<T, E extends Env, P extends string, R> = (result: {
     success: true;
     data: T;
 } | {
     success: false;
     error: ZodError;
-}, c: Context<E, P>) => TypedResponse<O> | Promise<TypedResponse<T>> | Response | Promise<Response> | void;
+}, c: Context<E, P>) => R;
 type ConvertPathType<T extends string> = T extends `${infer Start}/{${infer Param}}${infer Rest}` ? `${Start}/:${Param}${ConvertPathType<Rest>}` : T;
-type HandlerTypedResponse<O> = TypedResponse<O> | Promise<TypedResponse<O>>;
-type HandlerAllResponse<O> = Response | Promise<Response> | TypedResponse<O> | Promise<TypedResponse<O>>;
 type OpenAPIHonoOptions<E extends Env> = {
     defaultHook?: Hook<any, E, any, any>;
 };
 type HonoInit<E extends Env> = ConstructorParameters<typeof Hono>[0] & OpenAPIHonoOptions<E>;
 type RouteHandler<R extends RouteConfig, E extends Env = Env, I extends Input = InputTypeParam<R> & InputTypeQuery<R> & InputTypeHeader<R> & InputTypeCookie<R> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R['path']>> = Handler<E, P, I, R extends {
     responses: {
-        [statusCode: string]: {
+        [statusCode: number]: {
             content: {
                 [mediaType: string]: ZodMediaTypeObject;
             };
         };
     };
-} ? HandlerTypedResponse<OutputType<R>> : HandlerAllResponse<OutputType<R>>>;
-type RouteHook<R extends RouteConfig, E extends Env = Env, I extends Input = InputTypeParam<R> & InputTypeQuery<R> & InputTypeHeader<R> & InputTypeCookie<R> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R['path']>> = Hook<I, E, P, OutputType<R>>;
+} ? RouteConfigToTypedResponse<R> : RouteConfigToTypedResponse<R> | Response | Promise<Response>>;
+type RouteHook<R extends RouteConfig, E extends Env = Env, I extends Input = InputTypeParam<R> & InputTypeQuery<R> & InputTypeHeader<R> & InputTypeCookie<R> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R['path']>> = Hook<I, E, P, RouteConfigToTypedResponse<R> | Response | Promise<Response> | void | Promise<void>>;
 type OpenAPIObjectConfigure<E extends Env, P extends string> = OpenAPIObjectConfig | ((context: Context<E, P>) => OpenAPIObjectConfig);
 declare class OpenAPIHono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> extends Hono<E, S, BasePath> {
     openAPIRegistry: OpenAPIRegistry;
     defaultHook?: OpenAPIHonoOptions<E>['defaultHook'];
     constructor(init?: HonoInit<E>);
+    /**
+     *
+     * @param {RouteConfig} route - The route definition which you create with `createRoute()`.
+     * @param {Handler} handler - The handler. If you want to return a JSON object, you should specify the status code with `c.json()`.
+     * @param {Hook} hook - Optional. The hook method defines what it should do after validation.
+     * @example
+     * app.openapi(
+     *   route,
+     *   (c) => {
+     *     // ...
+     *     return c.json(
+     *       {
+     *         age: 20,
+     *         name: 'Young man',
+     *       },
+     *       200 // You should specify the status code even if it's 200.
+     *     )
+     *   },
+     *  (result, c) => {
+     *    if (!result.success) {
+     *      return c.json(
+     *        {
+     *          code: 400,
+     *          message: 'Custom Message',
+     *        },
+     *        400
+     *      )
+     *    }
+     *  }
+     *)
+     */
     openapi: <R extends RouteConfig, I extends Input = InputTypeBase<R, "params", "param"> & InputTypeBase<R, "query", "query"> & InputTypeBase<R, "headers", "header"> & InputTypeBase<R, "cookies", "cookie"> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R["path"]>>(route: R, handler: Handler<E, P, I, R extends {
         responses: {
-            [statusCode: string]: {
+            [statusCode: number]: {
                 content: {
                     [mediaType: string]: ZodMediaTypeObject;
                 };
             };
         };
-    } ? HandlerTypedResponse<OutputType<R>> : HandlerAllResponse<OutputType<R>>>, hook?: Hook<I, E, P, OutputType<R>> | undefined) => OpenAPIHono<E, S & ToSchema<R['method'], MergePath<BasePath, P>, I['in'], OutputType<R>>, BasePath>;
+    } ? RouteConfigToTypedResponse<R> : RouteConfigToTypedResponse<R> | Response | Promise<Response>>, hook?: Hook<I, E, P, RouteConfigToTypedResponse<R> | Response | Promise<Response> | void | Promise<void>> | undefined) => OpenAPIHono<E, S & ToSchema<R['method'], MergePath<BasePath, P>, I, RouteConfigToTypedResponse<R>>, BasePath>;
     getOpenAPIDocument: (config: OpenAPIObjectConfig) => openapi3_ts_oas30.OpenAPIObject;
     getOpenAPI31Document: (config: OpenAPIObjectConfig) => openapi3_ts_oas31.OpenAPIObject;
     doc: <P extends string>(path: P, configure: OpenAPIObjectConfigure<E, P>) => OpenAPIHono<E, S & ToSchema<'get', P, {}, {}>, BasePath>;
@@ -103,4 +138,4 @@ declare const createRoute: <P extends string, R extends Omit<RouteConfig, "path"
     getRoutingPath(): RoutingPath<R['path']>;
 };
 
-export { type Hook, OpenAPIHono, type OpenAPIHonoOptions, type OpenAPIObjectConfigure, type RouteHandler, type RouteHook, createRoute };
+export { type Hook, OpenAPIHono, type OpenAPIHonoOptions, type OpenAPIObjectConfigure, type RouteConfigToTypedResponse, type RouteHandler, type RouteHook, createRoute };

package/dist/index.js

@@ -39,6 +39,37 @@ var OpenAPIHono = class _OpenAPIHono extends import_hono.Hono {
     this.openAPIRegistry = new import_zod_to_openapi.OpenAPIRegistry();
     this.defaultHook = init?.defaultHook;
   }
+  /**
+   *
+   * @param {RouteConfig} route - The route definition which you create with `createRoute()`.
+   * @param {Handler} handler - The handler. If you want to return a JSON object, you should specify the status code with `c.json()`.
+   * @param {Hook} hook - Optional. The hook method defines what it should do after validation.
+   * @example
+   * app.openapi(
+   *   route,
+   *   (c) => {
+   *     // ...
+   *     return c.json(
+   *       {
+   *         age: 20,
+   *         name: 'Young man',
+   *       },
+   *       200 // You should specify the status code even if it's 200.
+   *     )
+   *   },
+   *  (result, c) => {
+   *    if (!result.success) {
+   *      return c.json(
+   *        {
+   *          code: 400,
+   *          message: 'Custom Message',
+   *        },
+   *        400
+   *      )
+   *    }
+   *  }
+   *)
+   */
   openapi = (route, handler, hook = this.defaultHook) => {
     this.openAPIRegistry.registerPath(route);
     const validators = [];
@@ -79,7 +110,13 @@ var OpenAPIHono = class _OpenAPIHono extends import_hono.Hono {
       }
     }
     const middleware = route.middleware ? Array.isArray(route.middleware) ? route.middleware : [route.middleware] : [];
-    this.on([route.method], route.path.replaceAll(/\/{(.+?)}/g, "/:$1"), ...middleware, ...validators, handler);
+    this.on(
+      [route.method],
+      route.path.replaceAll(/\/{(.+?)}/g, "/:$1"),
+      ...middleware,
+      ...validators,
+      handler
+    );
     return this;
   };
   getOpenAPIDocument = (config) => {

package/dist/index.mjs

@@ -17,6 +17,37 @@ var OpenAPIHono = class _OpenAPIHono extends Hono {
     this.openAPIRegistry = new OpenAPIRegistry();
     this.defaultHook = init?.defaultHook;
   }
+  /**
+   *
+   * @param {RouteConfig} route - The route definition which you create with `createRoute()`.
+   * @param {Handler} handler - The handler. If you want to return a JSON object, you should specify the status code with `c.json()`.
+   * @param {Hook} hook - Optional. The hook method defines what it should do after validation.
+   * @example
+   * app.openapi(
+   *   route,
+   *   (c) => {
+   *     // ...
+   *     return c.json(
+   *       {
+   *         age: 20,
+   *         name: 'Young man',
+   *       },
+   *       200 // You should specify the status code even if it's 200.
+   *     )
+   *   },
+   *  (result, c) => {
+   *    if (!result.success) {
+   *      return c.json(
+   *        {
+   *          code: 400,
+   *          message: 'Custom Message',
+   *        },
+   *        400
+   *      )
+   *    }
+   *  }
+   *)
+   */
   openapi = (route, handler, hook = this.defaultHook) => {
     this.openAPIRegistry.registerPath(route);
     const validators = [];
@@ -57,7 +88,13 @@ var OpenAPIHono = class _OpenAPIHono extends Hono {
       }
     }
     const middleware = route.middleware ? Array.isArray(route.middleware) ? route.middleware : [route.middleware] : [];
-    this.on([route.method], route.path.replaceAll(/\/{(.+?)}/g, "/:$1"), ...middleware, ...validators, handler);
+    this.on(
+      [route.method],
+      route.path.replaceAll(/\/{(.+?)}/g, "/:$1"),
+      ...middleware,
+      ...validators,
+      handler
+    );
     return this;
   };
   getOpenAPIDocument = (config) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/zod-openapi",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "A wrapper class of Hono which supports OpenAPI.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -37,12 +37,12 @@
   },
   "homepage": "https://github.com/honojs/middleware",
   "peerDependencies": {
-    "hono": ">=3.11.3",
+    "hono": ">=4.3.6",
     "zod": "3.*"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20240117.0",
-    "hono": "^4.2.2",
+    "hono": "^4.3.6",
     "jest": "^29.7.0",
     "openapi3-ts": "^4.1.2",
     "tsup": "^8.0.1",