hono

• contextStorage

  /**
   * Context Storage Middleware for Hono.
   *
   * @see {@link https://hono.dev/docs/middleware/builtin/context-storage}
   *
   * @returns {MiddlewareHandler} The middleware handler function.
   *
   * @example
   * ```ts
   * type Env = {
   *   Variables: {
   *     message: string
   *   }
   * }
   *
   * const app = new Hono<Env>()
   *
   * app.use(contextStorage())
   *
   * app.use(async (c, next) => {
   *   c.set('message', 'Hono is cool!!)
   *   await next()
   * })
   *
   * app.get('/', async (c) => { c.text(getMessage()) })
   *
   * const getMessage = () => {
   *   return getContext<Env>().var.message
   * }
   * ```
   */
  export declare const contextStorage: () => MiddlewareHandler;

• getContext

  export declare const getContext: <E extends Env = Env>() => Context<E, any, {}>;

/**
 * @module
 * Context Storage Middleware for Hono.
 */
import type { Context } from '../../context';
import type { Env, MiddlewareHandler } from '../../types';
/**
 * Context Storage Middleware for Hono.
 *
 * @see {@link https://hono.dev/docs/middleware/builtin/context-storage}
 *
 * @returns {MiddlewareHandler} The middleware handler function.
 *
 * @example
 * ```ts
 * type Env = {
 *   Variables: {
 *     message: string
 *   }
 * }
 *
 * const app = new Hono<Env>()
 *
 * app.use(contextStorage())
 *
 * app.use(async (c, next) => {
 *   c.set('message', 'Hono is cool!!)
 *   await next()
 * })
 *
 * app.get('/', async (c) => { c.text(getMessage()) })
 *
 * const getMessage = () => {
 *   return getContext<Env>().var.message
 * }
 * ```
 */
export declare const contextStorage: () => MiddlewareHandler;
export declare const getContext: <E extends Env = Env>() => Context<E, any, {}>;

• Root

  export interface Root {
      render(children: Child): void;
      unmount(): void;
  }

• RootOptions

  export type RootOptions = Record<string, unknown>;

• createRoot

  /**
   * Create a root object for rendering
   * @param element Render target
   * @param options Options for createRoot (not supported yet)
   * @returns Root object has `render` and `unmount` methods
   */
  export declare const createRoot: (element: HTMLElement | DocumentFragment, options?: RootOptions) => Root;

• hydrateRoot

  /**
   * Create a root object and hydrate app to the target element.
   * In hono/jsx/dom, hydrate is equivalent to render.
   * @param element Render target
   * @param reactNode A JSXNode to render
   * @param options Options for createRoot (not supported yet)
   * @returns Root object has `render` and `unmount` methods
   */
  export declare const hydrateRoot: (element: HTMLElement | DocumentFragment, reactNode: Child, options?: RootOptions) => Root;

/**
 * @module
 * This module provides APIs for `hono/jsx/dom/client`, which is compatible with `react-dom/client`.
 */
import type { Child } from '../base';
export interface Root {
    render(children: Child): void;
    unmount(): void;
}
export type RootOptions = Record<string, unknown>;
/**
 * Create a root object for rendering
 * @param element Render target
 * @param options Options for createRoot (not supported yet)
 * @returns Root object has `render` and `unmount` methods
 */
export declare const createRoot: (element: HTMLElement | DocumentFragment, options?: RootOptions) => Root;
/**
 * Create a root object and hydrate app to the target element.
 * In hono/jsx/dom, hydrate is equivalent to render.
 * @param element Render target
 * @param reactNode A JSXNode to render
 * @param options Options for createRoot (not supported yet)
 * @returns Root object has `render` and `unmount` methods
 */
export declare const hydrateRoot: (element: HTMLElement | DocumentFragment, reactNode: Child, options?: RootOptions) => Root;
declare const _default: {
    createRoot: (element: HTMLElement | DocumentFragment, options?: RootOptions) => Root;
    hydrateRoot: (element: HTMLElement | DocumentFragment, reactNode: Child, options?: RootOptions) => Root;
};
export default _default;

• MessageFunction

  type MessageFunction = (c: Context) => string | object | Promise<string | object>;

• BearerAuthOptions

  type BearerAuthOptions = {
      token: string | string[];
      realm?: string;
      prefix?: string;
      headerName?: string;
      hashFunction?: Function;
      noAuthenticationHeaderMessage?: string | object | MessageFunction;
      invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
      invalidTokenMessage?: string | object | MessageFunction;
  } | {
      realm?: string;
      prefix?: string;
      headerName?: string;
      verifyToken: (token: string, c: Context) => boolean | Promise<boolean>;
      hashFunction?: Function;
      noAuthenticationHeaderMessage?: string | object | MessageFunction;
      invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
      invalidTokenMessage?: string | object | MessageFunction;
  };

• bearerAuth

  /**
   * Bearer Auth Middleware for Hono.
   *
   * @see {@link https://hono.dev/docs/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. If set to the empty string, no prefix is expected.
   * @param {string} [options.headerName=Authorization] - The header name.
   * @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
   * @param {string | object | MessageFunction} [options.noAuthenticationHeaderMessage="Unauthorized"] - The no authentication header message.
   * @param {string | object | MessageFunction} [options.invalidAuthenticationHeaderMeasage="Bad Request"] - The invalid authentication header message.
   * @param {string | object | MessageFunction} [options.invalidTokenMessage="Unauthorized"] - The invalid token message.
   * @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;

/**
 * @module
 * Bearer Auth Middleware for Hono.
 */
import type { Context } from '../../context';
import type { MiddlewareHandler } from '../../types';
type MessageFunction = (c: Context) => string | object | Promise<string | object>;
type BearerAuthOptions = {
    token: string | string[];
    realm?: string;
    prefix?: string;
    headerName?: string;
    hashFunction?: Function;
    noAuthenticationHeaderMessage?: string | object | MessageFunction;
    invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
    invalidTokenMessage?: string | object | MessageFunction;
} | {
    realm?: string;
    prefix?: string;
    headerName?: string;
    verifyToken: (token: string, c: Context) => boolean | Promise<boolean>;
    hashFunction?: Function;
    noAuthenticationHeaderMessage?: string | object | MessageFunction;
    invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
    invalidTokenMessage?: string | object | MessageFunction;
};
/**
 * Bearer Auth Middleware for Hono.
 *
 * @see {@link https://hono.dev/docs/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. If set to the empty string, no prefix is expected.
 * @param {string} [options.headerName=Authorization] - The header name.
 * @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
 * @param {string | object | MessageFunction} [options.noAuthenticationHeaderMessage="Unauthorized"] - The no authentication header message.
 * @param {string | object | MessageFunction} [options.invalidAuthenticationHeaderMeasage="Bad Request"] - The invalid authentication header message.
 * @param {string | object | MessageFunction} [options.invalidTokenMessage="Unauthorized"] - The invalid token message.
 * @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 {};

• GetIPAddr

  /**
   * Function to get IP Address
   */
  type GetIPAddr = GetConnInfo | ((c: Context) => string);

• IPRestrictionRule

  export type IPRestrictionRule = string | ((addr: {
      addr: string;
      type: AddressType;
  }) => boolean);

• IPRestrictionRules

  /**
   * Rules for IP Restriction Middleware
   */
  export interface IPRestrictionRules {
      denyList?: IPRestrictionRule[];
      allowList?: IPRestrictionRule[];
  }

• ipRestriction

  /**
   * IP Restriction Middleware
   *
   * @param getIP function to get IP Address
   */
  export declare const ipRestriction: (getIP: GetIPAddr, { denyList, allowList }: IPRestrictionRules, onError?: ((remote: {
      addr: string;
      type: AddressType;
  }, c: Context) => Response | Promise<Response>) | undefined) => MiddlewareHandler;

/**
 * IP Restriction Middleware for Hono
 * @module
 */
import type { Context, MiddlewareHandler } from '../..';
import type { AddressType, GetConnInfo } from '../../helper/conninfo';
/**
 * Function to get IP Address
 */
type GetIPAddr = GetConnInfo | ((c: Context) => string);
export type IPRestrictionRule = string | ((addr: {
    addr: string;
    type: AddressType;
}) => boolean);
/**
 * Rules for IP Restriction Middleware
 */
export interface IPRestrictionRules {
    denyList?: IPRestrictionRule[];
    allowList?: IPRestrictionRule[];
}
/**
 * IP Restriction Middleware
 *
 * @param getIP function to get IP Address
 */
export declare const ipRestriction: (getIP: GetIPAddr, { denyList, allowList }: IPRestrictionRules, onError?: ((remote: {
    addr: string;
    type: AddressType;
}, c: Context) => Response | Promise<Response>) | undefined) => MiddlewareHandler;
export {};

/**
 * @module
 * The preset that uses `PatternRouter`.
 */
import { HonoBase } from '../hono-base';
import type { HonoOptions } from '../hono-base';
import type { BlankEnv, BlankSchema, Env, Schema } from '../types';
export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
    constructor(options?: HonoOptions<E>);
}

• HTTPExceptionFunction

  export type HTTPExceptionFunction = (context: Context) => HTTPException;

• timeout

  /**
   * Timeout Middleware for Hono.
   *
   * @param {number} duration - The timeout duration in milliseconds.
   * @param {HTTPExceptionFunction | HTTPException} [exception=defaultTimeoutException] - The exception to throw when the timeout occurs. Can be a function that returns an HTTPException or an HTTPException object.
   * @returns {MiddlewareHandler} The middleware handler function.
   *
   * @example
   * ```ts
   * const app = new Hono()
   *
   * app.use(
   *   '/long-request',
   *   timeout(5000) // Set timeout to 5 seconds
   * )
   *
   * app.get('/long-request', async (c) => {
   *   await someLongRunningFunction()
   *   return c.text('Completed within time limit')
   * })
   * ```
   */
  export declare const timeout: (duration: number, exception?: HTTPExceptionFunction | HTTPException) => MiddlewareHandler;

/**
 * @module
 * Timeout Middleware for Hono.
 */
import type { Context } from '../../context';
import { HTTPException } from '../../http-exception';
import type { MiddlewareHandler } from '../../types';
export type HTTPExceptionFunction = (context: Context) => HTTPException;
/**
 * Timeout Middleware for Hono.
 *
 * @param {number} duration - The timeout duration in milliseconds.
 * @param {HTTPExceptionFunction | HTTPException} [exception=defaultTimeoutException] - The exception to throw when the timeout occurs. Can be a function that returns an HTTPException or an HTTPException object.
 * @returns {MiddlewareHandler} The middleware handler function.
 *
 * @example
 * ```ts
 * const app = new Hono()
 *
 * app.use(
 *   '/long-request',
 *   timeout(5000) // Set timeout to 5 seconds
 * )
 *
 * app.get('/long-request', async (c) => {
 *   await someLongRunningFunction()
 *   return c.text('Completed within time limit')
 * })
 * ```
 */
export declare const timeout: (duration: number, exception?: HTTPExceptionFunction | HTTPException) => MiddlewareHandler;

• CORSOptions

  type CORSOptions = {
      origin: string | string[] | ((origin: string, c: Context) => string | undefined | null);
      allowMethods?: string[];
      allowHeaders?: string[];
      maxAge?: number;
      credentials?: boolean;
      exposeHeaders?: string[];
  };

• cors

  /**
   * CORS Middleware for Hono.
   *
   * @see {@link https://hono.dev/docs/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;

/**
 * @module
 * CORS Middleware for Hono.
 */
import type { Context } from '../../context';
import type { MiddlewareHandler } from '../../types';
type CORSOptions = {
    origin: string | string[] | ((origin: string, c: Context) => string | undefined | null);
    allowMethods?: string[];
    allowHeaders?: string[];
    maxAge?: number;
    credentials?: boolean;
    exposeHeaders?: string[];
};
/**
 * CORS Middleware for Hono.
 *
 * @see {@link https://hono.dev/docs/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 {};

• cache

  /**
   * Cache Middleware for Hono.
   *
   * @see {@link https://hono.dev/docs/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;
      cacheControl?: string | undefined;
      vary?: string | string[] | undefined;
      keyGenerator?: ((c: Context) => Promise<string> | string) | undefined;
  }) => MiddlewareHandler;

/**
 * @module
 * Cache Middleware for Hono.
 */
import type { Context } from '../../context';
import type { MiddlewareHandler } from '../../types';
/**
 * Cache Middleware for Hono.
 *
 * @see {@link https://hono.dev/docs/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;
    cacheControl?: string | undefined;
    vary?: string | string[] | undefined;
    keyGenerator?: ((c: Context) => Promise<string> | string) | undefined;
}) => MiddlewareHandler;

/**
 * @module
 * Lambda@Edge Adapter for Hono.
 */
export { handle } from './handler';
export { getConnInfo } from './conninfo';
export type { Callback, CloudFrontConfig, CloudFrontRequest, CloudFrontResponse, CloudFrontEdgeEvent, } from './handler';

• GetPath

  type GetPath<E extends Env> = (request: Request, options?: {
      env?: E["Bindings"];
  }) => string;

• HonoOptions

  export type HonoOptions<E extends Env> = {
      /**
       * `strict` option specifies whether to distinguish whether the last path is a directory or not.
       *
       * @see {@link https://hono.dev/docs/api/hono#strict-mode}
       *
       * @default true
       */
      strict?: boolean;
      /**
       * `router` option specifices which router to use.
       *
       * @see {@link https://hono.dev/docs/api/hono#router-option}
       *
       * @example
       * ```ts
       * const app = new Hono({ router: new RegExpRouter() })
       * ```
       */
      router?: Router<[
          H,
          RouterRoute
      ]>;
      /**
       * `getPath` can handle the host header value.
       *
       * @see {@link https://hono.dev/docs/api/routing#routing-with-host-header-value}
       *
       * @example
       * ```ts
       * const app = new Hono({
       *  getPath: (req) =>
       *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
       * })
       *
       * app.get('/www1.example.com/hello', () => c.text('hello www1'))
       *
       * // A following request will match the route:
       * // new Request('http://www1.example.com/hello', {
       * //  headers: { host: 'www1.example.com' },
       * // })
       * ```
       */
      getPath?: GetPath<E>;
  };

• MountOptionHandler

  type MountOptionHandler = (c: Context) => unknown;

• MountReplaceRequest

  type MountReplaceRequest = (originalRequest: Request) => Request;

• MountOptions

  type MountOptions = MountOptionHandler | {
      optionHandler?: MountOptionHandler;
      replaceRequest?: MountReplaceRequest;
  };

/**
 * @module
 * This module is the base module for the Hono object.
 */
import { Context } from './context';
import type { ExecutionContext } from './context';
import type { Router } from './router';
import type { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from './types';
/**
 * Symbol used to mark a composed handler.
 */
export declare const COMPOSED_HANDLER: unique symbol;
type GetPath<E extends Env> = (request: Request, options?: {
    env?: E['Bindings'];
}) => string;
export type HonoOptions<E extends Env> = {
    /**
     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
     *
     * @see {@link https://hono.dev/docs/api/hono#strict-mode}
     *
     * @default true
     */
    strict?: boolean;
    /**
     * `router` option specifices which router to use.
     *
     * @see {@link https://hono.dev/docs/api/hono#router-option}
     *
     * @example
     * ```ts
     * const app = new Hono({ router: new RegExpRouter() })
     * ```
     */
    router?: Router<[H, RouterRoute]>;
    /**
     * `getPath` can handle the host header value.
     *
     * @see {@link https://hono.dev/docs/api/routing#routing-with-host-header-value}
     *
     * @example
     * ```ts
     * const app = new Hono({
     *  getPath: (req) =>
     *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
     * })
     *
     * app.get('/www1.example.com/hello', () => c.text('hello www1'))
     *
     * // A following request will match the route:
     * // new Request('http://www1.example.com/hello', {
     * //  headers: { host: 'www1.example.com' },
     * // })
     * ```
     */
    getPath?: GetPath<E>;
};
type MountOptionHandler = (c: Context) => unknown;
type MountReplaceRequest = (originalRequest: Request) => Request;
type MountOptions = MountOptionHandler | {
    optionHandler?: MountOptionHandler;
    replaceRequest?: MountReplaceRequest;
};
declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
    #private;
    get: HandlerInterface<E, 'get', S, BasePath>;
    post: HandlerInterface<E, 'post', S, BasePath>;
    put: HandlerInterface<E, 'put', S, BasePath>;
    delete: HandlerInterface<E, 'delete', S, BasePath>;
    options: HandlerInterface<E, 'options', S, BasePath>;
    patch: HandlerInterface<E, 'patch', S, BasePath>;
    all: HandlerInterface<E, 'all', S, BasePath>;
    on: OnHandlerInterface<E, S, BasePath>;
    use: MiddlewareHandlerInterface<E, S, BasePath>;
    router: Router<[H, RouterRoute]>;
    readonly getPath: GetPath<E>;
    private _basePath;
    routes: RouterRoute[];
    constructor(options?: HonoOptions<E>);
    private clone;
    private notFoundHandler;
    private errorHandler;
    /**
     * `.route()` allows grouping other Hono instance in routes.
     *
     * @see {@link https://hono.dev/docs/api/routing#grouping}
     *
     * @param {string} path - base Path
     * @param {Hono} app - other Hono instance
     * @returns {Hono} routed Hono instance
     *
     * @example
     * ```ts
     * const app = new Hono()
     * const app2 = new Hono()
     *
     * app2.get("/user", (c) => c.text("user"))
     * app.route("/api", app2) // GET /api/user
     * ```
     */
    route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string>(path: SubPath, app: Hono<SubEnv, SubSchema, SubBasePath>): Hono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> & S, BasePath>;
    /**
     * `.basePath()` allows base paths to be specified.
     *
     * @see {@link https://hono.dev/docs/api/routing#base-path}
     *
     * @param {string} path - base Path
     * @returns {Hono} changed Hono instance
     *
     * @example
     * ```ts
     * const api = new Hono().basePath('/api')
     * ```
     */
    basePath<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>>;
    /**
     * `.onError()` handles an error and returns a customized Response.
     *
     * @see {@link https://hono.dev/docs/api/hono#error-handling}
     *
     * @param {ErrorHandler} handler - request Handler for error
     * @returns {Hono} changed Hono instance
     *
     * @example
     * ```ts
     * app.onError((err, c) => {
     *   console.error(`${err}`)
     *   return c.text('Custom Error Message', 500)
     * })
     * ```
     */
    onError: (handler: ErrorHandler<E>) => Hono<E, S, BasePath>;
    /**
     * `.notFound()` allows you to customize a Not Found Response.
     *
     * @see {@link https://hono.dev/docs/api/hono#not-found}
     *
     * @param {NotFoundHandler} handler - request handler for not-found
     * @returns {Hono} changed Hono instance
     *
     * @example
     * ```ts
     * app.notFound((c) => {
     *   return c.text('Custom 404 Message', 404)
     * })
     * ```
     */
    notFound: (handler: NotFoundHandler<E>) => Hono<E, S, BasePath>;
    /**
     * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
     *
     * @see {@link https://hono.dev/docs/api/hono#mount}
     *
     * @param {string} path - base Path
     * @param {Function} applicationHandler - other Request Handler
     * @param {MountOptions} [options] - options of `.mount()`
     * @returns {Hono} mounted Hono instance
     *
     * @example
     * ```ts
     * import { Router as IttyRouter } from 'itty-router'
     * import { Hono } from 'hono'
     * // Create itty-router application
     * const ittyRouter = IttyRouter()
     * // GET /itty-router/hello
     * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
     *
     * const app = new Hono()
     * app.mount('/itty-router', ittyRouter.handle)
     * ```
     *
     * @example
     * ```ts
     * const app = new Hono()
     * // Send the request to another application without modification.
     * app.mount('/app', anotherApp, {
     *   replaceRequest: (req) => req,
     * })
     * ```
     */
    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono<E, S, BasePath>;
    private addRoute;
    private matchRoute;
    private handleError;
    private dispatch;
    /**
     * `.fetch()` will be entry point of your app.
     *
     * @see {@link https://hono.dev/docs/api/hono#fetch}
     *
     * @param {Request} request - request Object of request
     * @param {Env} Env - env Object
     * @param {ExecutionContext} - context of execution
     * @returns {Response | Promise<Response>} response of request
     *
     */
    fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
    /**
     * `.request()` is a useful method for testing.
     * You can pass a URL or pathname to send a GET request.
     * app will return a Response object.
     * ```ts
     * test('GET /hello is ok', async () => {
     *   const res = await app.request('/hello')
     *   expect(res.status).toBe(200)
     * })
     * ```
     * @see https://hono.dev/docs/api/hono#request
     */
    request: (input: RequestInfo | URL, requestInit?: RequestInit, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
    /**
     * `.fire()` automatically adds a global fetch event listener.
     * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
     * @see https://hono.dev/docs/api/hono#fire
     * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
     * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
     */
    fire: () => void;
}
export { Hono as HonoBase };

• Bindings

  export type Bindings = object;

• Variables

  export type Variables = object;

• BlankEnv

  export type BlankEnv = {};

• Env

  export type Env = {
      Bindings?: Bindings;
      Variables?: Variables;
  };

• Next

  export type Next = () => Promise<void>;

• ExtractInput

  export type ExtractInput<I extends Input | Input["in"]> = I extends Input ? unknown extends I["in"] ? {} : I["in"] : I;

• Input

  export type Input = {
      in?: {};
      out?: {};
      outputFormat?: ResponseFormat;
  };

• BlankSchema

  export type BlankSchema = {};

• BlankInput

  export type BlankInput = {};

• HandlerResponse

  export type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>>;

• Handler

  export type Handler<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = (c: Context<E, P, I>, next: Next) => R;

• MiddlewareHandler

  export type MiddlewareHandler<E extends Env = any, P extends string = string, I extends Input = {}> = (c: Context<E, P, I>, next: Next) => Promise<Response | void>;

• H

  export type H<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = Handler<E, P, I, R> | MiddlewareHandler<E, P, I>;

• NotFoundHandler

  export type NotFoundHandler<E extends Env = any> = (c: Context<E>) => Response | Promise<Response>;

• ErrorHandler

  export type ErrorHandler<E extends Env = any> = (err: Error | HTTPResponseError, c: Context<E>) => Response | Promise<Response>;

• ExtractKey

  type ExtractKey<S> = S extends Record<infer Key, unknown> ? Key extends string ? Key : never : string;

• ToSchema

  export type ToSchema<M extends string, P extends string, I extends Input | Input["in"], RorO> = Simplify<{
      [K in P]: {
          [K2 in M as AddDollar<K2>]: Simplify<{
              input: AddParam<ExtractInput<I>, P>;
          } & (IsAny<RorO> extends true ? {
              output: {};
              outputFormat: ResponseFormat;
              status: StatusCode;
          } : RorO extends TypedResponse<infer T, infer U, infer F> ? {
              output: unknown extends T ? {} : T;
              outputFormat: I extends {
                  outputFormat: string;
              } ? I["outputFormat"] : F;
              status: U;
          } : {
              output: unknown extends RorO ? {} : RorO;
              outputFormat: unknown extends RorO ? "json" : I extends {
                  outputFormat: string;
              } ? I["outputFormat"] : "json";
              status: StatusCode;
          })>;
      };
  }>;

• Schema

  export type Schema = {
      [Path: string]: {
          [Method: `$${Lowercase<string>}`]: Endpoint;
      };
  };

• ChangePathOfSchema

  type ChangePathOfSchema<S extends Schema, Path extends string> = keyof S extends never ? {
      [K in Path]: {};
  } : {
      [K in keyof S as Path]: S[K];
  };

• Endpoint

  export type Endpoint = {
      input: any;
      output: any;
      outputFormat: ResponseFormat;
      status: StatusCode;
  };

• ExtractParams

  type ExtractParams<Path extends string> = string extends Path ? Record<string, string> : Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
      [K in Param | keyof ExtractParams<`/${Rest}`>]: string;
  } : Path extends `${infer _Start}:${infer Param}` ? {
      [K in Param]: string;
  } : never;

• FlattenIfIntersect

  type FlattenIfIntersect<T> = T extends infer O ? {
      [K in keyof O]: O[K];
  } : never;

• MergeSchemaPath

  export type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string> = Simplify<{
      [P in keyof OrigSchema as MergePath<SubPath, P & string>]: {
          [M in keyof OrigSchema[P]]: MergeEndpointParamsWithPath<OrigSchema[P][M], SubPath>;
      };
  }>;

• MergeEndpointParamsWithPath

  type MergeEndpointParamsWithPath<T, SubPath extends string> = T extends {
      input: infer Input;
      output: infer Output;
      outputFormat: infer OutputFormat;
      status: infer Status;
  } ? {
      input: Input extends {
          param: infer _;
      } ? ExtractParams<SubPath> extends never ? Input : FlattenIfIntersect<Input & {
          param: {
              [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
          };
      }> : RemoveBlankRecord<ExtractParams<SubPath>> extends never ? Input : Input & {
          param: {
              [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
          };
      };
      output: Output;
      outputFormat: OutputFormat;
      status: Status;
  } : never;

• AddParam

  export type AddParam<I, P extends string> = ParamKeys<P> extends never ? I : I extends {
      param: infer _;
  } ? I : I & {
      param: UnionToIntersection<ParamKeyToRecord<ParamKeys<P>>>;
  };

• AddDollar

  type AddDollar<T extends string> = `$${Lowercase<T>}`;

• MergePath

  export type MergePath<A extends string, B extends string> = B extends "" ? MergePath<A, "/"> : A extends "" ? B : A extends "/" ? B : A extends `${infer P}/` ? B extends `/${infer Q}` ? `${P}/${Q}` : `${P}/${B}` : B extends `/${infer Q}` ? Q extends "" ? A : `${A}/${Q}` : `${A}/${B}`;

• KnownResponseFormat

  export type KnownResponseFormat = "json" | "text" | "redirect";

• ResponseFormat

  export type ResponseFormat = KnownResponseFormat | string;

• TypedResponse

  export type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = T extends string ? "text" : T extends JSONValue ? "json" : ResponseFormat> = {
      _data: T;
      _status: U;
      _format: F;
  };

• MergeTypedResponse

  type MergeTypedResponse<T> = T extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : TypedResponse : T extends TypedResponse ? T : TypedResponse;

• FormValue

  export type FormValue = string | Blob;

• ParsedFormValue

  export type ParsedFormValue = string | File;

• ValidationTargets

  export type ValidationTargets<T extends FormValue = ParsedFormValue, P extends string = string> = {
      json: any;
      form: Record<string, T | T[]>;
      query: Record<string, string | string[]>;
      param: Record<P, P extends `${infer _}?` ? string | undefined : string>;
      header: Record<string, string>;
      cookie: Record<string, string>;
  };

• ParamKeyName

  type ParamKeyName<NameWithPattern> = NameWithPattern extends `${infer Name}{${infer Rest}` ? Rest extends `${infer _Pattern}?` ? `${Name}?` : Name : NameWithPattern;

• ParamKey

  type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? ParamKeyName<NameWithPattern> : never;

• ParamKeys

  export type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;

• ParamKeyToRecord

  export type ParamKeyToRecord<T extends string> = T extends `${infer R}?` ? Record<R, string | undefined> : {
      [K in T]: string;
  };

• InputToDataByTarget

  export type InputToDataByTarget<T extends Input["out"], Target extends keyof ValidationTargets> = T extends {
      [K in Target]: infer R;
  } ? R : never;

• RemoveQuestion

  export type RemoveQuestion<T> = T extends `${infer R}?` ? R : T;

• ExtractSchema

  export type ExtractSchema<T> = UnionToIntersection<T extends Hono<infer _, infer S, any> ? S : never>;

• EnvOrEmpty

  type EnvOrEmpty<T> = T extends Env ? (Env extends T ? {} : T) : T;

• IntersectNonAnyTypes

  type IntersectNonAnyTypes<T extends any[]> = T extends [
      infer Head,
      ...infer Rest
  ] ? IfAnyThenEmptyObject<EnvOrEmpty<Head>> & IntersectNonAnyTypes<Rest> : {};

• RouterRoute

  export interface RouterRoute {
      path: string;
      method: string;
      handler: H;
  }

• HTTPResponseError

  export interface HTTPResponseError extends Error {
      getResponse: () => Response;
  }

• HandlerInterface

  export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = "/"> {
      <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[
          E,
          E2
      ]>, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
      <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
          E,
          E2
      ]>>(...handlers: [
          H<E2, P, I>,
          H<E3, P, I2, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>, S & ToSchema<M, P, I2, MergeTypedResponse<R>>, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
      <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>>(...handlers: [
          H<E2, P, I>,
          H<E3, P, I2>,
          H<E4, P, I3, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>, S & ToSchema<M, P, I3, MergeTypedResponse<R>>, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
          E,
          E2
      ]>>(path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2, R>
      ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
      <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>>(...handlers: [
          H<E2, P, I>,
          H<E3, P, I2>,
          H<E4, P, I3>,
          H<E5, P, I4, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>, S & ToSchema<M, P, I4, MergeTypedResponse<R>>, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>>(path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3, R>
      ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
      <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>>(...handlers: [
          H<E2, P, I>,
          H<E3, P, I2>,
          H<E4, P, I3>,
          H<E5, P, I4>,
          H<E6, P, I5, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>, S & ToSchema<M, P, I5, MergeTypedResponse<R>>, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>>(path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4, R>
      ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
      <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>>(...handlers: [
          H<E2, P, I>,
          H<E3, P, I2>,
          H<E4, P, I3>,
          H<E5, P, I4>,
          H<E6, P, I5>,
          H<E7, P, I6, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>, S & ToSchema<M, P, I6, MergeTypedResponse<R>>, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>>(path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5, R>
      ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
      <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>>(...handlers: [
          H<E2, P, I>,
          H<E3, P, I2>,
          H<E4, P, I3>,
          H<E5, P, I4>,
          H<E6, P, I5>,
          H<E7, P, I6>,
          H<E8, P, I7, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>, S & ToSchema<M, P, I7, MergeTypedResponse<R>>, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>>(path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6, R>
      ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
      <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>>(...handlers: [
          H<E2, P, I>,
          H<E3, P, I2>,
          H<E4, P, I3>,
          H<E5, P, I4>,
          H<E6, P, I5>,
          H<E7, P, I6>,
          H<E8, P, I7>,
          H<E9, P, I8, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>, S & ToSchema<M, P, I8, MergeTypedResponse<R>>, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>>(path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7, R>
      ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
      <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>>(...handlers: [
          H<E2, P, I>,
          H<E3, P, I2>,
          H<E4, P, I3>,
          H<E5, P, I4>,
          H<E6, P, I5>,
          H<E7, P, I6>,
          H<E8, P, I7>,
          H<E9, P, I8>,
          H<E10, P, I9, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10
      ]>, S & ToSchema<M, P, I9, MergeTypedResponse<R>>, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>>(path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7>,
          H<E9, MergedPath, I8, R>
      ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
      <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10
      ]>>(...handlers: [
          H<E2, P, I>,
          H<E3, P, I2>,
          H<E4, P, I3>,
          H<E5, P, I4>,
          H<E6, P, I5>,
          H<E7, P, I6>,
          H<E8, P, I7>,
          H<E9, P, I8>,
          H<E10, P, I9>,
          H<E11, P, I10, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10,
          E11
      ]>, S & ToSchema<M, P, I10, MergeTypedResponse<R>>, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>>(path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7>,
          H<E9, MergedPath, I8>,
          H<E10, MergedPath, I9, R>
      ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10
      ]>>(path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7>,
          H<E9, MergedPath, I8>,
          H<E10, MergedPath, I9>,
          H<E11, MergedPath, I10, R>
      ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<R>>, BasePath>;
      <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(...handlers: H<E, P, I, R>[]): Hono<E, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
      <P extends string, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
      <P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(path: P): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
  }

• MiddlewareHandlerInterface

  export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = "/"> {
      <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractKey<S>>>[]): Hono<IntersectNonAnyTypes<[
          E,
          E2
      ]>, S, BasePath>;
      <E2 extends Env = E>(handler: MiddlewareHandler<E2, MergePath<BasePath, ExtractKey<S>>>): Hono<IntersectNonAnyTypes<[
          E,
          E2
      ]>, S, BasePath>;
      <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
          E,
          E2
      ]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>, S, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E>(path: P, handler: MiddlewareHandler<E2, MergedPath>): Hono<IntersectNonAnyTypes<[
          E,
          E2
      ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
      <E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>, S, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
          E,
          E2
      ]>>(path: P, ...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
      <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>, S, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>>(path: P, ...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
      <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>,
          MiddlewareHandler<E6, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>, S, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>>(path: P, ...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
      <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>,
          MiddlewareHandler<E6, P>,
          MiddlewareHandler<E7, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>, S, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>>(path: P, ...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>,
          MiddlewareHandler<E6, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
      <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>,
          MiddlewareHandler<E6, P>,
          MiddlewareHandler<E7, P>,
          MiddlewareHandler<E8, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>, S, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>>(path: P, ...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>,
          MiddlewareHandler<E6, P>,
          MiddlewareHandler<E7, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
      <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>,
          MiddlewareHandler<E6, P>,
          MiddlewareHandler<E7, P>,
          MiddlewareHandler<E8, P>,
          MiddlewareHandler<E9, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>, S, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>>(path: P, ...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>,
          MiddlewareHandler<E6, P>,
          MiddlewareHandler<E7, P>,
          MiddlewareHandler<E8, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
      <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>,
          MiddlewareHandler<E6, P>,
          MiddlewareHandler<E7, P>,
          MiddlewareHandler<E8, P>,
          MiddlewareHandler<E9, P>,
          MiddlewareHandler<E10, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10
      ]>, S, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>>(path: P, ...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>,
          MiddlewareHandler<E6, P>,
          MiddlewareHandler<E7, P>,
          MiddlewareHandler<E8, P>,
          MiddlewareHandler<E9, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
      <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10
      ]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>,
          MiddlewareHandler<E6, P>,
          MiddlewareHandler<E7, P>,
          MiddlewareHandler<E8, P>,
          MiddlewareHandler<E9, P>,
          MiddlewareHandler<E10, P>,
          MiddlewareHandler<E11, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10,
          E11
      ]>, S, BasePath>;
      <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>>(path: P, ...handlers: [
          MiddlewareHandler<E2, P>,
          MiddlewareHandler<E3, P>,
          MiddlewareHandler<E4, P>,
          MiddlewareHandler<E5, P>,
          MiddlewareHandler<E6, P>,
          MiddlewareHandler<E7, P>,
          MiddlewareHandler<E8, P>,
          MiddlewareHandler<E9, P>,
          MiddlewareHandler<E10, P>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10
      ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
      <P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
  }

• OnHandlerInterface

  export interface OnHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = "/"> {
      <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(method: M, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[
          E,
          E2
      ]>, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
      <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
          E,
          E2
      ]>>(method: M, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
      <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>>(method: M, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
      <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>>(method: M, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
      <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>>(method: M, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
      <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>>(method: M, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
      <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>>(method: M, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
      <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>>(method: M, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7>,
          H<E9, MergedPath, I8, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
      <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>>(method: M, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7>,
          H<E9, MergedPath, I8>,
          H<E10, MergedPath, I9, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10
      ]>, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
      <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10
      ]>>(method: M, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7>,
          H<E9, MergedPath, I8>,
          H<E10, MergedPath, I9>,
          H<E11, MergedPath, I10>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10,
          E11
      ]>, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
      <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(method: M, path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
      <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[
          E,
          E2
      ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
      <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
          E,
          E2
      ]>>(methods: Ms, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
      <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>>(methods: Ms, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
      <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>>(methods: Ms, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
      <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>>(methods: Ms, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
      <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>>(methods: Ms, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
      <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>>(methods: Ms, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
      <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>>(methods: Ms, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7>,
          H<E9, MergedPath, I8, R>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
      <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>>(methods: Ms, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7>,
          H<E9, MergedPath, I8>,
          H<E10, MergedPath, I9>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10
      ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I9, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
      <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10
      ]>>(methods: Ms, path: P, ...handlers: [
          H<E2, MergedPath, I>,
          H<E3, MergedPath, I2>,
          H<E4, MergedPath, I3>,
          H<E5, MergedPath, I4>,
          H<E6, MergedPath, I5>,
          H<E7, MergedPath, I6>,
          H<E8, MergedPath, I7>,
          H<E9, MergedPath, I8>,
          H<E10, MergedPath, I9>,
          H<E11, MergedPath, I10>
      ]): Hono<IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10,
          E11
      ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
      <P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<string, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
      <I extends Input = BlankInput, R extends HandlerResponse<any> = any>(methods: string | string[], paths: string[], ...handlers: H<E, any, I, R>[]): Hono<E, S & ToSchema<string, string, I, MergeTypedResponse<R>>, BasePath>;
  }