//#region ../../node_modules/hono/dist/types/router.d.ts

/**
 * Interface representing a router.
 *
 * @template T - The type of the handler.
 */
interface Router<T$1> {
  /**
   * The name of the router.
   */
  name: string;
  /**
   * Adds a route to the router.
   *
   * @param method - The HTTP method (e.g., 'get', 'post').
   * @param path - The path for the route.
   * @param handler - The handler for the route.
   */
  add(method: string, path: string, handler: T$1): void;
  /**
   * Matches a route based on the given method and path.
   *
   * @param method - The HTTP method (e.g., 'get', 'post').
   * @param path - The path to match.
   * @returns The result of the match.
   */
  match(method: string, path: string): Result<T$1>;
}
/**
 * Type representing a map of parameter indices.
 */
type ParamIndexMap = Record<string, number>;
/**
 * Type representing a stash of parameters.
 */
type ParamStash = string[];
/**
 * Type representing a map of parameters.
 */
type Params = Record<string, string>;
/**
 * Type representing the result of a route match.
 *
 * The result can be in one of two formats:
 * 1. An array of handlers with their corresponding parameter index maps, followed by a parameter stash.
 * 2. An array of handlers with their corresponding parameter maps.
 *
 * Example:
 *
 * [[handler, paramIndexMap][], paramArray]
 * ```typescript
 * [
 *   [
 *     [middlewareA, {}],                     // '*'
 *     [funcA,       {'id': 0}],              // '/user/:id/*'
 *     [funcB,       {'id': 0, 'action': 1}], // '/user/:id/:action'
 *   ],
 *   ['123', 'abc']
 * ]
 * ```
 *
 * [[handler, params][]]
 * ```typescript
 * [
 *   [
 *     [middlewareA, {}],                             // '*'
 *     [funcA,       {'id': '123'}],                  // '/user/:id/*'
 *     [funcB,       {'id': '123', 'action': 'abc'}], // '/user/:id/:action'
 *   ]
 * ]
 * ```
 */
type Result<T$1> = [[T$1, ParamIndexMap][], ParamStash] | [[T$1, Params][]];
//#endregion
//#region ../../node_modules/hono/dist/types/hono-base.d.ts
type GetPath<E$1 extends Env> = (request: Request, options?: {
  env?: E$1["Bindings"];
}) => string;
type HonoOptions<E$1 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 specifies 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$1>;
};
type MountOptionHandler = (c: Context) => unknown;
type MountReplaceRequest = (originalRequest: Request) => Request;
type MountOptions = MountOptionHandler | {
  optionHandler?: MountOptionHandler;
  replaceRequest?: MountReplaceRequest | false;
};
declare class Hono<E$1 extends Env = Env, S$1 extends Schema = {}, BasePath extends string = "/"> {
  get: HandlerInterface<E$1, "get", S$1, BasePath>;
  post: HandlerInterface<E$1, "post", S$1, BasePath>;
  put: HandlerInterface<E$1, "put", S$1, BasePath>;
  delete: HandlerInterface<E$1, "delete", S$1, BasePath>;
  options: HandlerInterface<E$1, "options", S$1, BasePath>;
  patch: HandlerInterface<E$1, "patch", S$1, BasePath>;
  all: HandlerInterface<E$1, "all", S$1, BasePath>;
  on: OnHandlerInterface<E$1, S$1, BasePath>;
  use: MiddlewareHandlerInterface<E$1, S$1, BasePath>;
  router: Router<[H, RouterRoute]>;
  readonly getPath: GetPath<E$1>;
  routes: RouterRoute[];
  constructor(options?: HonoOptions<E$1>);
  /**
   * `.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$1, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> | S$1, 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$1, S$1, 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$1>) => Hono<E$1, S$1, 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$1>) => Hono<E$1, S$1, 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$1, S$1, BasePath>;
  /**
   * `.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$1["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$1["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;
}
//#endregion
//#region ../../node_modules/hono/dist/types/utils/headers.d.ts
/**
 * @module
 * HTTP Headers utility.
 */
type RequestHeader = "A-IM" | "Accept" | "Accept-Additions" | "Accept-CH" | "Accept-Charset" | "Accept-Datetime" | "Accept-Encoding" | "Accept-Features" | "Accept-Language" | "Accept-Patch" | "Accept-Post" | "Accept-Ranges" | "Accept-Signature" | "Access-Control" | "Access-Control-Allow-Credentials" | "Access-Control-Allow-Headers" | "Access-Control-Allow-Methods" | "Access-Control-Allow-Origin" | "Access-Control-Expose-Headers" | "Access-Control-Max-Age" | "Access-Control-Request-Headers" | "Access-Control-Request-Method" | "Age" | "Allow" | "ALPN" | "Alt-Svc" | "Alt-Used" | "Alternates" | "AMP-Cache-Transform" | "Apply-To-Redirect-Ref" | "Authentication-Control" | "Authentication-Info" | "Authorization" | "Available-Dictionary" | "C-Ext" | "C-Man" | "C-Opt" | "C-PEP" | "C-PEP-Info" | "Cache-Control" | "Cache-Status" | "Cal-Managed-ID" | "CalDAV-Timezones" | "Capsule-Protocol" | "CDN-Cache-Control" | "CDN-Loop" | "Cert-Not-After" | "Cert-Not-Before" | "Clear-Site-Data" | "Client-Cert" | "Client-Cert-Chain" | "Close" | "CMCD-Object" | "CMCD-Request" | "CMCD-Session" | "CMCD-Status" | "CMSD-Dynamic" | "CMSD-Static" | "Concealed-Auth-Export" | "Configuration-Context" | "Connection" | "Content-Base" | "Content-Digest" | "Content-Disposition" | "Content-Encoding" | "Content-ID" | "Content-Language" | "Content-Length" | "Content-Location" | "Content-MD5" | "Content-Range" | "Content-Script-Type" | "Content-Security-Policy" | "Content-Security-Policy-Report-Only" | "Content-Style-Type" | "Content-Type" | "Content-Version" | "Cookie" | "Cookie2" | "Cross-Origin-Embedder-Policy" | "Cross-Origin-Embedder-Policy-Report-Only" | "Cross-Origin-Opener-Policy" | "Cross-Origin-Opener-Policy-Report-Only" | "Cross-Origin-Resource-Policy" | "CTA-Common-Access-Token" | "DASL" | "Date" | "DAV" | "Default-Style" | "Delta-Base" | "Deprecation" | "Depth" | "Derived-From" | "Destination" | "Differential-ID" | "Dictionary-ID" | "Digest" | "DPoP" | "DPoP-Nonce" | "Early-Data" | "EDIINT-Features" | "ETag" | "Expect" | "Expect-CT" | "Expires" | "Ext" | "Forwarded" | "From" | "GetProfile" | "Hobareg" | "Host" | "HTTP2-Settings" | "If" | "If-Match" | "If-Modified-Since" | "If-None-Match" | "If-Range" | "If-Schedule-Tag-Match" | "If-Unmodified-Since" | "IM" | "Include-Referred-Token-Binding-ID" | "Isolation" | "Keep-Alive" | "Label" | "Last-Event-ID" | "Last-Modified" | "Link" | "Link-Template" | "Location" | "Lock-Token" | "Man" | "Max-Forwards" | "Memento-Datetime" | "Meter" | "Method-Check" | "Method-Check-Expires" | "MIME-Version" | "Negotiate" | "NEL" | "OData-EntityId" | "OData-Isolation" | "OData-MaxVersion" | "OData-Version" | "Opt" | "Optional-WWW-Authenticate" | "Ordering-Type" | "Origin" | "Origin-Agent-Cluster" | "OSCORE" | "OSLC-Core-Version" | "Overwrite" | "P3P" | "PEP" | "PEP-Info" | "Permissions-Policy" | "PICS-Label" | "Ping-From" | "Ping-To" | "Position" | "Pragma" | "Prefer" | "Preference-Applied" | "Priority" | "ProfileObject" | "Protocol" | "Protocol-Info" | "Protocol-Query" | "Protocol-Request" | "Proxy-Authenticate" | "Proxy-Authentication-Info" | "Proxy-Authorization" | "Proxy-Features" | "Proxy-Instruction" | "Proxy-Status" | "Public" | "Public-Key-Pins" | "Public-Key-Pins-Report-Only" | "Range" | "Redirect-Ref" | "Referer" | "Referer-Root" | "Referrer-Policy" | "Refresh" | "Repeatability-Client-ID" | "Repeatability-First-Sent" | "Repeatability-Request-ID" | "Repeatability-Result" | "Replay-Nonce" | "Reporting-Endpoints" | "Repr-Digest" | "Retry-After" | "Safe" | "Schedule-Reply" | "Schedule-Tag" | "Sec-GPC" | "Sec-Purpose" | "Sec-Token-Binding" | "Sec-WebSocket-Accept" | "Sec-WebSocket-Extensions" | "Sec-WebSocket-Key" | "Sec-WebSocket-Protocol" | "Sec-WebSocket-Version" | "Security-Scheme" | "Server" | "Server-Timing" | "Set-Cookie" | "Set-Cookie2" | "SetProfile" | "Signature" | "Signature-Input" | "SLUG" | "SoapAction" | "Status-URI" | "Strict-Transport-Security" | "Sunset" | "Surrogate-Capability" | "Surrogate-Control" | "TCN" | "TE" | "Timeout" | "Timing-Allow-Origin" | "Topic" | "Traceparent" | "Tracestate" | "Trailer" | "Transfer-Encoding" | "TTL" | "Upgrade" | "Urgency" | "URI" | "Use-As-Dictionary" | "User-Agent" | "Variant-Vary" | "Vary" | "Via" | "Want-Content-Digest" | "Want-Digest" | "Want-Repr-Digest" | "Warning" | "WWW-Authenticate" | "X-Content-Type-Options" | "X-Frame-Options";
type ResponseHeader = "Access-Control-Allow-Credentials" | "Access-Control-Allow-Headers" | "Access-Control-Allow-Methods" | "Access-Control-Allow-Origin" | "Access-Control-Expose-Headers" | "Access-Control-Max-Age" | "Age" | "Allow" | "Cache-Control" | "Clear-Site-Data" | "Content-Disposition" | "Content-Encoding" | "Content-Language" | "Content-Length" | "Content-Location" | "Content-Range" | "Content-Security-Policy" | "Content-Security-Policy-Report-Only" | "Content-Type" | "Cookie" | "Cross-Origin-Embedder-Policy" | "Cross-Origin-Opener-Policy" | "Cross-Origin-Resource-Policy" | "Date" | "ETag" | "Expires" | "Last-Modified" | "Location" | "Permissions-Policy" | "Pragma" | "Retry-After" | "Save-Data" | "Sec-CH-Prefers-Color-Scheme" | "Sec-CH-Prefers-Reduced-Motion" | "Sec-CH-UA" | "Sec-CH-UA-Arch" | "Sec-CH-UA-Bitness" | "Sec-CH-UA-Form-Factor" | "Sec-CH-UA-Full-Version" | "Sec-CH-UA-Full-Version-List" | "Sec-CH-UA-Mobile" | "Sec-CH-UA-Model" | "Sec-CH-UA-Platform" | "Sec-CH-UA-Platform-Version" | "Sec-CH-UA-WoW64" | "Sec-Fetch-Dest" | "Sec-Fetch-Mode" | "Sec-Fetch-Site" | "Sec-Fetch-User" | "Sec-GPC" | "Server" | "Server-Timing" | "Service-Worker-Navigation-Preload" | "Set-Cookie" | "Strict-Transport-Security" | "Timing-Allow-Origin" | "Trailer" | "Transfer-Encoding" | "Upgrade" | "Vary" | "WWW-Authenticate" | "Warning" | "X-Content-Type-Options" | "X-DNS-Prefetch-Control" | "X-Frame-Options" | "X-Permitted-Cross-Domain-Policies" | "X-Powered-By" | "X-Robots-Tag" | "X-XSS-Protection";
type CustomHeader = string & {};
//#endregion
//#region ../../node_modules/hono/dist/types/utils/http-status.d.ts
/**
 * @module
 * HTTP Status utility.
 */
type InfoStatusCode = 100 | 101 | 102 | 103;
type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
type DeprecatedStatusCode = 305 | 306;
type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
/**
 * `UnofficialStatusCode` can be used to specify an unofficial status code.
 * @example
 *
 * ```ts
 * app.get('/unknown', (c) => {
 *   return c.text("Unknown Error", 520 as UnofficialStatusCode)
 * })
 * ```
 */
type UnofficialStatusCode = -1;
/**
 * If you want to use an unofficial status, use `UnofficialStatusCode`.
 */
type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode | UnofficialStatusCode;
type ContentlessStatusCode = 101 | 204 | 205 | 304;
type ContentfulStatusCode = Exclude<StatusCode, ContentlessStatusCode>;
//#endregion
//#region ../../node_modules/hono/dist/types/utils/types.d.ts
type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => void : never) extends ((k: infer I) => void) ? I : never;
type RemoveBlankRecord<T$1> = T$1 extends Record<infer K, unknown> ? K extends string ? T$1 : never : never;
type IfAnyThenEmptyObject<T$1> = 0 extends 1 & T$1 ? {} : T$1;
type JSONPrimitive = string | boolean | number | null;
type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
type JSONObject = {
  [key: string]: JSONPrimitive | JSONArray | JSONObject | object | InvalidJSONValue;
};
type InvalidJSONValue = undefined | symbol | ((...args: unknown[]) => unknown);
type InvalidToNull<T$1> = T$1 extends InvalidJSONValue ? null : T$1;
type IsInvalid<T$1> = T$1 extends InvalidJSONValue ? true : false;
/**
 * symbol keys are omitted through `JSON.stringify`
 */
type OmitSymbolKeys<T$1> = { [K in keyof T$1 as K extends symbol ? never : K]: T$1[K] };
type JSONValue = JSONObject | JSONArray | JSONPrimitive;
type JSONParsed<T$1> = T$1 extends {
  toJSON(): infer J;
} ? (() => J) extends (() => JSONPrimitive) ? J : (() => J) extends (() => {
  toJSON(): unknown;
}) ? {} : JSONParsed<J> : T$1 extends JSONPrimitive ? T$1 : T$1 extends InvalidJSONValue ? never : T$1 extends ReadonlyArray<unknown> ? { [K in keyof T$1]: JSONParsed<InvalidToNull<T$1[K]>> } : T$1 extends Set<unknown> | Map<unknown, unknown> ? {} : T$1 extends object ? { [K in keyof OmitSymbolKeys<T$1> as IsInvalid<T$1[K]> extends true ? never : K]: boolean extends IsInvalid<T$1[K]> ? JSONParsed<T$1[K]> | undefined : JSONParsed<T$1[K]> } : never;
/**
 * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 * @copyright from sindresorhus/type-fest
 */
type Simplify<T$1> = { [KeyType in keyof T$1]: T$1[KeyType] } & {};
/**
 * A simple extension of Simplify that will deeply traverse array elements.
 */
type SimplifyDeepArray<T$1> = T$1 extends any[] ? { [E in keyof T$1]: SimplifyDeepArray<T$1[E]> } : Simplify<T$1>;
type IsAny<T$1> = boolean extends (T$1 extends never ? true : false) ? true : false;
//#endregion
//#region ../../node_modules/hono/dist/types/types.d.ts
type Bindings = object;
type Variables = object;
type BlankEnv = {};
type Env = {
  Bindings?: Bindings;
  Variables?: Variables;
};
type Next = () => Promise<void>;
type ExtractInput<I$1 extends Input | Input["in"]> = I$1 extends Input ? unknown extends I$1["in"] ? {} : I$1["in"] : I$1;
type Input = {
  in?: {};
  out?: {};
  outputFormat?: ResponseFormat;
};
type BlankSchema = {};
type BlankInput = {};
interface RouterRoute {
  path: string;
  method: string;
  handler: H;
}
type HandlerResponse<O$1> = Response | TypedResponse<O$1> | Promise<Response | TypedResponse<O$1>>;
type Handler<E$1 extends Env = any, P$1 extends string = any, I$1 extends Input = BlankInput, R$1 extends HandlerResponse<any> = any> = (c: Context<E$1, P$1, I$1>, next: Next) => R$1;
type MiddlewareHandler<E$1 extends Env = any, P$1 extends string = string, I$1 extends Input = {}> = (c: Context<E$1, P$1, I$1>, next: Next) => Promise<Response | void>;
type H<E$1 extends Env = any, P$1 extends string = any, I$1 extends Input = BlankInput, R$1 extends HandlerResponse<any> = any> = Handler<E$1, P$1, I$1, R$1> | MiddlewareHandler<E$1, P$1, I$1>;
type NotFoundHandler<E$1 extends Env = any> = (c: Context<E$1>) => Response | Promise<Response>;
interface HTTPResponseError extends Error {
  getResponse: () => Response;
}
type ErrorHandler<E$1 extends Env = any> = (err: Error | HTTPResponseError, c: Context<E$1>) => Response | Promise<Response>;
interface HandlerInterface<E$1 extends Env = Env, M$1 extends string = string, S$1 extends Schema = BlankSchema, BasePath extends string = "/"> {
  <P extends string = (ExtractStringKey<S$1> extends never ? BasePath : ExtractStringKey<S$1>), I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E$1>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[E$1, E2]>, S$1 & ToSchema<M$1, P, I, MergeTypedResponse<R>>, BasePath>;
  <P extends string = (ExtractStringKey<S$1> extends never ? BasePath : ExtractStringKey<S$1>), I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>>(...handlers: [H<E2, P, I>, H<E3, P, I2, R>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3]>, S$1 & ToSchema<M$1, 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$1>(path: P, handler: H<E2, MergedPath, I, R>): Hono<E$1, S$1 & ToSchema<M$1, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
  <P extends string = (ExtractStringKey<S$1> extends never ? BasePath : ExtractStringKey<S$1>), R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3, R>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4]>, S$1 & ToSchema<M$1, 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<E$1, S$1 & ToSchema<M$1, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
  <P extends string = (ExtractStringKey<S$1> extends never ? BasePath : ExtractStringKey<S$1>), 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3>, H<E5, P, I4, R>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, S$1 & ToSchema<M$1, 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<E$1, S$1 & ToSchema<M$1, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
  <P extends string = (ExtractStringKey<S$1> extends never ? BasePath : ExtractStringKey<S$1>), 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6]>, S$1 & ToSchema<M$1, 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, 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$1, S$1 & ToSchema<M$1, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
  <P extends string = (ExtractStringKey<S$1> extends never ? BasePath : ExtractStringKey<S$1>), 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7]>, S$1 & ToSchema<M$1, 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, 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$1, S$1 & ToSchema<M$1, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
  <P extends string = (ExtractStringKey<S$1> extends never ? BasePath : ExtractStringKey<S$1>), 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8]>, S$1 & ToSchema<M$1, 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, 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$1, S$1 & ToSchema<M$1, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
  <P extends string = (ExtractStringKey<S$1> extends never ? BasePath : ExtractStringKey<S$1>), 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8, E9]>, S$1 & ToSchema<M$1, 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, 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$1, S$1 & ToSchema<M$1, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
  <P extends string = (ExtractStringKey<S$1> extends never ? BasePath : ExtractStringKey<S$1>), 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S$1 & ToSchema<M$1, 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, 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$1, S$1 & ToSchema<M$1, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
  <P extends string = (ExtractStringKey<S$1> extends never ? BasePath : ExtractStringKey<S$1>), 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S$1 & ToSchema<M$1, 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E$1, 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$1, S$1 & ToSchema<M$1, 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E$1, 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$1, S$1 & ToSchema<M$1, MergePath<BasePath, P>, I10, MergeTypedResponse<R>>, BasePath>;
  <P extends string = (ExtractStringKey<S$1> extends never ? BasePath : ExtractStringKey<S$1>), I extends Input = BlankInput, R extends HandlerResponse<any> = any>(...handlers: H<E$1, P, I, R>[]): Hono<E$1, S$1 & ToSchema<M$1, P, I, MergeTypedResponse<R>>, BasePath>;
  <P extends string, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E$1, MergePath<BasePath, P>, I, R>[]): Hono<E$1, S$1 & ToSchema<M$1, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
  <P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(path: P): Hono<E$1, S$1 & ToSchema<M$1, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
}
interface MiddlewareHandlerInterface<E$1 extends Env = Env, S$1 extends Schema = BlankSchema, BasePath extends string = "/"> {
  <E2 extends Env = E$1>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S$1>>>[]): Hono<IntersectNonAnyTypes<[E$1, E2]>, S$1, BasePath>;
  <E2 extends Env = E$1>(handler: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S$1>>>): Hono<IntersectNonAnyTypes<[E$1, E2]>, S$1, BasePath>;
  <E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, P extends string = MergePath<BasePath, ExtractStringKey<S$1>>>(...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3]>, S$1, BasePath>;
  <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E$1>(path: P, handler: MiddlewareHandler<E2, MergedPath>): Hono<IntersectNonAnyTypes<[E$1, E2]>, ChangePathOfSchema<S$1, MergedPath>, BasePath>;
  <E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, P extends string = MergePath<BasePath, ExtractStringKey<S$1>>>(...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>, MiddlewareHandler<E4, P>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4]>, S$1, BasePath>;
  <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>>(path: P, ...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3]>, ChangePathOfSchema<S$1, MergedPath>, BasePath>;
  <E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, P extends string = MergePath<BasePath, ExtractStringKey<S$1>>>(...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>, MiddlewareHandler<E4, P>, MiddlewareHandler<E5, P>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, S$1, BasePath>;
  <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>>(path: P, ...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>, MiddlewareHandler<E4, P>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4]>, ChangePathOfSchema<S$1, MergedPath>, BasePath>;
  <E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, P extends string = MergePath<BasePath, ExtractStringKey<S$1>>>(...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>, MiddlewareHandler<E4, P>, MiddlewareHandler<E5, P>, MiddlewareHandler<E6, P>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, S$1, BasePath>;
  <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>>(path: P, ...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>, MiddlewareHandler<E4, P>, MiddlewareHandler<E5, P>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, ChangePathOfSchema<S$1, MergedPath>, BasePath>;
  <E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, P extends string = MergePath<BasePath, ExtractStringKey<S$1>>>(...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>, MiddlewareHandler<E4, P>, MiddlewareHandler<E5, P>, MiddlewareHandler<E6, P>, MiddlewareHandler<E7, P>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, S$1, BasePath>;
  <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6]>, ChangePathOfSchema<S$1, MergedPath>, BasePath>;
  <E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, P extends string = MergePath<BasePath, ExtractStringKey<S$1>>>(...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$1, E2, E3, E4, E5, E6, E7, E8]>, S$1, BasePath>;
  <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7]>, ChangePathOfSchema<S$1, MergedPath>, BasePath>;
  <E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, P extends string = MergePath<BasePath, ExtractStringKey<S$1>>>(...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$1, E2, E3, E4, E5, E6, E7, E8, E9]>, S$1, BasePath>;
  <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8]>, ChangePathOfSchema<S$1, MergedPath>, BasePath>;
  <E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8, E9]>, P extends string = MergePath<BasePath, ExtractStringKey<S$1>>>(...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$1, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S$1, BasePath>;
  <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8, E9]>, ChangePathOfSchema<S$1, MergedPath>, BasePath>;
  <E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, P extends string = MergePath<BasePath, ExtractStringKey<S$1>>>(...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$1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S$1, BasePath>;
  <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, ChangePathOfSchema<S$1, MergedPath>, BasePath>;
  <P extends string, E2 extends Env = E$1>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono<E$1, S$1, BasePath>;
}
interface OnHandlerInterface<E$1 extends Env = Env, S$1 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$1>(method: M, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E$1, E2]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8, E9]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S$1 & ToSchema<M, MergePath<BasePath, P>, I9, 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, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E$1, 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, R>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S$1 & 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$1, MergePath<BasePath, P>, I, R>[]): Hono<E$1, S$1 & 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$1>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E$1, E2]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8]>, S$1 & 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, 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$1, E2, E3, E4, E5, E6, E7, E8, E9]>, S$1 & ToSchema<Ms[number], MergePath<BasePath, P>, I8, 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, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E$1, 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, R>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S$1 & 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>, 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$1, E3 extends Env = IntersectNonAnyTypes<[E$1, E2]>, E4 extends Env = IntersectNonAnyTypes<[E$1, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E$1, 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, R>]): Hono<IntersectNonAnyTypes<[E$1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S$1 & 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$1, MergePath<BasePath, P>, I, R>[]): Hono<E$1, S$1 & ToSchema<string, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
  <I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E$1>(methods: string | string[], paths: string[], ...handlers: H<E2, any, I, R>[]): Hono<E$1, S$1 & ToSchema<string, string, I, MergeTypedResponse<R>>, BasePath>;
}
type ExtractStringKey<S$1> = keyof S$1 & string;
type ToSchema<M$1 extends string, P$1 extends string, I$1 extends Input | Input["in"], RorO> = Simplify<{ [K in P$1]: { [K2 in M$1 as AddDollar<K2>]: Simplify<{
  input: AddParam<ExtractInput<I$1>, P$1>;
} & (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$1 extends {
    outputFormat: string;
  } ? I$1["outputFormat"] : F;
  status: U;
} : {
  output: unknown extends RorO ? {} : RorO;
  outputFormat: unknown extends RorO ? "json" : I$1 extends {
    outputFormat: string;
  } ? I$1["outputFormat"] : "json";
  status: StatusCode;
})> } }>;
type Schema = {
  [Path: string]: {
    [Method: `$${Lowercase<string>}`]: Endpoint;
  };
};
type ChangePathOfSchema<S$1 extends Schema, Path extends string> = keyof S$1 extends never ? { [K in Path]: {} } : { [K in keyof S$1 as Path]: S$1[K] };
type Endpoint = {
  input: any;
  output: any;
  outputFormat: ResponseFormat;
  status: StatusCode;
};
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;
type FlattenIfIntersect<T$1> = T$1 extends infer O ? { [K in keyof O]: O[K] } : never;
type MergeSchemaPath<OrigSchema extends Schema, SubPath$1 extends string> = { [P in keyof OrigSchema as MergePath<SubPath$1, P & string>]: [OrigSchema[P]] extends [Record<string, Endpoint>] ? { [M in keyof OrigSchema[P]]: MergeEndpointParamsWithPath<OrigSchema[P][M], SubPath$1> } : never };
type MergeEndpointParamsWithPath<T$1 extends Endpoint, SubPath$1 extends string> = T$1 extends unknown ? {
  input: T$1["input"] extends {
    param: infer _;
  } ? ExtractParams<SubPath$1> extends never ? T$1["input"] : FlattenIfIntersect<T$1["input"] & {
    param: { [K in keyof ExtractParams<SubPath$1> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string };
  }> : RemoveBlankRecord<ExtractParams<SubPath$1>> extends never ? T$1["input"] : T$1["input"] & {
    param: { [K in keyof ExtractParams<SubPath$1> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string };
  };
  output: T$1["output"];
  outputFormat: T$1["outputFormat"];
  status: T$1["status"];
} : never;
type AddParam<I$1, P$1 extends string> = ParamKeys<P$1> extends never ? I$1 : I$1 extends {
  param: infer _;
} ? I$1 : I$1 & {
  param: UnionToIntersection<ParamKeyToRecord<ParamKeys<P$1>>>;
};
type AddDollar<T$1 extends string> = `$${Lowercase<T$1>}`;
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}`;
type KnownResponseFormat = "json" | "text" | "redirect";
type ResponseFormat = KnownResponseFormat | string;
type TypedResponse<T$1 = unknown, U$1 extends StatusCode = StatusCode, F$1 extends ResponseFormat = (T$1 extends string ? "text" : T$1 extends JSONValue ? "json" : ResponseFormat)> = {
  _data: T$1;
  _status: U$1;
  _format: F$1;
};
type MergeTypedResponse<T$1> = T$1 extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : TypedResponse : T$1 extends TypedResponse ? T$1 : TypedResponse;
type FormValue = string | Blob;
type ParsedFormValue = string | File;
type ValidationTargets<T$1 extends FormValue = ParsedFormValue, P$1 extends string = string> = {
  json: any;
  form: Record<string, T$1 | T$1[]>;
  query: Record<string, string | string[]>;
  param: Record<P$1, P$1 extends `${infer _}?` ? string | undefined : string>;
  header: Record<RequestHeader | CustomHeader, string>;
  cookie: Record<string, string>;
};
type ParamKey<Component$1> = Component$1 extends `:${infer NameWithPattern}` ? NameWithPattern extends `${infer Name}{${infer Rest}` ? Rest extends `${infer _Pattern}?` ? `${Name}?` : Name : NameWithPattern : never;
type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
type ParamKeyToRecord<T$1 extends string> = T$1 extends `${infer R}?` ? Record<R, string | undefined> : { [K in T$1]: string };
type InputToDataByTarget<T$1 extends Input["out"], Target extends keyof ValidationTargets> = T$1 extends { [K in Target]: infer R } ? R : never;
type RemoveQuestion<T$1> = T$1 extends `${infer R}?` ? R : T$1;
type ProcessHead<T$1> = IfAnyThenEmptyObject<T$1 extends Env ? (Env extends T$1 ? {} : T$1) : T$1>;
type IntersectNonAnyTypes<T$1 extends any[]> = T$1 extends [infer Head, ...infer Rest] ? ProcessHead<Head> & IntersectNonAnyTypes<Rest> : {};
declare abstract class FetchEventLike {
  abstract readonly request: Request;
  abstract respondWith(promise: Response | Promise<Response>): void;
  abstract passThroughOnException(): void;
  abstract waitUntil(promise: Promise<void>): void;
}
//#endregion
//#region ../../node_modules/hono/dist/types/utils/body.d.ts
type BodyDataValueDot = {
  [x: string]: string | File | BodyDataValueDot;
};
type BodyDataValueDotAll = {
  [x: string]: string | File | (string | File)[] | BodyDataValueDotAll;
};
type SimplifyBodyData<T$1> = { [K in keyof T$1]: string | File | (string | File)[] | BodyDataValueDotAll extends T$1[K] ? string | File | (string | File)[] | BodyDataValueDotAll : string | File | BodyDataValueDot extends T$1[K] ? string | File | BodyDataValueDot : string | File | (string | File)[] extends T$1[K] ? string | File | (string | File)[] : string | File } & {};
type BodyDataValueComponent<T$1> = string | File | (T$1 extends {
  all: false;
} ? never : T$1 extends {
  all: true;
} | {
  all: boolean;
} ? (string | File)[] : never);
type BodyDataValueObject<T$1> = {
  [key: string]: BodyDataValueComponent<T$1> | BodyDataValueObject<T$1>;
};
type BodyDataValue<T$1> = BodyDataValueComponent<T$1> | (T$1 extends {
  dot: false;
} ? never : T$1 extends {
  dot: true;
} | {
  dot: boolean;
} ? BodyDataValueObject<T$1> : never);
type BodyData<T$1 extends Partial<ParseBodyOptions> = {}> = SimplifyBodyData<Record<string, BodyDataValue<T$1>>>;
type ParseBodyOptions = {
  /**
   * Determines whether all fields with multiple values should be parsed as arrays.
   * @default false
   * @example
   * const data = new FormData()
   * data.append('file', 'aaa')
   * data.append('file', 'bbb')
   * data.append('message', 'hello')
   *
   * If all is false:
   * parseBody should return { file: 'bbb', message: 'hello' }
   *
   * If all is true:
   * parseBody should return { file: ['aaa', 'bbb'], message: 'hello' }
   */
  all: boolean;
  /**
   * Determines whether all fields with dot notation should be parsed as nested objects.
   * @default false
   * @example
   * const data = new FormData()
   * data.append('obj.key1', 'value1')
   * data.append('obj.key2', 'value2')
   *
   * If dot is false:
   * parseBody should return { 'obj.key1': 'value1', 'obj.key2': 'value2' }
   *
   * If dot is true:
   * parseBody should return { obj: { key1: 'value1', key2: 'value2' } }
   */
  dot: boolean;
};
//#endregion
//#region ../../node_modules/hono/dist/types/request.d.ts
type Body = {
  json: any;
  text: string;
  arrayBuffer: ArrayBuffer;
  blob: Blob;
  formData: FormData;
};
type BodyCache = Partial<Body & {
  parsedBody: BodyData;
}>;
declare class HonoRequest<P$1 extends string = "/", I$1 extends Input["out"] = {}> {
  /**
   * `.raw` can get the raw Request object.
   *
   * @see {@link https://hono.dev/docs/api/request#raw}
   *
   * @example
   * ```ts
   * // For Cloudflare Workers
   * app.post('/', async (c) => {
   *   const metadata = c.req.raw.cf?.hostMetadata?
   *   ...
   * })
   * ```
   */
  raw: Request;
  routeIndex: number;
  /**
   * `.path` can get the pathname of the request.
   *
   * @see {@link https://hono.dev/docs/api/request#path}
   *
   * @example
   * ```ts
   * app.get('/about/me', (c) => {
   *   const pathname = c.req.path // `/about/me`
   * })
   * ```
   */
  path: string;
  bodyCache: BodyCache;
  constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
  /**
   * `.req.param()` gets the path parameters.
   *
   * @see {@link https://hono.dev/docs/api/routing#path-parameter}
   *
   * @example
   * ```ts
   * const name = c.req.param('name')
   * // or all parameters at once
   * const { id, comment_id } = c.req.param()
   * ```
   */
  param<P2 extends ParamKeys<P$1> = ParamKeys<P$1>>(key: P2 extends `${infer _}?` ? never : P2): string;
  param<P2 extends RemoveQuestion<ParamKeys<P$1>> = RemoveQuestion<ParamKeys<P$1>>>(key: P2): string | undefined;
  param(key: string): string | undefined;
  param<P2 extends string = P$1>(): Simplify<UnionToIntersection<ParamKeyToRecord<ParamKeys<P2>>>>;
  /**
   * `.query()` can get querystring parameters.
   *
   * @see {@link https://hono.dev/docs/api/request#query}
   *
   * @example
   * ```ts
   * // Query params
   * app.get('/search', (c) => {
   *   const query = c.req.query('q')
   * })
   *
   * // Get all params at once
   * app.get('/search', (c) => {
   *   const { q, limit, offset } = c.req.query()
   * })
   * ```
   */
  query(key: string): string | undefined;
  query(): Record<string, string>;
  /**
   * `.queries()` can get multiple querystring parameter values, e.g. /search?tags=A&tags=B
   *
   * @see {@link https://hono.dev/docs/api/request#queries}
   *
   * @example
   * ```ts
   * app.get('/search', (c) => {
   *   // tags will be string[]
   *   const tags = c.req.queries('tags')
   * })
   * ```
   */
  queries(key: string): string[] | undefined;
  queries(): Record<string, string[]>;
  /**
   * `.header()` can get the request header value.
   *
   * @see {@link https://hono.dev/docs/api/request#header}
   *
   * @example
   * ```ts
   * app.get('/', (c) => {
   *   const userAgent = c.req.header('User-Agent')
   * })
   * ```
   */
  header(name: RequestHeader): string | undefined;
  header(name: string): string | undefined;
  header(): Record<RequestHeader | (string & CustomHeader), string>;
  /**
   * `.parseBody()` can parse Request body of type `multipart/form-data` or `application/x-www-form-urlencoded`
   *
   * @see {@link https://hono.dev/docs/api/request#parsebody}
   *
   * @example
   * ```ts
   * app.post('/entry', async (c) => {
   *   const body = await c.req.parseBody()
   * })
   * ```
   */
  parseBody<Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(options?: Options): Promise<T>;
  parseBody<T extends BodyData>(options?: Partial<ParseBodyOptions>): Promise<T>;
  /**
   * `.json()` can parse Request body of type `application/json`
   *
   * @see {@link https://hono.dev/docs/api/request#json}
   *
   * @example
   * ```ts
   * app.post('/entry', async (c) => {
   *   const body = await c.req.json()
   * })
   * ```
   */
  json<T = any>(): Promise<T>;
  /**
   * `.text()` can parse Request body of type `text/plain`
   *
   * @see {@link https://hono.dev/docs/api/request#text}
   *
   * @example
   * ```ts
   * app.post('/entry', async (c) => {
   *   const body = await c.req.text()
   * })
   * ```
   */
  text(): Promise<string>;
  /**
   * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
   *
   * @see {@link https://hono.dev/docs/api/request#arraybuffer}
   *
   * @example
   * ```ts
   * app.post('/entry', async (c) => {
   *   const body = await c.req.arrayBuffer()
   * })
   * ```
   */
  arrayBuffer(): Promise<ArrayBuffer>;
  /**
   * Parses the request body as a `Blob`.
   * @example
   * ```ts
   * app.post('/entry', async (c) => {
   *   const body = await c.req.blob();
   * });
   * ```
   * @see https://hono.dev/docs/api/request#blob
   */
  blob(): Promise<Blob>;
  /**
   * Parses the request body as `FormData`.
   * @example
   * ```ts
   * app.post('/entry', async (c) => {
   *   const body = await c.req.formData();
   * });
   * ```
   * @see https://hono.dev/docs/api/request#formdata
   */
  formData(): Promise<FormData>;
  /**
   * Adds validated data to the request.
   *
   * @param target - The target of the validation.
   * @param data - The validated data to add.
   */
  addValidatedData(target: keyof ValidationTargets, data: {}): void;
  /**
   * Gets validated data from the request.
   *
   * @param target - The target of the validation.
   * @returns The validated data.
   *
   * @see https://hono.dev/docs/api/request#valid
   */
  valid<T extends keyof I$1 & keyof ValidationTargets>(target: T): InputToDataByTarget<I$1, T>;
  /**
   * `.url()` can get the request url strings.
   *
   * @see {@link https://hono.dev/docs/api/request#url}
   *
   * @example
   * ```ts
   * app.get('/about/me', (c) => {
   *   const url = c.req.url // `http://localhost:8787/about/me`
   *   ...
   * })
   * ```
   */
  get url(): string;
  /**
   * `.method()` can get the method name of the request.
   *
   * @see {@link https://hono.dev/docs/api/request#method}
   *
   * @example
   * ```ts
   * app.get('/about/me', (c) => {
   *   const method = c.req.method // `GET`
   * })
   * ```
   */
  get method(): string;
  /**
   * `.matchedRoutes()` can return a matched route in the handler
   *
   * @see {@link https://hono.dev/docs/api/request#matchedroutes}
   *
   * @example
   * ```ts
   * app.use('*', async function logger(c, next) {
   *   await next()
   *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
   *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
   *     console.log(
   *       method,
   *       ' ',
   *       path,
   *       ' '.repeat(Math.max(10 - path.length, 0)),
   *       name,
   *       i === c.req.routeIndex ? '<- respond from here' : ''
   *     )
   *   })
   * })
   * ```
   */
  get matchedRoutes(): RouterRoute[];
  /**
   * `routePath()` can retrieve the path registered within the handler
   *
   * @see {@link https://hono.dev/docs/api/request#routepath}
   *
   * @example
   * ```ts
   * app.get('/posts/:id', (c) => {
   *   return c.json({ path: c.req.routePath })
   * })
   * ```
   */
  get routePath(): string;
}
//#endregion
//#region ../../node_modules/hono/dist/types/utils/mime.d.ts
/**
 * Union types for BaseMime
 */
type BaseMime = (typeof _baseMimes)[keyof typeof _baseMimes];
declare const _baseMimes: {
  readonly aac: "audio/aac";
  readonly avi: "video/x-msvideo";
  readonly avif: "image/avif";
  readonly av1: "video/av1";
  readonly bin: "application/octet-stream";
  readonly bmp: "image/bmp";
  readonly css: "text/css";
  readonly csv: "text/csv";
  readonly eot: "application/vnd.ms-fontobject";
  readonly epub: "application/epub+zip";
  readonly gif: "image/gif";
  readonly gz: "application/gzip";
  readonly htm: "text/html";
  readonly html: "text/html";
  readonly ico: "image/x-icon";
  readonly ics: "text/calendar";
  readonly jpeg: "image/jpeg";
  readonly jpg: "image/jpeg";
  readonly js: "text/javascript";
  readonly json: "application/json";
  readonly jsonld: "application/ld+json";
  readonly map: "application/json";
  readonly mid: "audio/x-midi";
  readonly midi: "audio/x-midi";
  readonly mjs: "text/javascript";
  readonly mp3: "audio/mpeg";
  readonly mp4: "video/mp4";
  readonly mpeg: "video/mpeg";
  readonly oga: "audio/ogg";
  readonly ogv: "video/ogg";
  readonly ogx: "application/ogg";
  readonly opus: "audio/opus";
  readonly otf: "font/otf";
  readonly pdf: "application/pdf";
  readonly png: "image/png";
  readonly rtf: "application/rtf";
  readonly svg: "image/svg+xml";
  readonly tif: "image/tiff";
  readonly tiff: "image/tiff";
  readonly ts: "video/mp2t";
  readonly ttf: "font/ttf";
  readonly txt: "text/plain";
  readonly wasm: "application/wasm";
  readonly webm: "video/webm";
  readonly weba: "audio/webm";
  readonly webp: "image/webp";
  readonly woff: "font/woff";
  readonly woff2: "font/woff2";
  readonly xhtml: "application/xhtml+xml";
  readonly xml: "application/xml";
  readonly zip: "application/zip";
  readonly "3gp": "video/3gpp";
  readonly "3g2": "video/3gpp2";
  readonly gltf: "model/gltf+json";
  readonly glb: "model/gltf-binary";
};
//#endregion
//#region ../../node_modules/hono/dist/types/context.d.ts
type HeaderRecord = Record<"Content-Type", BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
/**
 * Data type can be a string, ArrayBuffer, Uint8Array (buffer), or ReadableStream.
 */
type Data = string | ArrayBuffer | ReadableStream | Uint8Array;
/**
 * Interface for the execution context in a web worker or similar environment.
 */
interface ExecutionContext {
  /**
   * Extends the lifetime of the event callback until the promise is settled.
   *
   * @param promise - A promise to wait for.
   */
  waitUntil(promise: Promise<unknown>): void;
  /**
   * Allows the event to be passed through to subsequent event listeners.
   */
  passThroughOnException(): void;
}
/**
 * Interface for context variable mapping.
 */
interface ContextVariableMap {}
/**
 * Interface for context renderer.
 */
interface ContextRenderer {}
/**
 * Interface representing a renderer for content.
 *
 * @interface DefaultRenderer
 * @param {string | Promise<string>} content - The content to be rendered, which can be either a string or a Promise resolving to a string.
 * @returns {Response | Promise<Response>} - The response after rendering the content, which can be either a Response or a Promise resolving to a Response.
 */
interface DefaultRenderer {
  (content: string | Promise<string>): Response | Promise<Response>;
}
/**
 * Renderer type which can either be a ContextRenderer or DefaultRenderer.
 */
type Renderer = ContextRenderer extends Function ? ContextRenderer : DefaultRenderer;
/**
 * Extracts the props for the renderer.
 */
type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
type Layout<T$1 = Record<string, any>> = (props: T$1) => any;
/**
 * Interface for getting context variables.
 *
 * @template E - Environment type.
 */
interface Get<E$1 extends Env> {
  <Key extends keyof E$1["Variables"]>(key: Key): E$1["Variables"][Key];
  <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
}
/**
 * Interface for setting context variables.
 *
 * @template E - Environment type.
 */
interface Set$1<E$1 extends Env> {
  <Key extends keyof E$1["Variables"]>(key: Key, value: E$1["Variables"][Key]): void;
  <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
}
/**
 * Interface for creating a new response.
 */
interface NewResponse {
  (data: Data | null, status?: StatusCode, headers?: HeaderRecord): Response;
  (data: Data | null, init?: ResponseOrInit): Response;
}
/**
 * Interface for responding with a body.
 */
interface BodyRespond {
  <U extends ContentfulStatusCode>(data: Data, status?: U, headers?: HeaderRecord): Response & TypedResponse<unknown, U, "body">;
  <U extends StatusCode>(data: null, status?: U, headers?: HeaderRecord): Response & TypedResponse<null, U, "body">;
  <U extends ContentfulStatusCode>(data: Data, init?: ResponseOrInit<U>): Response & TypedResponse<unknown, U, "body">;
  <U extends StatusCode>(data: null, init?: ResponseOrInit<U>): Response & TypedResponse<null, U, "body">;
}
/**
 * Interface for responding with text.
 *
 * @interface TextRespond
 * @template T - The type of the text content.
 * @template U - The type of the status code.
 *
 * @param {T} text - The text content to be included in the response.
 * @param {U} [status] - An optional status code for the response.
 * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
 *
 * @returns {Response & TypedResponse<T, U, 'text'>} - The response after rendering the text content, typed with the provided text and status code types.
 */
interface TextRespond {
  <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, "text">;
  <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, "text">;
}
/**
 * Interface for responding with JSON.
 *
 * @interface JSONRespond
 * @template T - The type of the JSON value or simplified unknown type.
 * @template U - The type of the status code.
 *
 * @param {T} object - The JSON object to be included in the response.
 * @param {U} [status] - An optional status code for the response.
 * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
 *
 * @returns {JSONRespondReturn<T, U>} - The response after rendering the JSON object, typed with the provided object and status code types.
 */
interface JSONRespond {
  <T extends JSONValue | SimplifyDeepArray<unknown> | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
  <T extends JSONValue | SimplifyDeepArray<unknown> | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, init?: ResponseOrInit<U>): JSONRespondReturn<T, U>;
}
/**
 * @template T - The type of the JSON value or simplified unknown type.
 * @template U - The type of the status code.
 *
 * @returns {Response & TypedResponse<SimplifyDeepArray<T> extends JSONValue ? (JSONValue extends SimplifyDeepArray<T> ? never : JSONParsed<T>) : never, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
 */
type JSONRespondReturn<T$1 extends JSONValue | SimplifyDeepArray<unknown> | InvalidJSONValue, U$1 extends ContentfulStatusCode> = Response & TypedResponse<SimplifyDeepArray<T$1> extends JSONValue ? JSONValue extends SimplifyDeepArray<T$1> ? never : JSONParsed<T$1> : never, U$1, "json">;
/**
 * Interface representing a function that responds with HTML content.
 *
 * @param html - The HTML content to respond with, which can be a string or a Promise that resolves to a string.
 * @param status - (Optional) The HTTP status code for the response.
 * @param headers - (Optional) A record of headers to include in the response.
 * @param init - (Optional) The response initialization object.
 *
 * @returns A Response object or a Promise that resolves to a Response object.
 */
interface HTMLRespond {
  <T extends string | Promise<string>>(html: T, status?: ContentfulStatusCode, headers?: HeaderRecord): T extends string ? Response : Promise<Response>;
  <T extends string | Promise<string>>(html: T, init?: ResponseOrInit<ContentfulStatusCode>): T extends string ? Response : Promise<Response>;
}
/**
 * Options for configuring the context.
 *
 * @template E - Environment type.
 */
type ContextOptions<E$1 extends Env> = {
  /**
   * Bindings for the environment.
   */
  env: E$1["Bindings"];
  /**
   * Execution context for the request.
   */
  executionCtx?: FetchEventLike | ExecutionContext | undefined;
  /**
   * Handler for not found responses.
   */
  notFoundHandler?: NotFoundHandler<E$1>;
  matchResult?: Result<[H, RouterRoute]>;
  path?: string;
};
interface SetHeadersOptions {
  append?: boolean;
}
interface SetHeaders {
  (name: "Content-Type", value?: BaseMime, options?: SetHeadersOptions): void;
  (name: ResponseHeader, value?: string, options?: SetHeadersOptions): void;
  (name: string, value?: string, options?: SetHeadersOptions): void;
}
type ResponseHeadersInit = [string, string][] | Record<"Content-Type", BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
interface ResponseInit<T$1 extends StatusCode = StatusCode> {
  headers?: ResponseHeadersInit;
  status?: T$1;
  statusText?: string;
}
type ResponseOrInit<T$1 extends StatusCode = StatusCode> = ResponseInit<T$1> | Response;
declare class Context<E$1 extends Env = any, P$1 extends string = any, I$1 extends Input = {}> {
  /**
   * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
   *
   * @see {@link https://hono.dev/docs/api/context#env}
   *
   * @example
   * ```ts
   * // Environment object for Cloudflare Workers
   * app.get('*', async c => {
   *   const counter = c.env.COUNTER
   * })
   * ```
   */
  env: E$1["Bindings"];
  finalized: boolean;
  /**
   * `.error` can get the error object from the middleware if the Handler throws an error.
   *
   * @see {@link https://hono.dev/docs/api/context#error}
   *
   * @example
   * ```ts
   * app.use('*', async (c, next) => {
   *   await next()
   *   if (c.error) {
   *     // do something...
   *   }
   * })
   * ```
   */
  error: Error | undefined;
  /**
   * Creates an instance of the Context class.
   *
   * @param req - The Request object.
   * @param options - Optional configuration options for the context.
   */
  constructor(req: Request, options?: ContextOptions<E$1>);
  /**
   * `.req` is the instance of {@link HonoRequest}.
   */
  get req(): HonoRequest<P$1, I$1["out"]>;
  /**
   * @see {@link https://hono.dev/docs/api/context#event}
   * The FetchEvent associated with the current request.
   *
   * @throws Will throw an error if the context does not have a FetchEvent.
   */
  get event(): FetchEventLike;
  /**
   * @see {@link https://hono.dev/docs/api/context#executionctx}
   * The ExecutionContext associated with the current request.
   *
   * @throws Will throw an error if the context does not have an ExecutionContext.
   */
  get executionCtx(): ExecutionContext;
  /**
   * @see {@link https://hono.dev/docs/api/context#res}
   * The Response object for the current request.
   */
  get res(): Response;
  /**
   * Sets the Response object for the current request.
   *
   * @param _res - The Response object to set.
   */
  set res(_res: Response | undefined);
  /**
   * `.render()` can create a response within a layout.
   *
   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
   *
   * @example
   * ```ts
   * app.get('/', (c) => {
   *   return c.render('Hello!')
   * })
   * ```
   */
  render: Renderer;
  /**
   * Sets the layout for the response.
   *
   * @param layout - The layout to set.
   * @returns The layout function.
   */
  setLayout: (layout: Layout<PropsForRenderer & {
    Layout: Layout;
  }>) => Layout<PropsForRenderer & {
    Layout: Layout;
  }>;
  /**
   * Gets the current layout for the response.
   *
   * @returns The current layout function.
   */
  getLayout: () => Layout<PropsForRenderer & {
    Layout: Layout;
  }> | undefined;
  /**
   * `.setRenderer()` can set the layout in the custom middleware.
   *
   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
   *
   * @example
   * ```tsx
   * app.use('*', async (c, next) => {
   *   c.setRenderer((content) => {
   *     return c.html(
   *       <html>
   *         <body>
   *           <p>{content}</p>
   *         </body>
   *       </html>
   *     )
   *   })
   *   await next()
   * })
   * ```
   */
  setRenderer: (renderer: Renderer) => void;
  /**
   * `.header()` can set headers.
   *
   * @see {@link https://hono.dev/docs/api/context#body}
   *
   * @example
   * ```ts
   * app.get('/welcome', (c) => {
   *   // Set headers
   *   c.header('X-Message', 'Hello!')
   *   c.header('Content-Type', 'text/plain')
   *
   *   return c.body('Thank you for coming')
   * })
   * ```
   */
  header: SetHeaders;
  status: (status: StatusCode) => void;
  /**
   * `.set()` can set the value specified by the key.
   *
   * @see {@link https://hono.dev/docs/api/context#set-get}
   *
   * @example
   * ```ts
   * app.use('*', async (c, next) => {
   *   c.set('message', 'Hono is hot!!')
   *   await next()
   * })
   * ```
   */
  set: Set$1<IsAny<E$1> extends true ? {
    Variables: ContextVariableMap & Record<string, any>;
  } : E$1>;
  /**
   * `.get()` can use the value specified by the key.
   *
   * @see {@link https://hono.dev/docs/api/context#set-get}
   *
   * @example
   * ```ts
   * app.get('/', (c) => {
   *   const message = c.get('message')
   *   return c.text(`The message is "${message}"`)
   * })
   * ```
   */
  get: Get<IsAny<E$1> extends true ? {
    Variables: ContextVariableMap & Record<string, any>;
  } : E$1>;
  /**
   * `.var` can access the value of a variable.
   *
   * @see {@link https://hono.dev/docs/api/context#var}
   *
   * @example
   * ```ts
   * const result = c.var.client.oneMethod()
   * ```
   */
  get var(): Readonly<ContextVariableMap & (IsAny<E$1["Variables"]> extends true ? Record<string, any> : E$1["Variables"])>;
  newResponse: NewResponse;
  /**
   * `.body()` can return the HTTP response.
   * You can set headers with `.header()` and set HTTP status code with `.status`.
   * This can also be set in `.text()`, `.json()` and so on.
   *
   * @see {@link https://hono.dev/docs/api/context#body}
   *
   * @example
   * ```ts
   * app.get('/welcome', (c) => {
   *   // Set headers
   *   c.header('X-Message', 'Hello!')
   *   c.header('Content-Type', 'text/plain')
   *   // Set HTTP status code
   *   c.status(201)
   *
   *   // Return the response body
   *   return c.body('Thank you for coming')
   * })
   * ```
   */
  body: BodyRespond;
  /**
   * `.text()` can render text as `Content-Type:text/plain`.
   *
   * @see {@link https://hono.dev/docs/api/context#text}
   *
   * @example
   * ```ts
   * app.get('/say', (c) => {
   *   return c.text('Hello!')
   * })
   * ```
   */
  text: TextRespond;
  /**
   * `.json()` can render JSON as `Content-Type:application/json`.
   *
   * @see {@link https://hono.dev/docs/api/context#json}
   *
   * @example
   * ```ts
   * app.get('/api', (c) => {
   *   return c.json({ message: 'Hello!' })
   * })
   * ```
   */
  json: JSONRespond;
  html: HTMLRespond;
  /**
   * `.redirect()` can Redirect, default status code is 302.
   *
   * @see {@link https://hono.dev/docs/api/context#redirect}
   *
   * @example
   * ```ts
   * app.get('/redirect', (c) => {
   *   return c.redirect('/')
   * })
   * app.get('/redirect-permanently', (c) => {
   *   return c.redirect('/', 301)
   * })
   * ```
   */
  redirect: <T extends RedirectStatusCode = 302>(location: string | URL, status?: T) => Response & TypedResponse<undefined, T, "redirect">;
  /**
   * `.notFound()` can return the Not Found Response.
   *
   * @see {@link https://hono.dev/docs/api/context#notfound}
   *
   * @example
   * ```ts
   * app.get('/notfound', (c) => {
   *   return c.notFound()
   * })
   * ```
   */
  notFound: () => Response | Promise<Response>;
}
//#endregion
export { Hono as a, Schema as i, BlankSchema as n, HonoOptions as o, Env as r, BlankEnv as t };