@rho-workspace/rho 0.5.2 → 0.5.3

package/node_modules/hono/dist/types/middleware/etag/index.d.ts

@@ -1,40 +0,0 @@
-import { MiddlewareHandler } from "../../types.js";
-//#region src/middleware/etag/index.d.ts
-type ETagOptions = {
-  retainedHeaders?: string[];
-  weak?: boolean;
-  generateDigest?: (body: Uint8Array<ArrayBuffer>) => ArrayBuffer | Promise<ArrayBuffer>;
-};
-/**
- * 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.
- * @param {function(Uint8Array): ArrayBuffer | Promise<ArrayBuffer>} [options.generateDigest] -
- * A custom digest generation function. By default, it uses 'SHA-1'
- * This function is called with the response body as a `Uint8Array` and should return a hash as an `ArrayBuffer` or a Promise of one.
- * @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 hot')
- * })
- * ```
- */
-export declare const etag: (options?: ETagOptions) => MiddlewareHandler;
-//#endregion
-export {};

package/node_modules/hono/dist/types/middleware/ip-restriction/index.d.ts

@@ -1,66 +0,0 @@
-import { MiddlewareHandler } from "../../index.js";
-import { Context } from "../../index.js";
-import { AddressType, GetConnInfo } from "../../helper/conninfo/index.js";
-//#region src/middleware/ip-restriction/index.d.ts
-/**
- * Function to get IP Address
- */
-type GetIPAddr = GetConnInfo | ((c: Context) => string);
-export type IPRestrictionRule = string | ((addr: {
-  addr: string;
-  type: AddressType;
-}) => boolean);
-/**
- * Rules for IP Restriction Middleware
- */
-export interface IPRestrictionRules {
-  denyList?: IPRestrictionRule[];
-  allowList?: IPRestrictionRule[];
-}
-/**
- * IP Restriction Middleware for Hono.
- *
- * @see {@link https://hono.dev/docs/middleware/builtin/ip-restriction}
- *
- * @param {GetConnInfo | ((c: Context) => string)} getIP - A function to retrieve the client IP address. Use `getConnInfo` from the appropriate runtime adapter.
- * @param {IPRestrictionRules} rules - An object with optional `denyList` and `allowList` arrays of IP rules. Each rule can be a static IP, a CIDR range, or a custom function.
- * @param {(remote: { addr: string; type: AddressType }, c: Context) => Response | Promise<Response>} [onError] - Optional custom handler invoked when a request is blocked. Defaults to returning a 403 Forbidden response.
- * @returns {MiddlewareHandler} The middleware handler function.
- *
- * @example
- * ```ts
- * import { Hono } from 'hono'
- * import { ipRestriction } from 'hono/ip-restriction'
- * import { getConnInfo } from 'hono/cloudflare-workers'
- *
- * const app = new Hono()
- *
- * app.use(
- *   '*',
- *   ipRestriction(getConnInfo, {
- *     // Block a specific IP and an entire subnet
- *     denyList: ['192.168.0.5', '10.0.0.0/8'],
- *     // Only allow requests from localhost and a private range
- *     allowList: ['127.0.0.1', '::1', '192.168.1.0/24'],
- *   })
- * )
- *
- * // With a custom error handler
- * app.use(
- *   '/admin/*',
- *   ipRestriction(
- *     getConnInfo,
- *     { allowList: ['203.0.113.0/24'] },
- *     (remote, c) => c.text(`Access denied for ${remote.addr}`, 403)
- *   )
- * )
- *
- * app.get('/', (c) => c.text('Hello!'))
- * ```
- */
-export declare const ipRestriction: (getIP: GetIPAddr, { denyList, allowList }: IPRestrictionRules, onError?: (remote: {
-  addr: string;
-  type: AddressType;
-}, c: Context) => Response | Promise<Response>) => MiddlewareHandler;
-//#endregion
-export {};

package/node_modules/hono/dist/types/middleware/jsx-renderer/index.d.ts

@@ -1,77 +0,0 @@
-import { Env, Input, MiddlewareHandler } from "../../types.js";
-import { Context, PropsForRenderer } from "../../context.js";
-import { PropsWithChildren } from "../../jsx/index.js";
-import { Context as Context$1 } from "../../jsx/index.js";
-import { FC } from "../../jsx/index.js";
-//#region src/middleware/jsx-renderer/index.d.ts
-export declare const RequestContext: Context$1<Context<any, any, {}> | null>;
-type RendererOptions = {
-  docType?: boolean | string;
-  stream?: boolean | Record<string, string>;
-};
-type ComponentResult = Exclude<ReturnType<FC>, null>;
-type ComponentWithChildren = (props: PropsWithChildren<PropsForRenderer & {
-  Layout: FC;
-}>, c: Context) => ComponentResult;
-/**
- * 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: <E extends Env = Env>(component?: ComponentWithChildren, options?: RendererOptions | ((c: Context<E>) => 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>;
-//#endregion
-export {};

package/node_modules/hono/dist/types/middleware/jwk/index.d.ts

@@ -1,2 +0,0 @@
-import { jwk } from "./jwk.js";
-export { jwk };

package/node_modules/hono/dist/types/middleware/jwk/jwk.d.ts

@@ -1,53 +0,0 @@
-import { MiddlewareHandler } from "../../types.js";
-import { Context } from "../../context.js";
-import { CookiePrefixOptions } from "../../utils/cookie.js";
-import { AsymmetricAlgorithm } from "../../utils/jwt/jwa.js";
-import { HonoJsonWebKey } from "../../utils/jwt/jws.js";
-import { VerifyOptions } from "../../utils/jwt/jwt.js";
-//#region src/middleware/jwk/jwk.d.ts
-/**
- * JWK Auth Middleware for Hono.
- *
- * @see {@link https://hono.dev/docs/middleware/builtin/jwk}
- *
- * @param {object} options - The options for the JWK middleware.
- * @param {HonoJsonWebKey[] | ((ctx: Context) => Promise<HonoJsonWebKey[]> | HonoJsonWebKey[])} [options.keys] - The public keys used for JWK verification, or a function that returns them.
- * @param {string | ((ctx: Context) => Promise<string> | string)} [options.jwks_uri] - If set to a URI string or a function that returns a URI string, attempt to fetch JWKs from it. The response must be a JSON object containing a `keys` array, which will be merged with the `keys` option.
- * @param {boolean} [options.allow_anon] - If set to `true`, the middleware allows requests without a token to proceed without authentication.
- * @param {string} [options.cookie] - If set, the middleware attempts to retrieve the token from a cookie with these options (optionally signed) only if no token is found in the header.
- * @param {string} [options.headerName='Authorization'] - The name of the header to look for the JWT token. Default is 'Authorization'.
- * @param {string} [options.realm] - The protection space described by the `realm` parameter of the returned `WWW-Authenticate` challenge header. Defaults to the request URL.
- * @param {AsymmetricAlgorithm[]} options.alg - An array of allowed asymmetric algorithms for JWT verification. Only tokens signed with these algorithms will be accepted.
- * @param {RequestInit} [init] - Optional init options for the `fetch` request when retrieving JWKS from a URI.
- * @param {VerifyOptions} [options.verification] - Additional options for JWK payload verification.
- * @returns {MiddlewareHandler} The middleware handler function.
- *
- * @example
- * ```ts
- * const app = new Hono()
- *
- * app.use("/auth/*", jwk({
- *   jwks_uri: (c) => `https://${c.env.authServer}/.well-known/jwks.json`,
- *   headerName: 'x-custom-auth-header', // Optional, default is 'Authorization'
- * }))
- *
- * app.get('/auth/page', (c) => {
- *   return c.text('You are authorized')
- * })
- * ```
- */
-export declare const jwk: (options: {
-  keys?: HonoJsonWebKey[] | ((ctx: Context) => Promise<HonoJsonWebKey[]> | HonoJsonWebKey[]);
-  jwks_uri?: string | ((ctx: Context) => Promise<string> | string);
-  allow_anon?: boolean;
-  cookie?: string | {
-    key: string;
-    secret?: string | BufferSource;
-    prefixOptions?: CookiePrefixOptions;
-  };
-  headerName?: string;
-  alg: AsymmetricAlgorithm[];
-  realm?: string;
-  verification?: VerifyOptions;
-}, init?: RequestInit) => MiddlewareHandler;
-//#endregion

package/node_modules/hono/dist/types/middleware/jwt/index.d.ts

@@ -1,9 +0,0 @@
-import { AlgorithmTypes } from "../../utils/jwt/jwa.js";
-import { JwtVariables, decode, jwt, sign, verify, verifyWithJwks } from "./jwt.js";
-//#region src/middleware/jwt/index.d.ts
-declare module '../..' {
-  interface ContextVariableMap extends JwtVariables<unknown> {}
-}
-//#endregion
-export { AlgorithmTypes, type JwtVariables, decode, jwt, sign, verify, verifyWithJwks };
-export {};

package/node_modules/hono/dist/types/middleware/jwt/jwt.d.ts

@@ -1,67 +0,0 @@
-import { MiddlewareHandler } from "../../types.js";
-import { CookiePrefixOptions } from "../../utils/cookie.js";
-import { AsymmetricAlgorithm, SignatureAlgorithm } from "../../utils/jwt/jwa.js";
-import { HonoJsonWebKey, SignatureKey } from "../../utils/jwt/jws.js";
-import { JWTPayload } from "../../utils/jwt/types.js";
-import { TokenHeader, VerifyOptions, VerifyOptionsWithAlg } from "../../utils/jwt/jwt.js";
-//#region src/middleware/jwt/jwt.d.ts
-export type JwtVariables<T = any> = {
-  jwtPayload: T;
-};
-/**
- * JWT Auth Middleware for Hono.
- *
- * @see {@link https://hono.dev/docs/middleware/builtin/jwt}
- *
- * @param {object} options - The options for the JWT middleware.
- * @param {SignatureKey} options.secret - A value of your secret key.
- * @param {string} [options.cookie] - If this value is set, then the value is retrieved from the cookie header using that value as a key, which is then validated as a token.
- * @param {SignatureAlgorithm} options.alg - An algorithm type that is used for verifying (required). Available types are `HS256` | `HS384` | `HS512` | `RS256` | `RS384` | `RS512` | `PS256` | `PS384` | `PS512` | `ES256` | `ES384` | `ES512` | `EdDSA`.
- * @param {string} [options.headerName='Authorization'] - The name of the header to look for the JWT token. Default is 'Authorization'.
- * @param {string} [options.realm] - The protection space described by the `realm` parameter of the returned `WWW-Authenticate` challenge header. Defaults to the request URL.
- * @param {VerifyOptions} [options.verification] - Additional options for JWT payload verification.
- * @returns {MiddlewareHandler} The middleware handler function.
- *
- * @example
- * ```ts
- * const app = new Hono()
- *
- * app.use(
- *   '/auth/*',
- *   jwt({
- *     secret: 'it-is-very-secret',
- *     alg: 'HS256',
- *     headerName: 'x-custom-auth-header', // Optional, default is 'Authorization'
- *   })
- * )
- *
- * app.get('/auth/page', (c) => {
- *   return c.text('You are authorized')
- * })
- * ```
- */
-export declare const jwt: (options: {
-  secret: SignatureKey;
-  cookie?: string | {
-    key: string;
-    secret?: string | BufferSource;
-    prefixOptions?: CookiePrefixOptions;
-  };
-  alg: SignatureAlgorithm;
-  headerName?: string;
-  realm?: string;
-  verification?: VerifyOptions;
-}) => MiddlewareHandler;
-export declare const verifyWithJwks: (token: string, options: {
-  keys?: HonoJsonWebKey[];
-  jwks_uri?: string;
-  verification?: VerifyOptions;
-  allowedAlgorithms: readonly AsymmetricAlgorithm[];
-}, init?: RequestInit) => Promise<JWTPayload>;
-export declare const verify: (token: string, publicKey: SignatureKey, algOrOptions: SignatureAlgorithm | VerifyOptionsWithAlg) => Promise<JWTPayload>;
-export declare const decode: (token: string) => {
-  header: TokenHeader;
-  payload: JWTPayload;
-};
-export declare const sign: (payload: JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;
-//#endregion

package/node_modules/hono/dist/types/middleware/language/index.d.ts

@@ -1,8 +0,0 @@
-import { CacheType, DetectorOptions, DetectorType, LanguageVariables, detectFromCookie, detectFromHeader, detectFromPath, detectFromQuery, languageDetector } from "./language.js";
-//#region src/middleware/language/index.d.ts
-declare module '../..' {
-  interface ContextVariableMap extends LanguageVariables {}
-}
-//#endregion
-export { type CacheType, type DetectorOptions, type DetectorType, type LanguageVariables, detectFromCookie, detectFromHeader, detectFromPath, detectFromQuery, languageDetector };
-export {};

package/node_modules/hono/dist/types/middleware/language/language.d.ts

@@ -1,118 +0,0 @@
-import { MiddlewareHandler } from "../../types.js";
-import { Context } from "../../context.js";
-//#region src/middleware/language/language.d.ts
-export type DetectorType = 'path' | 'querystring' | 'cookie' | 'header';
-export type CacheType = 'cookie';
-export interface DetectorOptions {
-  /** Order of language detection strategies */
-  order: DetectorType[];
-  /** Query parameter name for language */
-  lookupQueryString: string;
-  /** Cookie name for language */
-  lookupCookie: string;
-  /** Index in URL path where language code appears */
-  lookupFromPathIndex: number;
-  /** Header key for language detection */
-  lookupFromHeaderKey: string;
-  /** Caching strategies */
-  caches: CacheType[] | false;
-  /** Cookie configuration options */
-  cookieOptions?: {
-    domain?: string;
-    path?: string;
-    sameSite?: 'Strict' | 'Lax' | 'None';
-    secure?: boolean;
-    maxAge?: number;
-    httpOnly?: boolean;
-  };
-  /** Whether to ignore case in language codes */
-  ignoreCase: boolean;
-  /** Default language if none detected */
-  fallbackLanguage: string;
-  /** List of supported language codes */
-  supportedLanguages: string[];
-  /** Optional function to transform detected language codes */
-  convertDetectedLanguage?: (lang: string) => string;
-  /** Enable debug logging */
-  debug?: boolean;
-}
-export interface LanguageVariables {
-  language: string;
-}
-export declare const DEFAULT_OPTIONS: DetectorOptions;
-/**
- * Parse Accept-Language header values with quality scores
- * @param header Accept-Language header string
- * @returns Array of parsed languages with quality scores
- */
-export declare function parseAcceptLanguage(header: string): Array<{
-  lang: string;
-  q: number;
-}>;
-/**
- * Validate and normalize language codes
- * @param lang Language code to normalize
- * @param options Detector options
- * @returns Normalized language code or undefined
- */
-export declare const normalizeLanguage: (lang: string | null | undefined, options: DetectorOptions) => string | undefined;
-/**
- * Detects language from query parameter
- */
-export declare const detectFromQuery: (c: Context, options: DetectorOptions) => string | undefined;
-/**
- * Detects language from cookie
- */
-export declare const detectFromCookie: (c: Context, options: DetectorOptions) => string | undefined;
-/**
- * Detects language from Accept-Language header
- */
-export declare function detectFromHeader(c: Context, options: DetectorOptions): string | undefined;
-/**
- * Detects language from URL path
- */
-export declare function detectFromPath(c: Context, options: DetectorOptions): string | undefined;
-/**
- * Collection of all language detection strategies
- */
-export declare const detectors: {
-  readonly querystring: (c: Context, options: DetectorOptions) => string | undefined;
-  readonly cookie: (c: Context, options: DetectorOptions) => string | undefined;
-  readonly header: typeof detectFromHeader;
-  readonly path: typeof detectFromPath;
-};
-/** Type for detector functions */
-export type DetectorFunction = (c: Context, options: DetectorOptions) => string | undefined;
-/** Type-safe detector map */
-export type Detectors = Record<keyof typeof detectors, DetectorFunction>;
-/**
- * Validate detector options
- * @param options Detector options to validate
- * @throws Error if options are invalid
- */
-export declare function validateOptions(options: DetectorOptions): void;
-/**
- * Language detector middleware factory
- * @param userOptions Configuration options for the language detector
- * @returns Hono middleware function
- *
- * @example
- * ```ts
- * type Variables = LanguageVariables
- * const app = new Hono<{ Variables: Variables }>()
- *
- * app.use(
- *   languageDetector({
- *     supportedLanguages: ['en', 'ja'], // Must include fallback
- *     fallbackLanguage: 'en', // Required
- *   })
- * )
- *
- * app.get('/', (c) => {
- *   const lang = c.get('language')
- *   return c.text(`Current language: ${lang}`)
- * })
- * ```
- */
-export declare const languageDetector: (userOptions: Partial<DetectorOptions>) => MiddlewareHandler;
-//#endregion

package/node_modules/hono/dist/types/middleware/logger/index.d.ts

@@ -1,22 +0,0 @@
-import { MiddlewareHandler } from "../../types.js";
-//#region src/middleware/logger/index.d.ts
-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;
-//#endregion
-export {};

package/node_modules/hono/dist/types/middleware/method-not-allowed/index.d.ts

@@ -1,47 +0,0 @@
-import { Env, MiddlewareHandler } from "../../types.js";
-import { Context } from "../../context.js";
-import { Hono } from "../../hono.js";
-//#region src/middleware/method-not-allowed/index.d.ts
-type MethodNotAllowedHandler<E extends Env> = (c: Context<E>, allowedMethods: string[]) => Response | Promise<Response>;
-type MethodNotAllowedOptions<E extends Env> = {
-  app: Hono<E, any, any>;
-  onMethodNotAllowed?: MethodNotAllowedHandler<E>;
-};
-/**
- * Method Not Allowed Middleware for Hono.
- *
- * Returns a `405 Method Not Allowed` response with an `Allow` header when the request path
- * matches a registered route but the request method is not supported.
- *
- * @param {MethodNotAllowedOptions} options - The options for the middleware.
- * @param {Hono} options.app - The Hono instance used by the application.
- * @param {MethodNotAllowedHandler} [options.onMethodNotAllowed] - Generates the response, including its `Allow` header.
- * @returns {MiddlewareHandler} The middleware handler function.
- *
- * @example
- * ```ts
- * const app = new Hono()
- *
- * app.use(methodNotAllowed({ app }))
- *
- * app.get('/hello', (c) => c.text('Hello!'))
- * app.post('/hello', (c) => c.text('Posted!'))
- *
- * // PUT /hello -> 405 Method Not Allowed
- * // Allow: GET, HEAD, POST
- * ```
- *
- * @example
- * ```ts
- * app.use(
- *   methodNotAllowed({
- *     app,
- *     onMethodNotAllowed: (c, methods) =>
- *       c.json({ error: 'Method Not Allowed' }, 405, { Allow: methods.join(', ') }),
- *   })
- * )
- * ```
- */
-export declare const methodNotAllowed: <E extends Env = Env>(options: MethodNotAllowedOptions<E>) => MiddlewareHandler<E>;
-//#endregion
-export {};

package/node_modules/hono/dist/types/middleware/method-override/index.d.ts

@@ -1,46 +0,0 @@
-import { MiddlewareHandler } from "../../types.js";
-import { Hono } from "../../hono.js";
-//#region src/middleware/method-override/index.d.ts
-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;
-//#endregion
-export {};

package/node_modules/hono/dist/types/middleware/mount/index.d.ts

@@ -1,47 +0,0 @@
-import { MiddlewareHandler } from "../../types.js";
-import { Context } from "../../context.js";
-//#region src/middleware/mount/index.d.ts
-type ApplicationHandler = (request: Request, ...args: any) => Response | Promise<Response>;
-type MountOptionHandler = (c: Context) => unknown;
-type MountReplaceRequest = (originalRequest: Request) => Request;
-type MountOptions = MountOptionHandler | {
-  optionHandler?: MountOptionHandler;
-  replaceRequest?: MountReplaceRequest | false;
-};
-/**
- * `mount()` allows you to mount applications built with other frameworks into your Hono application.
- *
- * @see {@link https://hono.dev/docs/api/hono#mount}
- *
- * @param {Function} applicationHandler - other Request Handler
- * @param {MountOptions} [options] - options of `mount()`
- * @returns {MiddlewareHandler} handler to register with `app.all()`
- * @throws {Error} If the route ends with a wildcard inside a segment (e.g. `/assets*`), or automatic request rewriting encounters duplicate path parameter names.
- *
- * @example
- * ```ts
- * import { Router as IttyRouter } from 'itty-router'
- * import { Hono } from 'hono'
- * import { mount } from 'hono/mount'
- * // 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.all('/itty-router/*', mount(ittyRouter.handle))
- * ```
- *
- * @example
- * ```ts
- * const app = new Hono()
- * // Send the request to another application without modification.
- * app.all('/app/*', mount(anotherApp, {
- *   replaceRequest: (req) => req,
- * }))
- * ```
- */
-export declare const mount: (applicationHandler: ApplicationHandler, options?: MountOptions) => MiddlewareHandler;
-//#endregion
-export type { ApplicationHandler, MountOptionHandler, MountOptions, MountReplaceRequest };
-export {};

package/node_modules/hono/dist/types/middleware/powered-by/index.d.ts

@@ -1,27 +0,0 @@
-import { MiddlewareHandler } from "../../types.js";
-//#region src/middleware/powered-by/index.d.ts
-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;
-//#endregion
-export {};