[Hono] Generated handler cannot be implemeted (`Argument of type 'string' is not assignable to parameter of type 'never'`) about orval HOT 8 CLOSED

const responseValidator = factory.createMiddleware(async (c, next) => {
  await next();

  const data = c.res.json();

  const result = await createPetsResponse.safeParseAsync(data);

  if (!result.success) {
    c.res = new Response(JSON.stringify(result), {
      status: 400,
      headers: {
        'Content-Type': 'application/json',
      },
    });
  }

  c.res = new Response(c.res.body, c.res);
});

// based on https://github.com/honojs/middleware/blob/main/packages/zod-validator/src/index.ts
import type { z, ZodSchema, ZodError } from 'zod';
import {
  Context,
  Env,
  Input,
  MiddlewareHandler,
  TypedResponse,
  ValidationTargets,
} from 'hono';
type HasUndefined<T> = undefined extends T ? true : false;

type Hook<T, E extends Env, P extends string, O = {}> = (
  result:
    | { success: true; data: T }
    | { success: false; error: ZodError; data: T },
  c: Context<E, P>,
) =>
  | Response
  | Promise<Response>
  | void
  | Promise<Response | void>
  | TypedResponse<O>;

export const zResponseValidtor =
  <
    T extends ZodSchema,
    Target extends keyof ValidationTargets,
    E extends Env,
    P extends string,
    In = z.input<T>,
    Out = z.output<T>,
    I extends Input = {
      in: HasUndefined<In> extends true
        ? {
            [K in Target]?: K extends 'json'
              ? In
              : HasUndefined<keyof ValidationTargets[K]> extends true
              ? { [K2 in keyof In]?: ValidationTargets[K][K2] }
              : { [K2 in keyof In]: ValidationTargets[K][K2] };
          }
        : {
            [K in Target]: K extends 'json'
              ? In
              : HasUndefined<keyof ValidationTargets[K]> extends true
              ? { [K2 in keyof In]?: ValidationTargets[K][K2] }
              : { [K2 in keyof In]: ValidationTargets[K][K2] };
          };
      out: { [K in Target]: Out };
    },
    V extends I = I,
  >(
    schema: T,
    hook?: Hook<z.infer<T>, E, P>,
  ): MiddlewareHandler<E, P, V> =>
  async (c, next) => {
    await next();

    const clonedResponse = c.res.clone();

    let value: unknown;
    try {
      value = await clonedResponse.json();
    } catch {
      const message = 'Malformed JSON in response';
      c.res = new Response(message, { status: 400 });
    }

    const result = await schema.safeParseAsync(value);

    if (hook) {
      const hookResult = hook({ data: value, ...result }, c);
      if (hookResult) {
        if (hookResult instanceof Response || hookResult instanceof Promise) {
          const hookResponse = await hookResult;

          if (hookResponse instanceof Response) {
            c.res = new Response(hookResponse.body, hookResponse);
          }
        }
        if (
          'response' in hookResult &&
          hookResult.response instanceof Response
        ) {
          c.res = new Response(hookResult.response.body, hookResult.response);
        }
      }
    }

    if (!result.success) {
      c.res = new Response(JSON.stringify(result), {
        status: 400,
        headers: {
          'Content-Type': 'application/json',
        },
      });
    }
  };