hono

• GetPath

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

• HonoOptions

  export type HonoOptions<E extends Env> = {
      /**
       * `strict` option specifies whether to distinguish whether the last path is a directory or not.
       *
       * @see {@link https://hono.dev/docs/api/hono#strict-mode}
       *
       * @default true
       */
      strict?: boolean;
      /**
       * `router` option 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>;
  };

• MountOptionHandler

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

• MountReplaceRequest

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

• MountOptions

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

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

• OnError

  type OnError = (c: Context) => Response | Promise<Response>;

• BodyLimitOptions

  type BodyLimitOptions = {
      maxSize: number;
      onError?: OnError;
  };

• bodyLimit

  /**
   * Body Limit Middleware for Hono.
   *
   * @see {@link https://hono.dev/docs/middleware/builtin/body-limit}
   *
   * @param {BodyLimitOptions} options - The options for the body limit middleware.
   * @param {number} options.maxSize - The maximum body size allowed.
   * @param {OnError} [options.onError] - The error handler to be invoked if the specified body size is exceeded.
   * @returns {MiddlewareHandler} The middleware handler function.
   *
   * @example
   * ```ts
   * const app = new Hono()
   *
   * app.post(
   *   '/upload',
   *   bodyLimit({
   *     maxSize: 50 * 1024, // 50kb
   *     onError: (c) => {
   *       return c.text('overflow :(', 413)
   *     },
   *   }),
   *   async (c) => {
   *     const body = await c.req.parseBody()
   *     if (body['file'] instanceof File) {
   *       console.log(`Got file sized: ${body['file'].size}`)
   *     }
   *     return c.text('pass :)')
   *   }
   * )
   * ```
   */
  export declare const bodyLimit: (options: BodyLimitOptions) => MiddlewareHandler;

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

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

• ServeStaticOptions

  export type ServeStaticOptions<E extends Env = Env> = {
      root?: string;
      path?: string;
      precompressed?: boolean;
      mimes?: Record<string, string>;
      rewriteRequestPath?: (path: string) => string;
      onFound?: (path: string, c: Context<E>) => void | Promise<void>;
      onNotFound?: (path: string, c: Context<E>) => void | Promise<void>;
  };

• serveStatic

  /**
   * This middleware is not directly used by the user. Create a wrapper specifying `getContent()` by the environment such as Deno or Bun.
   */
  export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E> & {
      getContent: (path: string, c: Context<E>) => Promise<Data | Response | null>;
      pathResolve?: (path: string) => string;
      isDir?: (path: string) => boolean | undefined | Promise<boolean | undefined>;
  }) => MiddlewareHandler;

/**
 * @module
 * Serve Static Middleware for Hono.
 */
import type { Context, Data } from '../../context';
import type { Env, MiddlewareHandler } from '../../types';
export type ServeStaticOptions<E extends Env = Env> = {
    root?: string;
    path?: string;
    precompressed?: boolean;
    mimes?: Record<string, string>;
    rewriteRequestPath?: (path: string) => string;
    onFound?: (path: string, c: Context<E>) => void | Promise<void>;
    onNotFound?: (path: string, c: Context<E>) => void | Promise<void>;
};
/**
 * This middleware is not directly used by the user. Create a wrapper specifying `getContent()` by the environment such as Deno or Bun.
 */
export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E> & {
    getContent: (path: string, c: Context<E>) => Promise<Data | Response | null>;
    pathResolve?: (path: string) => string;
    isDir?: (path: string) => boolean | undefined | Promise<boolean | undefined>;
}) => MiddlewareHandler;

• HTTPExceptionOptions

  /**
   * Options for creating an `HTTPException`.
   * @property res - Optional response object to use.
   * @property message - Optional custom error message.
   * @property cause - Optional cause of the error.
   */
  type HTTPExceptionOptions = {
      res?: Response;
      message?: string;
      cause?: unknown;
  };

/**
 * @module
 * This module provides the `HTTPException` class.
 */
import type { StatusCode } from './utils/http-status';
/**
 * Options for creating an `HTTPException`.
 * @property res - Optional response object to use.
 * @property message - Optional custom error message.
 * @property cause - Optional cause of the error.
 */
type HTTPExceptionOptions = {
    res?: Response;
    message?: string;
    cause?: unknown;
};
/**
 * `HTTPException` must be used when a fatal error such as authentication failure occurs.
 *
 * @see {@link https://hono.dev/docs/api/exception}
 *
 * @param {StatusCode} status - status code of HTTPException
 * @param {HTTPExceptionOptions} options - options of HTTPException
 * @param {HTTPExceptionOptions["res"]} options.res - response of options of HTTPException
 * @param {HTTPExceptionOptions["message"]} options.message - message of options of HTTPException
 * @param {HTTPExceptionOptions["cause"]} options.cause - cause of options of HTTPException
 *
 * @example
 * ```ts
 * import { HTTPException } from 'hono/http-exception'
 *
 * // ...
 *
 * app.post('/auth', async (c, next) => {
 *   // authentication
 *   if (authorized === false) {
 *     throw new HTTPException(401, { message: 'Custom error message' })
 *   }
 *   await next()
 * })
 * ```
 */
export declare class HTTPException extends Error {
    readonly res?: Response;
    readonly status: StatusCode;
    /**
     * Creates an instance of `HTTPException`.
     * @param status - HTTP status code for the exception. Defaults to 500.
     * @param options - Additional options for the exception.
     */
    constructor(status?: StatusCode, options?: HTTPExceptionOptions);
    /**
     * Returns the response object associated with the exception.
     * If a response object is not provided, a new response is created with the error message and status code.
     * @returns The response object.
     */
    getResponse(): Response;
}
export {};

• ETagOptions

  type ETagOptions = {
      retainedHeaders?: string[];
      weak?: boolean;
  };

• etag

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

/**
 * @module
 * ETag Middleware for Hono.
 */
import type { MiddlewareHandler } from '../../types';
type ETagOptions = {
    retainedHeaders?: string[];
    weak?: boolean;
};
/**
 * Default headers to pass through on 304 responses. From the spec:
 * > The response must not contain a body and must include the headers that
 * > would have been sent in an equivalent 200 OK response: Cache-Control,
 * > Content-Location, Date, ETag, Expires, and Vary.
 */
export declare const RETAINED_304_HEADERS: string[];
/**
 * ETag Middleware for Hono.
 *
 * @see {@link https://hono.dev/docs/middleware/builtin/etag}
 *
 * @param {ETagOptions} [options] - The options for the ETag middleware.
 * @param {boolean} [options.weak=false] - Define using or not using a weak validation. If true is set, then `W/` is added to the prefix of the value.
 * @param {string[]} [options.retainedHeaders=RETAINED_304_HEADERS] - The headers that you want to retain in the 304 Response.
 * @returns {MiddlewareHandler} The middleware handler function.
 *
 * @example
 * ```ts
 * const app = new Hono()
 *
 * app.use('/etag/*', etag())
 * app.get('/etag/abc', (c) => {
 *   return c.text('Hono is cool')
 * })
 * ```
 */
export declare const etag: (options?: ETagOptions) => MiddlewareHandler;
export {};

• CORSOptions

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

• cors

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

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

• CompressionOptions

  interface CompressionOptions {
      encoding?: (typeof ENCODING_TYPES)[number];
      threshold?: number;
  }

• compress

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

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

• jsxDEV

  export declare const jsxDEV: (tag: string | Function, props: Props, key?: string) => JSXNode;

• Fragment

  export declare const Fragment: (props: Record<string, unknown>) => JSXNode;

/**
 * @module
 * This module provides the `hono/jsx/dom` dev runtime.
 */
import type { JSXNode, Props } from '../base';
export declare const jsxDEV: (tag: string | Function, props: Props, key?: string) => JSXNode;
export declare const Fragment: (props: Record<string, unknown>) => JSXNode;

• Root

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

• RootOptions

  export type RootOptions = Record<string, unknown>;

• createRoot

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

• hydrateRoot

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

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

• GetCookie

  interface GetCookie {
      (c: Context, key: string): string | undefined;
      (c: Context): Cookie;
      (c: Context, key: string, prefixOptions: CookiePrefixOptions): string | undefined;
  }

• GetSignedCookie

  interface GetSignedCookie {
      (c: Context, secret: string | BufferSource, key: string): Promise<string | undefined | false>;
      (c: Context, secret: string): Promise<SignedCookie>;
      (c: Context, secret: string | BufferSource, key: string, prefixOptions: CookiePrefixOptions): Promise<string | undefined | false>;
  }

• setCookie

  export declare const setCookie: (c: Context, name: string, value: string, opt?: CookieOptions) => void;

• setSignedCookie

  export declare const setSignedCookie: (c: Context, name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<void>;

• deleteCookie

  export declare const deleteCookie: (c: Context, name: string, opt?: CookieOptions) => string | undefined;

/**
 * @module
 * Cookie Helper for Hono.
 */
import type { Context } from '../../context';
import type { Cookie, CookieOptions, CookiePrefixOptions, SignedCookie } from '../../utils/cookie';
interface GetCookie {
    (c: Context, key: string): string | undefined;
    (c: Context): Cookie;
    (c: Context, key: string, prefixOptions: CookiePrefixOptions): string | undefined;
}
interface GetSignedCookie {
    (c: Context, secret: string | BufferSource, key: string): Promise<string | undefined | false>;
    (c: Context, secret: string): Promise<SignedCookie>;
    (c: Context, secret: string | BufferSource, key: string, prefixOptions: CookiePrefixOptions): Promise<string | undefined | false>;
}
export declare const getCookie: GetCookie;
export declare const getSignedCookie: GetSignedCookie;
export declare const setCookie: (c: Context, name: string, value: string, opt?: CookieOptions) => void;
export declare const setSignedCookie: (c: Context, name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<void>;
export declare const deleteCookie: (c: Context, name: string, opt?: CookieOptions) => string | undefined;
export {};

• PrintFunc

  type PrintFunc = (str: string, ...rest: string[]) => void;

• logger

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

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

• html

  export declare const html: (strings: TemplateStringsArray, ...values: unknown[]) => HtmlEscapedString | Promise<HtmlEscapedString>;

/**
 * @module
 * html Helper for Hono.
 */
import { raw } from '../../utils/html';
import type { HtmlEscapedString } from '../../utils/html';
export { raw };
export declare const html: (strings: TemplateStringsArray, ...values: unknown[]) => HtmlEscapedString | Promise<HtmlEscapedString>;

• IsAllowedOriginHandler

  type IsAllowedOriginHandler = (origin: string, context: Context) => boolean;

• CSRFOptions

  interface CSRFOptions {
      origin?: string | string[] | IsAllowedOriginHandler;
  }

• csrf

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

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

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

• MessageFunction

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

• BearerAuthOptions

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

• bearerAuth

  /**
   * Bearer Auth Middleware for Hono.
   *
   * @see {@link https://hono.dev/docs/middleware/builtin/bearer-auth}
   *
   * @param {BearerAuthOptions} options - The options for the bearer authentication middleware.
   * @param {string | string[]} [options.token] - The string or array of strings to validate the incoming bearer token against.
   * @param {Function} [options.verifyToken] - The function to verify the token.
   * @param {string} [options.realm=""] - The domain name of the realm, as part of the returned WWW-Authenticate challenge header.
   * @param {string} [options.prefix="Bearer"] - The prefix (or known as `schema`) for the Authorization header value. If set to the empty string, no prefix is expected.
   * @param {string} [options.headerName=Authorization] - The header name.
   * @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
   * @param {string | object | MessageFunction} [options.noAuthenticationHeaderMessage="Unauthorized"] - The no authentication header message.
   * @param {string | object | MessageFunction} [options.invalidAuthenticationHeaderMeasage="Bad Request"] - The invalid authentication header message.
   * @param {string | object | MessageFunction} [options.invalidTokenMessage="Unauthorized"] - The invalid token message.
   * @returns {MiddlewareHandler} The middleware handler function.
   * @throws {Error} If neither "token" nor "verifyToken" options are provided.
   * @throws {HTTPException} If authentication fails, with 401 status code for missing or invalid token, or 400 status code for invalid request.
   *
   * @example
   * ```ts
   * const app = new Hono()
   *
   * const token = 'honoiscool'
   *
   * app.use('/api/*', bearerAuth({ token }))
   *
   * app.get('/api/page', (c) => {
   *   return c.json({ message: 'You are authorized' })
   * })
   * ```
   */
  export declare const bearerAuth: (options: BearerAuthOptions) => MiddlewareHandler;

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

• CreateCssJsxDomObjectsType

  interface CreateCssJsxDomObjectsType {
      (args: {
          id: Readonly<string>;
      }): readonly [
          {
              toString(this: CssClassName): string;
          },
          FC<PropsWithChildren<void>>
      ];
  }

• CssType

  interface CssType {
      (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
  }

• CxType

  interface CxType {
      (...args: (string | boolean | null | undefined)[]): string;
  }

• KeyframesType

  interface KeyframesType {
      (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassName;
  }

• ViewTransitionType

  interface ViewTransitionType {
      (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
      (content: string): string;
      (): string;
  }

• DefaultContextType

  interface DefaultContextType {
      css: CssType;
      cx: CxType;
      keyframes: KeyframesType;
      viewTransition: ViewTransitionType;
      Style: FC<PropsWithChildren<void>>;
  }

• createCssContext

  /**
   * @experimental
   * `createCssContext` is an experimental feature.
   * The API might be changed.
   */
  export declare const createCssContext: ({ id }: {
      id: Readonly<string>;
  }) => DefaultContextType;

/**
 * @module
 * This module provides APIs that enable `hono/jsx/dom` to support.
 */
import type { FC, PropsWithChildren } from '../';
import type { CssClassName, CssVariableType } from '../../helper/css/common';
export { rawCssString } from '../../helper/css/common';
interface CreateCssJsxDomObjectsType {
    (args: {
        id: Readonly<string>;
    }): readonly [
        {
            toString(this: CssClassName): string;
        },
        FC<PropsWithChildren<void>>
    ];
}
export declare const createCssJsxDomObjects: CreateCssJsxDomObjectsType;
interface CssType {
    (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
}
interface CxType {
    (...args: (string | boolean | null | undefined)[]): string;
}
interface KeyframesType {
    (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassName;
}
interface ViewTransitionType {
    (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
    (content: string): string;
    (): string;
}
interface DefaultContextType {
    css: CssType;
    cx: CxType;
    keyframes: KeyframesType;
    viewTransition: ViewTransitionType;
    Style: FC<PropsWithChildren<void>>;
}
/**
 * @experimental
 * `createCssContext` is an experimental feature.
 * The API might be changed.
 */
export declare const createCssContext: ({ id }: {
    id: Readonly<string>;
}) => DefaultContextType;
/**
 * @experimental
 * `css` is an experimental feature.
 * The API might be changed.
 */
export declare const css: CssType;
/**
 * @experimental
 * `cx` is an experimental feature.
 * The API might be changed.
 */
export declare const cx: CxType;
/**
 * @experimental
 * `keyframes` is an experimental feature.
 * The API might be changed.
 */
export declare const keyframes: KeyframesType;
/**
 * @experimental
 * `viewTransition` is an experimental feature.
 * The API might be changed.
 */
export declare const viewTransition: ViewTransitionType;
/**
 * @experimental
 * `Style` is an experimental feature.
 * The API might be changed.
 */
export declare const Style: FC<PropsWithChildren<void>>;

/**
 * @module
 * JWT utility.
 */
export declare const Jwt: {
    sign: (payload: import("./types").JWTPayload, privateKey: import("./jws").SignatureKey, alg?: import("./jwa").SignatureAlgorithm) => Promise<string>;
    verify: (token: string, publicKey: import("./jws").SignatureKey, alg?: import("./jwa").SignatureAlgorithm) => Promise<import("./types").JWTPayload>;
    decode: (token: string) => {
        header: import("./jwt").TokenHeader;
        payload: import("./types").JWTPayload;
    };
};

• PoweredByOptions

  type PoweredByOptions = {
      /**
       * The value for X-Powered-By header.
       * @default Hono
       */
      serverName?: string;
  };

• poweredBy

  /**
   * Powered By Middleware for Hono.
   *
   * @param options - The options for the Powered By Middleware.
   * @returns {MiddlewareHandler} The middleware handler function.
   *
   * @example
   * ```ts
   * import { poweredBy } from 'hono/powered-by'
   *
   * const app = new Hono()
   *
   * app.use(poweredBy()) // With options: poweredBy({ serverName: "My Server" })
   * ```
   */
  export declare const poweredBy: (options?: PoweredByOptions) => MiddlewareHandler;

/**
 * @module
 * Powered By Middleware for Hono.
 */
import type { MiddlewareHandler } from '../../types';
type PoweredByOptions = {
    /**
     * The value for X-Powered-By header.
     * @default Hono
     */
    serverName?: string;
};
/**
 * Powered By Middleware for Hono.
 *
 * @param options - The options for the Powered By Middleware.
 * @returns {MiddlewareHandler} The middleware handler function.
 *
 * @example
 * ```ts
 * import { poweredBy } from 'hono/powered-by'
 *
 * const app = new Hono()
 *
 * app.use(poweredBy()) // With options: poweredBy({ serverName: "My Server" })
 * ```
 */
export declare const poweredBy: (options?: PoweredByOptions) => MiddlewareHandler;
export {};

• trimTrailingSlash

  /**
   * Trailing Slash Middleware for Hono.
   *
   * @see {@link https://hono.dev/docs/middleware/builtin/trailing-slash}
   *
   * @returns {MiddlewareHandler} The middleware handler function.
   *
   * @example
   * ```ts
   * const app = new Hono()
   *
   * app.use(trimTrailingSlash())
   * app.get('/about/me/', (c) => c.text('With Trailing Slash'))
   * ```
   */
  export declare const trimTrailingSlash: () => MiddlewareHandler;

• appendTrailingSlash

  /**
   * Append trailing slash middleware for Hono.
   * Append a trailing slash to the URL if it doesn't have one. For example, `/path/to/page` will be redirected to `/path/to/page/`.
   *
   * @see {@link https://hono.dev/docs/middleware/builtin/trailing-slash}
   *
   * @returns {MiddlewareHandler} The middleware handler function.
   *
   * @example
   * ```ts
   * const app = new Hono()
   *
   * app.use(appendTrailingSlash())
   * ```
   */
  export declare const appendTrailingSlash: () => MiddlewareHandler;

/**
 * @module
 * Trailing Slash Middleware for Hono.
 */
import type { MiddlewareHandler } from '../../types';
/**
 * Trailing Slash Middleware for Hono.
 *
 * @see {@link https://hono.dev/docs/middleware/builtin/trailing-slash}
 *
 * @returns {MiddlewareHandler} The middleware handler function.
 *
 * @example
 * ```ts
 * const app = new Hono()
 *
 * app.use(trimTrailingSlash())
 * app.get('/about/me/', (c) => c.text('With Trailing Slash'))
 * ```
 */
export declare const trimTrailingSlash: () => MiddlewareHandler;
/**
 * Append trailing slash middleware for Hono.
 * Append a trailing slash to the URL if it doesn't have one. For example, `/path/to/page` will be redirected to `/path/to/page/`.
 *
 * @see {@link https://hono.dev/docs/middleware/builtin/trailing-slash}
 *
 * @returns {MiddlewareHandler} The middleware handler function.
 *
 * @example
 * ```ts
 * const app = new Hono()
 *
 * app.use(appendTrailingSlash())
 * ```
 */
export declare const appendTrailingSlash: () => MiddlewareHandler;

• ShowRoutesOptions

  interface ShowRoutesOptions {
      verbose?: boolean;
      colorize?: boolean;
  }

• RouteData

  interface RouteData {
      path: string;
      method: string;
      name: string;
      isMiddleware: boolean;
  }

• inspectRoutes

  export declare const inspectRoutes: <E extends Env>(hono: Hono<E>) => RouteData[];

• showRoutes

  export declare const showRoutes: <E extends Env>(hono: Hono<E>, opts?: ShowRoutesOptions) => void;

• getRouterName

  export declare const getRouterName: <E extends Env>(app: Hono<E>) => string;

/**
 * @module
 * Dev Helper for Hono.
 */
import type { Hono } from '../../hono';
import type { Env } from '../../types';
interface ShowRoutesOptions {
    verbose?: boolean;
    colorize?: boolean;
}
interface RouteData {
    path: string;
    method: string;
    name: string;
    isMiddleware: boolean;
}
export declare const inspectRoutes: <E extends Env>(hono: Hono<E>) => RouteData[];
export declare const showRoutes: <E extends Env>(hono: Hono<E>, opts?: ShowRoutesOptions) => void;
export declare const getRouterName: <E extends Env>(app: Hono<E>) => string;
export {};

• HTTPExceptionFunction

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

• timeout

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

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

• ExtractEnv

  type ExtractEnv<T> = T extends Hono<infer E, Schema, string> ? E : never;

• testClient

  export declare const testClient: <T extends Hono<any, Schema, string>>(app: T, Env?: ExtractEnv<T>["Bindings"] | {}, executionCtx?: ExecutionContext) => UnionToIntersection<Client<T>>;

/**
 * @module
 * Testing Helper for Hono.
 */
import type { Client } from '../../client/types';
import type { ExecutionContext } from '../../context';
import type { Hono } from '../../hono';
import type { Schema } from '../../types';
import type { UnionToIntersection } from '../../utils/types';
type ExtractEnv<T> = T extends Hono<infer E, Schema, string> ? E : never;
export declare const testClient: <T extends Hono<any, Schema, string>>(app: T, Env?: ExtractEnv<T>["Bindings"] | {}, executionCtx?: ExecutionContext) => UnionToIntersection<Client<T>>;
export {};

• Body

  type Body = {
      json: any;
      text: string;
      arrayBuffer: ArrayBuffer;
      blob: Blob;
      formData: FormData;
  };

• BodyCache

  type BodyCache = Partial<Body & {
      parsedBody: BodyData;
  }>;

import type { Result } from './router';
import type { Input, InputToDataByTarget, ParamKeyToRecord, ParamKeys, RemoveQuestion, RouterRoute, ValidationTargets } from './types';
import type { BodyData, ParseBodyOptions } from './utils/body';
import type { CustomHeader, RequestHeader } from './utils/headers';
import type { Simplify, UnionToIntersection } from './utils/types';
type Body = {
    json: any;
    text: string;
    arrayBuffer: ArrayBuffer;
    blob: Blob;
    formData: FormData;
};
type BodyCache = Partial<Body & {
    parsedBody: BodyData;
}>;
export declare class HonoRequest<P extends string = "/", I 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> = ParamKeys<P>>(key: P2 extends `${infer _}?` ? never : P2): string;
    param<P2 extends RemoveQuestion<ParamKeys<P>> = RemoveQuestion<ParamKeys<P>>>(key: P2): string | undefined;
    param(key: string): string | undefined;
    param<P2 extends string = P>(): 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 & keyof ValidationTargets>(target: T): InputToDataByTarget<I, 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;
}
export {};

• MessageFunction

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

• BasicAuthOptions

  type BasicAuthOptions = {
      username: string;
      password: string;
      realm?: string;
      hashFunction?: Function;
      invalidUserMessage?: string | object | MessageFunction;
  } | {
      verifyUser: (username: string, password: string, c: Context) => boolean | Promise<boolean>;
      realm?: string;
      hashFunction?: Function;
      invalidUserMessage?: string | object | MessageFunction;
  };

• basicAuth

  /**
   * Basic Auth Middleware for Hono.
   *
   * @see {@link https://hono.dev/docs/middleware/builtin/basic-auth}
   *
   * @param {BasicAuthOptions} options - The options for the basic authentication middleware.
   * @param {string} options.username - The username for authentication.
   * @param {string} options.password - The password for authentication.
   * @param {string} [options.realm="Secure Area"] - The realm attribute for the WWW-Authenticate header.
   * @param {Function} [options.hashFunction] - The hash function used for secure comparison.
   * @param {Function} [options.verifyUser] - The function to verify user credentials.
   * @param {string | object | MessageFunction} [options.invalidUserMessage="Unauthorized"] - The invalid user message.
   * @returns {MiddlewareHandler} The middleware handler function.
   * @throws {HTTPException} If neither "username and password" nor "verifyUser" options are provided.
   *
   * @example
   * ```ts
   * const app = new Hono()
   *
   * app.use(
   *   '/auth/*',
   *   basicAuth({
   *     username: 'hono',
   *     password: 'acoolproject',
   *   })
   * )
   *
   * app.get('/auth/page', (c) => {
   *   return c.text('You are authorized')
   * })
   * ```
   */
  export declare const basicAuth: (options: BasicAuthOptions, ...users: {
      username: string;
      password: string;
  }[]) => MiddlewareHandler;

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

• WSEvents

  /**
   * WebSocket Event Listeners type
   */
  export interface WSEvents<T = unknown> {
      onOpen?: (evt: Event, ws: WSContext<T>) => void;
      onMessage?: (evt: MessageEvent<WSMessageReceive>, ws: WSContext<T>) => void;
      onClose?: (evt: CloseEvent, ws: WSContext<T>) => void;
      onError?: (evt: Event, ws: WSContext<T>) => void;
  }

• WSContextInit

  /**
   * An argument for WSContext class
   */
  export interface WSContextInit<T = unknown> {
      send(data: string | ArrayBuffer, options: SendOptions): void;
      close(code?: number, reason?: string): void;
      raw?: T;
      readyState: WSReadyState;
      url?: string | URL | null;
      protocol?: string | null;
  }

• SendOptions

  /**
   * Options for sending message
   */
  export interface SendOptions {
      compress?: boolean;
  }

• WebSocketHelperDefineContext

  export interface WebSocketHelperDefineContext {
  }

• UpgradeWebSocket

  /**
   * Upgrade WebSocket Type
   */
  export type UpgradeWebSocket<T = unknown, U = any, _WSEvents = WSEvents<T>> = (createEvents: (c: Context) => _WSEvents | Promise<_WSEvents>, options?: U) => MiddlewareHandler<any, string, {
      outputFormat: "ws";
  }>;

• WSReadyState

  /**
   * ReadyState for WebSocket
   */
  export type WSReadyState = 0 | 1 | 2 | 3;

• WSMessageReceive

  export type WSMessageReceive = string | Blob | ArrayBufferLike;

• WebSocketHelperDefineHandler

  export type WebSocketHelperDefineHandler<T, U> = (c: Context, events: WSEvents<T>, options?: U) => Promise<Response | void> | Response | void;

• createWSMessageEvent

  export declare const createWSMessageEvent: (source: WSMessageReceive) => MessageEvent<WSMessageReceive>;

• defineWebSocketHelper

  /**
   * Create a WebSocket adapter/helper
   */
  export declare const defineWebSocketHelper: <T = unknown, U = any>(handler: WebSocketHelperDefineHandler<T, U>) => UpgradeWebSocket<T, U>;

/**
 * @module
 * WebSocket Helper for Hono.
 */
import type { Context } from '../../context';
import type { MiddlewareHandler } from '../../types';
/**
 * WebSocket Event Listeners type
 */
export interface WSEvents<T = unknown> {
    onOpen?: (evt: Event, ws: WSContext<T>) => void;
    onMessage?: (evt: MessageEvent<WSMessageReceive>, ws: WSContext<T>) => void;
    onClose?: (evt: CloseEvent, ws: WSContext<T>) => void;
    onError?: (evt: Event, ws: WSContext<T>) => void;
}
/**
 * Upgrade WebSocket Type
 */
export type UpgradeWebSocket<T = unknown, U = any, _WSEvents = WSEvents<T>> = (createEvents: (c: Context) => _WSEvents | Promise<_WSEvents>, options?: U) => MiddlewareHandler<any, string, {
    outputFormat: "ws";
}>;
/**
 * ReadyState for WebSocket
 */
export type WSReadyState = 0 | 1 | 2 | 3;
/**
 * An argument for WSContext class
 */
export interface WSContextInit<T = unknown> {
    send(data: string | ArrayBuffer, options: SendOptions): void;
    close(code?: number, reason?: string): void;
    raw?: T;
    readyState: WSReadyState;
    url?: string | URL | null;
    protocol?: string | null;
}
/**
 * Options for sending message
 */
export interface SendOptions {
    compress?: boolean;
}
/**
 * A context for controlling WebSockets
 */
export declare class WSContext<T = unknown> {
    constructor(init: WSContextInit<T>);
    send(source: string | ArrayBuffer | Uint8Array, options?: SendOptions): void;
    raw?: T;
    binaryType: BinaryType;
    get readyState(): WSReadyState;
    url: URL | null;
    protocol: string | null;
    close(code?: number, reason?: string): void;
}
export type WSMessageReceive = string | Blob | ArrayBufferLike;
export declare const createWSMessageEvent: (source: WSMessageReceive) => MessageEvent<WSMessageReceive>;
export interface WebSocketHelperDefineContext {
}
export type WebSocketHelperDefineHandler<T, U> = (c: Context, events: WSEvents<T>, options?: U) => Promise<Response | void> | Response | void;
/**
 * Create a WebSocket adapter/helper
 */
export declare const defineWebSocketHelper: <T = unknown, U = any>(handler: WebSocketHelperDefineHandler<T, U>) => UpgradeWebSocket<T, U>;

• Router

  /**
   * Interface representing a router.
   *
   * @template T - The type of the handler.
   */
  export interface Router<T> {
      /**
       * 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): 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>;
  }

• ParamIndexMap

  /**
   * Type representing a map of parameter indices.
   */
  export type ParamIndexMap = Record<string, number>;

• ParamStash

  /**
   * Type representing a stash of parameters.
   */
  export type ParamStash = string[];

• Params

  /**
   * Type representing a map of parameters.
   */
  export type Params = Record<string, string>;

• Result

  /**
   * 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'
   *   ]
   * ]
   * ```
   */
  export type Result<T> = [
      [
          T,
          ParamIndexMap
      ][],
      ParamStash
  ] | [
      [
          T,
          Params
      ][]
  ];

/**
 * @module
 * This module provides types definitions and variables for the routers.
 */
/**
 * Constant representing all HTTP methods in uppercase.
 */
export declare const METHOD_NAME_ALL: "ALL";
/**
 * Constant representing all HTTP methods in lowercase.
 */
export declare const METHOD_NAME_ALL_LOWERCASE: "all";
/**
 * Array of supported HTTP methods.
 */
export declare const METHODS: readonly [
    "get",
    "post",
    "put",
    "delete",
    "options",
    "patch"
];
/**
 * Error message indicating that a route cannot be added because the matcher is already built.
 */
export declare const MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
/**
 * Interface representing a router.
 *
 * @template T - The type of the handler.
 */
export interface Router<T> {
    /**
     * 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): 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>;
}
/**
 * Type representing a map of parameter indices.
 */
export type ParamIndexMap = Record<string, number>;
/**
 * Type representing a stash of parameters.
 */
export type ParamStash = string[];
/**
 * Type representing a map of parameters.
 */
export 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'
 *   ]
 * ]
 * ```
 */
export type Result<T> = [
    [
        T,
        ParamIndexMap
    ][],
    ParamStash
] | [
    [
        T,
        Params
    ][]
];
/**
 * Error class representing an unsupported path error.
 */
export declare class UnsupportedPathError extends Error {
}

• RendererOptions

  type RendererOptions = {
      docType?: boolean | string;
      stream?: boolean | Record<string, string>;
  };

• ComponentWithChildren

  type ComponentWithChildren = (props: PropsWithChildren<PropsForRenderer & {
      Layout: FC;
  }>, c: Context) => HtmlEscapedString | Promise<HtmlEscapedString>;

• jsxRenderer

  /**
   * JSX Renderer Middleware for hono.
   *
   * @see {@link https://hono.dev/docs/middleware/builtin/jsx-renderer}
   *
   * @param {ComponentWithChildren} [component] - The component to render, which can accept children and props.
   * @param {RendererOptions} [options] - The options for the JSX renderer middleware.
   * @param {boolean | string} [options.docType=true] - The DOCTYPE to be added at the beginning of the HTML. If set to false, no DOCTYPE will be added.
   * @param {boolean | Record<string, string>} [options.stream=false] - If set to true, enables streaming response with default headers. If a record is provided, custom headers will be used.
   * @returns {MiddlewareHandler} The middleware handler function.
   *
   * @example
   * ```ts
   * const app = new Hono()
   *
   * app.get(
   *   '/page/*',
   *   jsxRenderer(({ children }) => {
   *     return (
   *       <html>
   *         <body>
   *           <header>Menu</header>
   *           <div>{children}</div>
   *         </body>
   *       </html>
   *     )
   *   })
   * )
   *
   * app.get('/page/about', (c) => {
   *   return c.render(<h1>About me!</h1>)
   * })
   * ```
   */
  export declare const jsxRenderer: (component?: ComponentWithChildren, options?: RendererOptions) => MiddlewareHandler;

• useRequestContext

  /**
   * useRequestContext for Hono.
   *
   * @template E - The environment type.
   * @template P - The parameter type.
   * @template I - The input type.
   * @returns {Context<E, P, I>} An instance of Context.
   *
   * @example
   * ```ts
   * const RequestUrlBadge: FC = () => {
   *   const c = useRequestContext()
   *   return <b>{c.req.url}</b>
   * }
   *
   * app.get('/page/info', (c) => {
   *   return c.render(
   *     <div>
   *       You are accessing: <RequestUrlBadge />
   *     </div>
   *   )
   * })
   * ```
   */
  export declare const useRequestContext: <E extends Env = any, P extends string = any, I extends Input = {}>() => Context<E, P, I>;

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

• Condition

  type Condition = (c: Context) => boolean;

• some

  /**
   * Create a composed middleware that runs the first middleware that returns true.
   *
   * @param middleware - An array of MiddlewareHandler or Condition functions.
   * Middleware is applied in the order it is passed, and if any middleware exits without returning
   * an exception first, subsequent middleware will not be executed.
   * You can also pass a condition function that returns a boolean value. If returns true
   * the evaluation will be halted, and rest of the middleware will not be executed.
   * @returns A composed middleware.
   *
   * @example
   * ```ts
   * import { some } from 'hono/combine'
   * import { bearerAuth } from 'hono/bearer-auth'
   * import { myRateLimit } from '@/rate-limit'
   *
   * // If client has a valid token, then skip rate limiting.
   * // Otherwise, apply rate limiting.
   * app.use('/api/*', some(
   *   bearerAuth({ token }),
   *   myRateLimit({ limit: 100 }),
   * ));
   * ```
   */
  export declare const some: (...middleware: (MiddlewareHandler | Condition)[]) => MiddlewareHandler;

• every

  /**
   * Create a composed middleware that runs all middleware and throws an error if any of them fail.
   *
   * @param middleware - An array of MiddlewareHandler or Condition functions.
   * Middleware is applied in the order it is passed, and if any middleware throws an error,
   * subsequent middleware will not be executed.
   * You can also pass a condition function that returns a boolean value. If returns false
   * the evaluation will be halted, and rest of the middleware will not be executed.
   * @returns A composed middleware.
   *
   * @example
   * ```ts
   * import { some, every } from 'hono/combine'
   * import { bearerAuth } from 'hono/bearer-auth'
   * import { myCheckLocalNetwork } from '@/check-local-network'
   * import { myRateLimit } from '@/rate-limit'
   *
   * // If client is in local network, then skip authentication and rate limiting.
   * // Otherwise, apply authentication and rate limiting.
   * app.use('/api/*', some(
   *   myCheckLocalNetwork(),
   *   every(
   *     bearerAuth({ token }),
   *     myRateLimit({ limit: 100 }),
   *   ),
   * ));
   * ```
   */
  export declare const every: (...middleware: (MiddlewareHandler | Condition)[]) => MiddlewareHandler;

• except

  /**
   * Create a composed middleware that runs all middleware except when the condition is met.
   *
   * @param condition - A string or Condition function.
   * If there are multiple targets to match any of them, they can be passed as an array.
   * If a string is passed, it will be treated as a path pattern to match.
   * If a Condition function is passed, it will be evaluated against the request context.
   * @param middleware - A composed middleware
   *
   * @example
   * ```ts
   * import { except } from 'hono/combine'
   * import { bearerAuth } from 'hono/bearer-auth
   *
   * // If client is accessing public API, then skip authentication.
   * // Otherwise, require a valid token.
   * app.use('/api/*', except(
   *   '/api/public/*',
   *   bearerAuth({ token }),
   * ));
   * ```
   */
  export declare const except: (condition: string | Condition | (string | Condition)[], ...middleware: MiddlewareHandler[]) => MiddlewareHandler;

/**
 * @module
 * Combine Middleware for Hono.
 */
import type { Context } from '../../context';
import type { MiddlewareHandler } from '../../types';
type Condition = (c: Context) => boolean;
/**
 * Create a composed middleware that runs the first middleware that returns true.
 *
 * @param middleware - An array of MiddlewareHandler or Condition functions.
 * Middleware is applied in the order it is passed, and if any middleware exits without returning
 * an exception first, subsequent middleware will not be executed.
 * You can also pass a condition function that returns a boolean value. If returns true
 * the evaluation will be halted, and rest of the middleware will not be executed.
 * @returns A composed middleware.
 *
 * @example
 * ```ts
 * import { some } from 'hono/combine'
 * import { bearerAuth } from 'hono/bearer-auth'
 * import { myRateLimit } from '@/rate-limit'
 *
 * // If client has a valid token, then skip rate limiting.
 * // Otherwise, apply rate limiting.
 * app.use('/api/*', some(
 *   bearerAuth({ token }),
 *   myRateLimit({ limit: 100 }),
 * ));
 * ```
 */
export declare const some: (...middleware: (MiddlewareHandler | Condition)[]) => MiddlewareHandler;
/**
 * Create a composed middleware that runs all middleware and throws an error if any of them fail.
 *
 * @param middleware - An array of MiddlewareHandler or Condition functions.
 * Middleware is applied in the order it is passed, and if any middleware throws an error,
 * subsequent middleware will not be executed.
 * You can also pass a condition function that returns a boolean value. If returns false
 * the evaluation will be halted, and rest of the middleware will not be executed.
 * @returns A composed middleware.
 *
 * @example
 * ```ts
 * import { some, every } from 'hono/combine'
 * import { bearerAuth } from 'hono/bearer-auth'
 * import { myCheckLocalNetwork } from '@/check-local-network'
 * import { myRateLimit } from '@/rate-limit'
 *
 * // If client is in local network, then skip authentication and rate limiting.
 * // Otherwise, apply authentication and rate limiting.
 * app.use('/api/*', some(
 *   myCheckLocalNetwork(),
 *   every(
 *     bearerAuth({ token }),
 *     myRateLimit({ limit: 100 }),
 *   ),
 * ));
 * ```
 */
export declare const every: (...middleware: (MiddlewareHandler | Condition)[]) => MiddlewareHandler;
/**
 * Create a composed middleware that runs all middleware except when the condition is met.
 *
 * @param condition - A string or Condition function.
 * If there are multiple targets to match any of them, they can be passed as an array.
 * If a string is passed, it will be treated as a path pattern to match.
 * If a Condition function is passed, it will be evaluated against the request context.
 * @param middleware - A composed middleware
 *
 * @example
 * ```ts
 * import { except } from 'hono/combine'
 * import { bearerAuth } from 'hono/bearer-auth
 *
 * // If client is accessing public API, then skip authentication.
 * // Otherwise, require a valid token.
 * app.use('/api/*', except(
 *   '/api/public/*',
 *   bearerAuth({ token }),
 * ));
 * ```
 */
export declare const except: (condition: string | Condition | (string | Condition)[], ...middleware: MiddlewareHandler[]) => MiddlewareHandler;
export {};

• Runtime

  export type Runtime = "node" | "deno" | "bun" | "workerd" | "fastly" | "edge-light" | "other";

• env

  export declare const env: <T extends Record<string, unknown>, C extends Context = Context<{}, any, {}>>(c: C, runtime?: Runtime) => T & C["env"];

• getRuntimeKey

  export declare const getRuntimeKey: () => Runtime;

• checkUserAgentEquals

  export declare const checkUserAgentEquals: (platform: string) => boolean;

/**
 * @module
 * Adapter Helper for Hono.
 */
import type { Context } from '../../context';
export type Runtime = "node" | "deno" | "bun" | "workerd" | "fastly" | "edge-light" | "other";
export declare const env: <T extends Record<string, unknown>, C extends Context = Context<{}, any, {}>>(c: C, runtime?: Runtime) => T & C["env"];
export declare const knownUserAgents: Partial<Record<Runtime, string>>;
export declare const getRuntimeKey: () => Runtime;
export declare const checkUserAgentEquals: (platform: string) => boolean;

• renderToReadableStream

  /**
   * @experimental
   * `renderToReadableStream()` is an experimental feature.
   * The API might be changed.
   */
  export declare const renderToReadableStream: (content: HtmlEscapedString | JSXNode | Promise<HtmlEscapedString>, onError?: (e: unknown) => string | void) => ReadableStream<Uint8Array>;

/**
 * @module
 * This module enables JSX to supports streaming Response.
 */
import type { HtmlEscapedString } from '../utils/html';
import { JSXNode } from './base';
import type { FC, PropsWithChildren } from './';
/**
 * @experimental
 * `Suspense` is an experimental feature.
 * The API might be changed.
 */
export declare const Suspense: FC<PropsWithChildren<{
    fallback: any;
}>>;
/**
 * @experimental
 * `renderToReadableStream()` is an experimental feature.
 * The API might be changed.
 */
export declare const renderToReadableStream: (content: HtmlEscapedString | JSXNode | Promise<HtmlEscapedString>, onError?: (e: unknown) => string | void) => ReadableStream<Uint8Array>;

• InitApp

  type InitApp<E extends Env = Env> = (app: Hono<E>) => void;

• CreateHandlersInterface

  export interface CreateHandlersInterface<E extends Env, P extends string> {
      <I extends Input = {}, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler1: H<E2, P, I, R>): [
          H<E2, P, I, R>
      ];
      <I extends Input = {}, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
          E,
          E2
      ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>): [
          H<E2, P, I, R>,
          H<E3, P, I2, R>
      ];
      <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3
      ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>): [
          H<E2, P, I, R>,
          H<E3, P, I2, R>,
          H<E4, P, I3, R>
      ];
      <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4
      ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>): [
          H<E2, P, I, R>,
          H<E3, P, I2, R>,
          H<E4, P, I3, R>,
          H<E5, P, I4, R>
      ];
      <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5
      ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>): [
          H<E2, P, I, R>,
          H<E3, P, I2, R>,
          H<E4, P, I3, R>,
          H<E5, P, I4, R>,
          H<E6, P, I5, R>
      ];
      <I extends Input = {}, 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, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6
      ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>): [
          H<E2, P, I, R>,
          H<E3, P, I2, R>,
          H<E4, P, I3, R>,
          H<E5, P, I4, R>,
          H<E6, P, I5, R>,
          H<E7, P, I6, R>
      ];
      <I extends Input = {}, 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, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7
      ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>): [
          H<E2, P, I, R>,
          H<E3, P, I2, R>,
          H<E4, P, I3, R>,
          H<E5, P, I4, R>,
          H<E6, P, I5, R>,
          H<E7, P, I6, R>,
          H<E8, P, I7, R>
      ];
      <I extends Input = {}, 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, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8
      ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>): [
          H<E2, P, I, R>,
          H<E3, P, I2, R>,
          H<E4, P, I3, R>,
          H<E5, P, I4, R>,
          H<E6, P, I5, R>,
          H<E7, P, I6, R>,
          H<E8, P, I7, R>,
          H<E9, P, I8, R>
      ];
      <I extends Input = {}, 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, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9
      ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>, handler9: H<E10, P, I9, R>): [
          H<E2, P, I, R>,
          H<E3, P, I2, R>,
          H<E4, P, I3, R>,
          H<E5, P, I4, R>,
          H<E6, P, I5, R>,
          H<E7, P, I6, R>,
          H<E8, P, I7, R>,
          H<E9, P, I8, R>,
          H<E10, P, I9, R>
      ];
      <I extends Input = {}, 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, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
          E,
          E2,
          E3,
          E4,
          E5,
          E6,
          E7,
          E8,
          E9,
          E10
      ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>, handler9: H<E10, P, I9, R>, handler10: H<E11, P, I10, R>): [
          H<E2, P, I, R>,
          H<E3, P, I2, R>,
          H<E4, P, I3, R>,
          H<E5, P, I4, R>,
          H<E6, P, I5, R>,
          H<E7, P, I6, R>,
          H<E8, P, I7, R>,
          H<E9, P, I8, R>,
          H<E10, P, I9, R>,
          H<E11, P, I10, R>
      ];
  }

• createFactory

  export declare const createFactory: <E extends Env = any, P extends string = any>(init?: {
      initApp?: InitApp<E>;
  }) => Factory<E, P>;

• createMiddleware

  export declare const createMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;

/**
 * @module
 * Factory Helper for Hono.
 */
import { Hono } from '../../hono';
import type { Env, H, HandlerResponse, Input, IntersectNonAnyTypes, MiddlewareHandler } from '../../types';
type InitApp<E extends Env = Env> = (app: Hono<E>) => void;
export interface CreateHandlersInterface<E extends Env, P extends string> {
    <I extends Input = {}, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler1: H<E2, P, I, R>): [
        H<E2, P, I, R>
    ];
    <I extends Input = {}, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
        E,
        E2
    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>): [
        H<E2, P, I, R>,
        H<E3, P, I2, R>
    ];
    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
        E,
        E2,
        E3
    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>): [
        H<E2, P, I, R>,
        H<E3, P, I2, R>,
        H<E4, P, I3, R>
    ];
    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
        E,
        E2,
        E3,
        E4
    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>): [
        H<E2, P, I, R>,
        H<E3, P, I2, R>,
        H<E4, P, I3, R>,
        H<E5, P, I4, R>
    ];
    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
        E,
        E2,
        E3,
        E4,
        E5
    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>): [
        H<E2, P, I, R>,
        H<E3, P, I2, R>,
        H<E4, P, I3, R>,
        H<E5, P, I4, R>,
        H<E6, P, I5, R>
    ];
    <I extends Input = {}, 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, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
        E,
        E2,
        E3,
        E4,
        E5,
        E6
    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>): [
        H<E2, P, I, R>,
        H<E3, P, I2, R>,
        H<E4, P, I3, R>,
        H<E5, P, I4, R>,
        H<E6, P, I5, R>,
        H<E7, P, I6, R>
    ];
    <I extends Input = {}, 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, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
        E,
        E2,
        E3,
        E4,
        E5,
        E6,
        E7
    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>): [
        H<E2, P, I, R>,
        H<E3, P, I2, R>,
        H<E4, P, I3, R>,
        H<E5, P, I4, R>,
        H<E6, P, I5, R>,
        H<E7, P, I6, R>,
        H<E8, P, I7, R>
    ];
    <I extends Input = {}, 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, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
        E,
        E2,
        E3,
        E4,
        E5,
        E6,
        E7,
        E8
    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>): [
        H<E2, P, I, R>,
        H<E3, P, I2, R>,
        H<E4, P, I3, R>,
        H<E5, P, I4, R>,
        H<E6, P, I5, R>,
        H<E7, P, I6, R>,
        H<E8, P, I7, R>,
        H<E9, P, I8, R>
    ];
    <I extends Input = {}, 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, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
        E,
        E2,
        E3,
        E4,
        E5,
        E6,
        E7,
        E8,
        E9
    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>, handler9: H<E10, P, I9, R>): [
        H<E2, P, I, R>,
        H<E3, P, I2, R>,
        H<E4, P, I3, R>,
        H<E5, P, I4, R>,
        H<E6, P, I5, R>,
        H<E7, P, I6, R>,
        H<E8, P, I7, R>,
        H<E9, P, I8, R>,
        H<E10, P, I9, R>
    ];
    <I extends Input = {}, 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, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
        E,
        E2,
        E3,
        E4,
        E5,
        E6,
        E7,
        E8,
        E9,
        E10
    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>, handler9: H<E10, P, I9, R>, handler10: H<E11, P, I10, R>): [
        H<E2, P, I, R>,
        H<E3, P, I2, R>,
        H<E4, P, I3, R>,
        H<E5, P, I4, R>,
        H<E6, P, I5, R>,
        H<E7, P, I6, R>,
        H<E8, P, I7, R>,
        H<E9, P, I8, R>,
        H<E10, P, I9, R>,
        H<E11, P, I10, R>
    ];
}
export declare class Factory<E extends Env = any, P extends string = any> {
    constructor(init?: {
        initApp?: InitApp<E>;
    });
    createApp: () => Hono<E>;
    createMiddleware: <I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;
    createHandlers: CreateHandlersInterface<E, P>;
}
export declare const createFactory: <E extends Env = any, P extends string = any>(init?: {
    initApp?: InitApp<E>;
}) => Factory<E, P>;
export declare const createMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;
export {};

• cache

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

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

• MethodOverrideOptions

  type MethodOverrideOptions = {
      app: Hono<any, any, any>;
  } & ({
      form?: string;
      header?: never;
      query?: never;
  } | {
      form?: never;
      header: string;
      query?: never;
  } | {
      form?: never;
      header?: never;
      query: string;
  });

• methodOverride

  /**
   * Method Override Middleware for Hono.
   *
   * @see {@link https://hono.dev/docs/middleware/builtin/method-override}
   *
   * @param {MethodOverrideOptions} options - The options for the method override middleware.
   * @param {Hono} options.app - The instance of Hono is used in your application.
   * @param {string} [options.form=_method] - Form key with a value containing the method name.
   * @param {string} [options.header] - Header name with a value containing the method name.
   * @param {string} [options.query] - Query parameter key with a value containing the method name.
   * @returns {MiddlewareHandler} The middleware handler function.
   *
   * @example
   * ```ts
   * const app = new Hono()
   *
   * // If no options are specified, the value of `_method` in the form,
   * // e.g. DELETE, is used as the method.
   * app.use('/posts', methodOverride({ app }))
   *
   * app.delete('/posts', (c) => {
   *   // ....
   * })
   * ```
   */
  export declare const methodOverride: (options: MethodOverrideOptions) => MiddlewareHandler;

/**
 * @module
 * Method Override Middleware for Hono.
 */
import type { Hono } from '../../hono';
import type { MiddlewareHandler } from '../../types';
type MethodOverrideOptions = {
    app: Hono<any, any, any>;
} & ({
    form?: string;
    header?: never;
    query?: never;
} | {
    form?: never;
    header: string;
    query?: never;
} | {
    form?: never;
    header?: never;
    query: string;
});
/**
 * Method Override Middleware for Hono.
 *
 * @see {@link https://hono.dev/docs/middleware/builtin/method-override}
 *
 * @param {MethodOverrideOptions} options - The options for the method override middleware.
 * @param {Hono} options.app - The instance of Hono is used in your application.
 * @param {string} [options.form=_method] - Form key with a value containing the method name.
 * @param {string} [options.header] - Header name with a value containing the method name.
 * @param {string} [options.query] - Query parameter key with a value containing the method name.
 * @returns {MiddlewareHandler} The middleware handler function.
 *
 * @example
 * ```ts
 * const app = new Hono()
 *
 * // If no options are specified, the value of `_method` in the form,
 * // e.g. DELETE, is used as the method.
 * app.use('/posts', methodOverride({ app }))
 *
 * app.delete('/posts', (c) => {
 *   // ....
 * })
 * ```
 */
export declare const methodOverride: (options: MethodOverrideOptions) => MiddlewareHandler;
export {};

• Bindings

  export type Bindings = object;

• Variables

  export type Variables = object;

• BlankEnv

  export type BlankEnv = {};

• Env

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

• Next

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

• ExtractInput

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

• Input

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

• BlankSchema

  export type BlankSchema = {};

• BlankInput

  export type BlankInput = {};

• HandlerResponse

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

• Handler

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

• MiddlewareHandler

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

• H

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

• NotFoundHandler

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

• ErrorHandler

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

• ExtractStringKey

  type ExtractStringKey<S> = keyof S & string;

• ToSchema

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

• Schema

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

• ChangePathOfSchema

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

• Endpoint

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

• ExtractParams

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

• FlattenIfIntersect

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

• MergeSchemaPath

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

• MergeEndpointParamsWithPath

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

• AddParam

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

• AddDollar

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

• MergePath

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

• KnownResponseFormat

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

• ResponseFormat

  export type ResponseFormat = KnownResponseFormat | string;

• TypedResponse

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

• MergeTypedResponse

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

• FormValue

  export type FormValue = string | Blob;

• ParsedFormValue

  export type ParsedFormValue = string | File;

• ValidationTargets

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

• ParamKeyName

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

• ParamKey

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

• ParamKeys

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

• ParamKeyToRecord

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

• InputToDataByTarget

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

• RemoveQuestion

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

• ExtractSchema

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

• EnvOrEmpty

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

• IntersectNonAnyTypes

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