@nocobase/plugin-mcp-server 2.4.0-alpha.1 → 2.4.0-alpha.10

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

@@ -1,19 +1,18 @@
-/**
- * @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>;
+import { Env, Input, MiddlewareHandler } from "../../types.js";
+import { Context, PropsForRenderer } from "../../context.js";
+import { PropsWithChildren } from "../../jsx/types.js";
+import { Context as Context$1 } from "../../jsx/context.js";
+import { FC } from "../../jsx/base.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>;
+  docType?: boolean | string;
+  stream?: boolean | Record<string, string>;
 };
+type ComponentResult = Exclude<ReturnType<FC>, null>;
 type ComponentWithChildren = (props: PropsWithChildren<PropsForRenderer & {
-    Layout: FC;
-}>, c: Context) => HtmlEscapedString | Promise<HtmlEscapedString>;
+  Layout: FC;
+}>, c: Context) => ComponentResult;
 /**
  * JSX Renderer Middleware for hono.
  *
@@ -74,4 +73,5 @@ export declare const jsxRenderer: <E extends Env = Env>(component?: ComponentWit
  * ```
  */
 export declare const useRequestContext: <E extends Env = any, P extends string = any, I extends Input = {}>() => Context<E, P, I>;
+//#endregion
 export {};

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

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

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

@@ -1,14 +1,10 @@
-/**
- * @module
- * JWK Auth Middleware for Hono.
- */
-import type { Context } from '../../context';
-import type { MiddlewareHandler } from '../../types';
-import type { CookiePrefixOptions } from '../../utils/cookie';
-import '../../context';
-import type { AsymmetricAlgorithm } from '../../utils/jwt/jwa';
-import type { HonoJsonWebKey } from '../../utils/jwt/jws';
-import type { VerifyOptions } from '../../utils/jwt/jwt';
+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.
  *
@@ -20,6 +16,7 @@ import type { VerifyOptions } from '../../utils/jwt/jwt';
  * @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.
@@ -40,15 +37,17 @@ import type { VerifyOptions } from '../../utils/jwt/jwt';
  * ```
  */
 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[];
-    verification?: VerifyOptions;
+  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/dist/node_modules/hono/dist/types/middleware/jwt/index.d.ts

@@ -1,8 +1,9 @@
-import type { JwtVariables } from './jwt';
-export type { JwtVariables };
-export { jwt, verifyWithJwks, verify, decode, sign } from './jwt';
-export { AlgorithmTypes } from '../../utils/jwt/jwa';
+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> {
-    }
+  interface ContextVariableMap extends JwtVariables<unknown> {}
 }
+//#endregion
+export { AlgorithmTypes, type JwtVariables, decode, jwt, sign, verify, verifyWithJwks };
+export {};

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

@@ -1,15 +1,12 @@
-/**
- * @module
- * JWT Auth Middleware for Hono.
- */
-import type { MiddlewareHandler } from '../../types';
-import type { CookiePrefixOptions } from '../../utils/cookie';
-import '../../context';
-import type { SignatureAlgorithm } from '../../utils/jwt/jwa';
-import type { SignatureKey } from '../../utils/jwt/jws';
-import type { VerifyOptions } from '../../utils/jwt/jwt';
+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;
+  jwtPayload: T;
 };
 /**
  * JWT Auth Middleware for Hono.
@@ -21,6 +18,7 @@ export type JwtVariables<T = any> = {
  * @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.
  *
@@ -43,25 +41,27 @@ export type JwtVariables<T = any> = {
  * ```
  */
 export declare const jwt: (options: {
-    secret: SignatureKey;
-    cookie?: string | {
-        key: string;
-        secret?: string | BufferSource;
-        prefixOptions?: CookiePrefixOptions;
-    };
-    alg: SignatureAlgorithm;
-    headerName?: string;
-    verification?: VerifyOptions;
+  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?: import("../../utils/jwt/jws").HonoJsonWebKey[];
-    jwks_uri?: string;
-    verification?: VerifyOptions;
-    allowedAlgorithms: readonly import("../../utils/jwt/jwa").AsymmetricAlgorithm[];
-}, init?: RequestInit) => Promise<import("../../utils/jwt/types").JWTPayload>;
-export declare const verify: (token: string, publicKey: SignatureKey, algOrOptions: SignatureAlgorithm | import("../../utils/jwt/jwt").VerifyOptionsWithAlg) => Promise<import("../../utils/jwt/types").JWTPayload>;
+  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: import("../../utils/jwt/jwt").TokenHeader;
-    payload: import("../../utils/jwt/types").JWTPayload;
+  header: TokenHeader;
+  payload: JWTPayload;
 };
-export declare const sign: (payload: import("../../utils/jwt/types").JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;
+export declare const sign: (payload: JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;
+//#endregion

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

@@ -1,7 +1,8 @@
-import type { LanguageVariables, DetectorOptions, DetectorType, CacheType } from './language';
-export type { LanguageVariables, DetectorOptions, DetectorType, CacheType };
-export { languageDetector, detectFromCookie, detectFromHeader, detectFromPath, detectFromQuery, } from './language';
+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 {
-    }
+  interface ContextVariableMap extends LanguageVariables {}
 }
+//#endregion
+export { type CacheType, type DetectorOptions, type DetectorType, type LanguageVariables, detectFromCookie, detectFromHeader, detectFromPath, detectFromQuery, languageDetector };
+export {};

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

@@ -1,46 +1,43 @@
-/**
- * @module
- * Language module for Hono.
- */
-import type { Context } from '../../context';
-import type { MiddlewareHandler } from '../../types';
+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;
+  /** 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;
+  language: string;
 }
 export declare const DEFAULT_OPTIONS: DetectorOptions;
 /**
@@ -49,8 +46,8 @@ export declare const DEFAULT_OPTIONS: DetectorOptions;
  * @returns Array of parsed languages with quality scores
  */
 export declare function parseAcceptLanguage(header: string): Array<{
-    lang: string;
-    q: number;
+  lang: string;
+  q: number;
 }>;
 /**
  * Validate and normalize language codes
@@ -79,10 +76,10 @@ export declare function detectFromPath(c: Context, options: DetectorOptions): st
  * 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;
+  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;
@@ -98,5 +95,24 @@ 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/dist/node_modules/hono/dist/types/middleware/logger/index.d.ts

@@ -1,8 +1,5 @@
-/**
- * @module
- * Logger Middleware for Hono.
- */
-import type { MiddlewareHandler } from '../../types';
+import { MiddlewareHandler } from "../../types.js";
+//#region src/middleware/logger/index.d.ts
 type PrintFunc = (str: string, ...rest: string[]) => void;
 /**
  * Logger Middleware for Hono.
@@ -21,4 +18,5 @@ type PrintFunc = (str: string, ...rest: string[]) => void;
  * ```
  */
 export declare const logger: (fn?: PrintFunc) => MiddlewareHandler;
+//#endregion
 export {};

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

@@ -0,0 +1,47 @@
+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/dist/node_modules/hono/dist/types/middleware/method-override/index.d.ts

@@ -1,23 +1,20 @@
-/**
- * @module
- * Method Override Middleware for Hono.
- */
-import type { Hono } from '../../hono';
-import type { MiddlewareHandler } from '../../types';
+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>;
+  app: Hono<any, any, any>;
 } & ({
-    form?: string;
-    header?: never;
-    query?: never;
+  form?: string;
+  header?: never;
+  query?: never;
 } | {
-    form?: never;
-    header: string;
-    query?: never;
+  form?: never;
+  header: string;
+  query?: never;
 } | {
-    form?: never;
-    header?: never;
-    query: string;
+  form?: never;
+  header?: never;
+  query: string;
 });
 /**
  * Method Override Middleware for Hono.
@@ -45,4 +42,5 @@ type MethodOverrideOptions = {
  * ```
  */
 export declare const methodOverride: (options: MethodOverrideOptions) => MiddlewareHandler;
+//#endregion
 export {};

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

@@ -0,0 +1,46 @@
+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()`
+ *
+ * @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/dist/node_modules/hono/dist/types/middleware/powered-by/index.d.ts

@@ -1,14 +1,11 @@
-/**
- * @module
- * Powered By Middleware for Hono.
- */
-import type { MiddlewareHandler } from '../../types';
+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;
+  /**
+   * The value for X-Powered-By header.
+   * @default Hono
+   */
+  serverName?: string;
 };
 /**
  * Powered By Middleware for Hono.
@@ -26,4 +23,5 @@ type PoweredByOptions = {
  * ```
  */
 export declare const poweredBy: (options?: PoweredByOptions) => MiddlewareHandler;
+//#endregion
 export {};

package/dist/node_modules/hono/dist/types/middleware/pretty-json/index.d.ts

@@ -1,24 +1,21 @@
-/**
- * @module
- * Pretty JSON Middleware for Hono.
- */
-import type { MiddlewareHandler } from '../../types';
+import { MiddlewareHandler } from "../../types.js";
+//#region src/middleware/pretty-json/index.d.ts
 interface PrettyOptions {
-    /**
-     * Number of spaces for indentation.
-     * @default 2
-     */
-    space?: number;
-    /**
-     * Query conditions for when to Pretty.
-     * @default 'pretty'
-     */
-    query?: string;
-    /**
-     * Force prettification of JSON responses regardless of query parameters.
-     * @default false
-     */
-    force?: boolean;
+  /**
+   * Number of spaces for indentation.
+   * @default 2
+   */
+  space?: number;
+  /**
+   * Query conditions for when to Pretty.
+   * @default 'pretty'
+   */
+  query?: string;
+  /**
+   * Force prettification of JSON responses regardless of query parameters.
+   * @default false
+   */
+  force?: boolean;
 }
 /**
  * Pretty JSON Middleware for Hono.
@@ -39,4 +36,5 @@ interface PrettyOptions {
  * ```
  */
 export declare const prettyJSON: (options?: PrettyOptions) => MiddlewareHandler;
+//#endregion
 export {};

package/dist/node_modules/hono/dist/types/middleware/request-id/index.d.ts

@@ -1,7 +1,8 @@
-import type { RequestIdVariables } from './request-id';
-export type { RequestIdVariables };
-export { requestId } from './request-id';
+import { RequestIdVariables, requestId } from "./request-id.js";
+//#region src/middleware/request-id/index.d.ts
 declare module '../..' {
-    interface ContextVariableMap extends RequestIdVariables {
-    }
+  interface ContextVariableMap extends RequestIdVariables {}
 }
+//#endregion
+export { type RequestIdVariables, requestId };
+export {};

package/dist/node_modules/hono/dist/types/middleware/request-id/request-id.d.ts

@@ -1,16 +1,13 @@
-/**
- * @module
- * Request ID Middleware for Hono.
- */
-import type { Context } from '../../context';
-import type { MiddlewareHandler } from '../../types';
+import { MiddlewareHandler } from "../../types.js";
+import { Context } from "../../context.js";
+//#region src/middleware/request-id/request-id.d.ts
 export type RequestIdVariables = {
-    requestId: string;
+  requestId: string;
 };
 export type RequestIdOptions = {
-    limitLength?: number;
-    headerName?: string;
-    generator?: (c: Context) => string;
+  limitLength?: number;
+  headerName?: string;
+  generator?: (c: Context) => string;
 };
 /**
  * Request ID Middleware for Hono.
@@ -34,4 +31,5 @@ export type RequestIdOptions = {
  * })
  * ```
  */
-export declare const requestId: ({ limitLength, headerName, generator, }?: RequestIdOptions) => MiddlewareHandler;
+export declare const requestId: ({ limitLength, headerName, generator }?: RequestIdOptions) => MiddlewareHandler;
+//#endregion

package/dist/node_modules/hono/dist/types/middleware/secure-headers/index.d.ts

@@ -1,8 +1,8 @@
-export type { ContentSecurityPolicyOptionHandler } from './secure-headers';
-export { NONCE, secureHeaders } from './secure-headers';
-import type { SecureHeadersVariables } from './secure-headers';
-export type { SecureHeadersVariables };
+import { ContentSecurityPolicyOptionHandler, NONCE, SecureHeadersVariables, secureHeaders } from "./secure-headers.js";
+//#region src/middleware/secure-headers/index.d.ts
 declare module '../..' {
-    interface ContextVariableMap extends SecureHeadersVariables {
-    }
+  interface ContextVariableMap extends SecureHeadersVariables {}
 }
+//#endregion
+export { type ContentSecurityPolicyOptionHandler, NONCE, type SecureHeadersVariables, secureHeaders };
+export {};