@zuplo/cli 6.69.11 → 6.70.1

package/node_modules/hono/dist/types/helper/css/index.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @module
+ * css Helper for Hono.
+ */
+import type { HtmlEscapedString } from '../../utils/html';
+import type { ClassNameSlug, CssClassName as CssClassNameCommon, CssVariableType, OnInvalidSlug } from './common';
+export { rawCssString } from './common';
+export type { ClassNameSlug, OnInvalidSlug } from './common';
+type CssClassName = HtmlEscapedString & CssClassNameCommon;
+interface CssType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): Promise<string>;
+}
+interface CxType {
+    (...args: (CssClassName | Promise<string> | string | boolean | null | undefined)[]): Promise<string>;
+}
+interface KeyframesType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassNameCommon;
+}
+interface ViewTransitionType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): Promise<string>;
+    (content: Promise<string>): Promise<string>;
+    (): Promise<string>;
+}
+interface StyleType {
+    (args?: {
+        children?: Promise<string>;
+        nonce?: string;
+    }): HtmlEscapedString;
+}
+/**
+ * @experimental
+ * `createCssContext` is an experimental feature.
+ * The API might be changed.
+ *
+ * @param options.id - The ID for the style element
+ * @param options.classNameSlug - Optional function to customize generated CSS class names
+ * @param options.onInvalidSlug - Optional callback function called when an invalid slug is returned from ClassNameSlug
+ */
+export declare const createCssContext: ({ id, classNameSlug, onInvalidSlug, }: {
+    id: Readonly<string>;
+    classNameSlug?: ClassNameSlug;
+    onInvalidSlug?: OnInvalidSlug;
+}) => DefaultContextType;
+interface DefaultContextType {
+    css: CssType;
+    cx: CxType;
+    keyframes: KeyframesType;
+    viewTransition: ViewTransitionType;
+    Style: StyleType;
+}
+/**
+ * @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: StyleType;

package/node_modules/hono/dist/types/helper/dev/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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 {};

package/node_modules/hono/dist/types/helper/factory/index.d.ts

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

package/node_modules/hono/dist/types/helper/html/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @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>;

package/node_modules/hono/dist/types/helper/proxy/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @module
+ * Proxy Helper for Hono.
+ */
+import type { RequestHeader } from '../../utils/headers';
+interface ProxyRequestInit extends Omit<RequestInit, 'headers'> {
+    raw?: Request;
+    headers?: HeadersInit | [string, string][] | Record<RequestHeader, string | undefined> | Record<string, string | undefined>;
+    customFetch?: (request: Request) => Promise<Response>;
+    /**
+     * Enable strict RFC 9110 compliance for Connection header processing.
+     *
+     * - `false` (default): Ignores Connection header to prevent potential
+     *   Hop-by-Hop Header Injection attacks. Recommended for untrusted clients.
+     * - `true`: Processes Connection header per RFC 9110 and removes listed headers.
+     *   Only use in trusted environments.
+     *
+     * @default false
+     * @see https://datatracker.ietf.org/doc/html/rfc9110#section-7.6.1
+     */
+    strictConnectionProcessing?: boolean;
+}
+interface ProxyFetch {
+    (input: string | URL | Request, init?: ProxyRequestInit): Promise<Response>;
+}
+/**
+ * Fetch API wrapper for proxy.
+ * The parameters and return value are the same as for `fetch` (except for the proxy-specific options).
+ *
+ * The “Accept-Encoding” header is replaced with an encoding that the current runtime can handle.
+ * Unnecessary response headers are deleted and a Response object is returned that can be returned
+ * as is as a response from the handler.
+ *
+ * @example
+ * ```ts
+ * app.get('/proxy/:path', (c) => {
+ *   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+ *     headers: {
+ *       ...c.req.header(), // optional, specify only when forwarding all the request data (including credentials) is necessary.
+ *       'X-Forwarded-For': '127.0.0.1',
+ *       'X-Forwarded-Host': c.req.header('host'),
+ *       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+ *     },
+ *   }).then((res) => {
+ *     res.headers.delete('Set-Cookie')
+ *     return res
+ *   })
+ * })
+ *
+ * app.all('/proxy/:path', (c) => {
+ *   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+ *     ...c.req, // optional, specify only when forwarding all the request data (including credentials) is necessary.
+ *     headers: {
+ *       ...c.req.header(),
+ *       'X-Forwarded-For': '127.0.0.1',
+ *       'X-Forwarded-Host': c.req.header('host'),
+ *       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+ *     },
+ *   })
+ * })
+ *
+ * // Strict RFC compliance mode (use only in trusted environments)
+ * app.get('/internal-proxy/:path', (c) => {
+ *   return proxy(`http://${internalServer}/${c.req.param('path')}`, {
+ *     ...c.req,
+ *     strictConnectionProcessing: true,
+ *   })
+ * })
+ * ```
+ */
+export declare const proxy: ProxyFetch;
+export {};

package/node_modules/hono/dist/types/helper/route/index.d.ts

@@ -0,0 +1,75 @@
+import type { Context } from '../../context';
+import type { RouterRoute } from '../../types';
+/**
+ * Get matched routes in the handler
+ *
+ * @param {Context} c - The context object
+ * @returns An array of matched routes
+ *
+ * @example
+ * ```ts
+ * import { matchedRoutes } from 'hono/route'
+ *
+ * app.use('*', async function logger(c, next) {
+ *   await next()
+ *   matchedRoutes(c).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' : ''
+ *     )
+ *   })
+ * })
+ * ```
+ */
+export declare const matchedRoutes: (c: Context) => RouterRoute[];
+/**
+ * Get the route path registered within the handler
+ *
+ * @param {Context} c - The context object
+ * @param {number} index - The index of the root from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching root. Defaults to the current root index.
+ * @returns The route path registered within the handler
+ *
+ * @example
+ * ```ts
+ * import { routePath } from 'hono/route'
+ *
+ * app.use('*', (c, next) => {
+ *   console.log(routePath(c)) // '*'
+ *   console.log(routePath(c, -1)) // '/posts/:id'
+ *   return next()
+ * })
+ *
+ * app.get('/posts/:id', (c) => {
+ *   return c.text(routePath(c)) // '/posts/:id'
+ * })
+ * ```
+ */
+export declare const routePath: (c: Context, index?: number) => string;
+/**
+ * Get the basePath of the as-is route specified by routing.
+ *
+ * @param {Context} c - The context object
+ * @param {number} index - The index of the root from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching root. Defaults to the current root index.
+ * @returns The basePath of the as-is route specified by routing.
+ *
+ * @example
+ * ```ts
+ * import { baseRoutePath } from 'hono/route'
+ *
+ * const app = new Hono()
+ *
+ * const subApp = new Hono()
+ * subApp.get('/posts/:id', (c) => {
+ *   return c.text(baseRoutePath(c)) // '/:sub'
+ * })
+ *
+ * app.route('/:sub', subApp)
+ * ```
+ */
+export declare const baseRoutePath: (c: Context, index?: number) => string;
+export declare const basePath: (c: Context, index?: number) => string;

package/node_modules/hono/dist/types/helper/ssg/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * SSG Helper for Hono.
+ */
+export * from './ssg';
+export { X_HONO_DISABLE_SSG_HEADER_KEY, ssgParams, isSSGContext, disableSSG, onlySSG, } from './middleware';
+export { defaultPlugin, redirectPlugin } from './plugins';

package/node_modules/hono/dist/types/helper/ssg/middleware.d.ts

@@ -0,0 +1,44 @@
+import type { Context } from '../../context';
+import type { Env, MiddlewareHandler } from '../../types';
+export declare const SSG_CONTEXT = "HONO_SSG_CONTEXT";
+export declare const X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
+/**
+ * @deprecated
+ * Use `X_HONO_DISABLE_SSG_HEADER_KEY` instead.
+ * This constant will be removed in the next minor version.
+ */
+export declare const SSG_DISABLED_RESPONSE: Response;
+interface SSGParam {
+    [key: string]: string;
+}
+export type SSGParams = SSGParam[];
+interface SSGParamsMiddleware {
+    <E extends Env = Env>(generateParams: (c: Context<E>) => SSGParams | Promise<SSGParams>): MiddlewareHandler<E>;
+    <E extends Env = Env>(params: SSGParams): MiddlewareHandler<E>;
+}
+export type AddedSSGDataRequest = Request & {
+    ssgParams?: SSGParams;
+};
+/**
+ * Define SSG Route
+ */
+export declare const ssgParams: SSGParamsMiddleware;
+/**
+ * @experimental
+ * `isSSGContext` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const isSSGContext: (c: Context) => boolean;
+/**
+ * @experimental
+ * `disableSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const disableSSG: () => MiddlewareHandler;
+/**
+ * @experimental
+ * `onlySSG` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const onlySSG: () => MiddlewareHandler;
+export {};

package/node_modules/hono/dist/types/helper/ssg/plugins.d.ts

@@ -0,0 +1,27 @@
+import type { SSGPlugin } from './ssg';
+/**
+ * The default plugin that defines the recommended behavior.
+ *
+ * @experimental
+ * `defaultPlugin` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const defaultPlugin: () => SSGPlugin;
+/**
+ * The redirect plugin that generates HTML redirect pages for HTTP redirect responses for status codes 301, 302, 303, 307 and 308.
+ *
+ * When used with `defaultPlugin`, place `redirectPlugin` before it, because `defaultPlugin` skips non-200 responses.
+ *
+ * ```ts
+ * // ✅ Will work as expected
+ * toSSG(app, fs, { plugins: [redirectPlugin(), defaultPlugin()] })
+ *
+ * // ❌ Will not work as expected
+ * toSSG(app, fs, { plugins: [defaultPlugin(), redirectPlugin()] })
+ * ```
+ *
+ * @experimental
+ * `redirectPlugin` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const redirectPlugin: () => SSGPlugin;

package/node_modules/hono/dist/types/helper/ssg/ssg.d.ts

@@ -0,0 +1,91 @@
+import type { Hono } from '../../hono';
+import type { Env, Schema } from '../../types';
+export declare const DEFAULT_OUTPUT_DIR = "./static";
+/**
+ * @experimental
+ * `FileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+export interface FileSystemModule {
+    writeFile(path: string, data: string | Uint8Array): Promise<void>;
+    mkdir(path: string, options: {
+        recursive: boolean;
+    }): Promise<void | string>;
+}
+/**
+ * @experimental
+ * `ToSSGResult` is an experimental feature.
+ * The API might be changed.
+ */
+export interface ToSSGResult {
+    success: boolean;
+    files: string[];
+    error?: Error;
+}
+export declare const defaultExtensionMap: Record<string, string>;
+export type BeforeRequestHook = (req: Request) => Request | false | Promise<Request | false>;
+export type AfterResponseHook = (res: Response) => Response | false | Promise<Response | false>;
+export type AfterGenerateHook = (result: ToSSGResult, fsModule: FileSystemModule, options?: ToSSGOptions) => void | Promise<void>;
+export declare const combineBeforeRequestHooks: (hooks: BeforeRequestHook | BeforeRequestHook[]) => BeforeRequestHook;
+export declare const combineAfterResponseHooks: (hooks: AfterResponseHook | AfterResponseHook[]) => AfterResponseHook;
+export declare const combineAfterGenerateHooks: (hooks: AfterGenerateHook | AfterGenerateHook[], fsModule: FileSystemModule, options?: ToSSGOptions) => AfterGenerateHook;
+export interface SSGPlugin {
+    beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[];
+    afterResponseHook?: AfterResponseHook | AfterResponseHook[];
+    afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[];
+}
+export interface ToSSGOptions {
+    dir?: string;
+    /**
+     * @deprecated Use plugins[].beforeRequestHook instead.
+     */
+    beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[];
+    /**
+     * @deprecated Use plugins[].afterResponseHook instead.
+     */
+    afterResponseHook?: AfterResponseHook | AfterResponseHook[];
+    /**
+     * @deprecated Use plugins[].afterGenerateHook instead.
+     */
+    afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[];
+    concurrency?: number;
+    extensionMap?: Record<string, string>;
+    plugins?: SSGPlugin[];
+}
+/**
+ * @experimental
+ * `fetchRoutesContent` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const fetchRoutesContent: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>, beforeRequestHook?: BeforeRequestHook, afterResponseHook?: AfterResponseHook, concurrency?: number) => Generator<Promise<Generator<Promise<{
+    routePath: string;
+    mimeType: string;
+    content: string | ArrayBuffer;
+} | undefined>> | undefined>>;
+export declare const saveContentToFile: (data: Promise<{
+    routePath: string;
+    content: string | ArrayBuffer;
+    mimeType: string;
+} | undefined>, fsModule: FileSystemModule, outDir: string, extensionMap?: Record<string, string>) => Promise<string | undefined>;
+/**
+ * @experimental
+ * `ToSSGInterface` is an experimental feature.
+ * The API might be changed.
+ */
+export interface ToSSGInterface {
+    (app: Hono<any, any, any>, fsModule: FileSystemModule, options?: ToSSGOptions): Promise<ToSSGResult>;
+}
+/**
+ * @experimental
+ * `ToSSGAdaptorInterface` is an experimental feature.
+ * The API might be changed.
+ */
+export interface ToSSGAdaptorInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
+    (app: Hono<E, S, BasePath>, options?: ToSSGOptions): Promise<ToSSGResult>;
+}
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const toSSG: ToSSGInterface;

package/node_modules/hono/dist/types/helper/ssg/utils.d.ts

@@ -0,0 +1,16 @@
+import type { Hono } from '../../hono';
+import type { Env } from '../../types';
+/**
+ * Get dirname
+ * @param path File Path
+ * @returns Parent dir path
+ */
+export declare const dirname: (path: string) => string;
+export declare const joinPaths: (...paths: string[]) => string;
+interface FilterStaticGenerateRouteData {
+    path: string;
+}
+export declare const filterStaticGenerateRoutes: <E extends Env>(hono: Hono<E>) => FilterStaticGenerateRouteData[];
+export declare const isDynamicRoute: (path: string) => boolean;
+export declare const ensureWithinOutDir: (outDir: string, filePath: string) => void;
+export {};

package/node_modules/hono/dist/types/helper/streaming/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * Streaming Helper for Hono.
+ */
+export { stream } from './stream';
+export type { SSEMessage } from './sse';
+export { streamSSE, SSEStreamingApi } from './sse';
+export { streamText } from './text';

package/node_modules/hono/dist/types/helper/streaming/sse.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from '../../context';
+import { StreamingApi } from '../../utils/stream';
+export interface SSEMessage {
+    data: string | Promise<string>;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+export declare class SSEStreamingApi extends StreamingApi {
+    constructor(writable: WritableStream, readable: ReadableStream);
+    writeSSE(message: SSEMessage): Promise<void>;
+}
+export declare const streamSSE: (c: Context, cb: (stream: SSEStreamingApi) => Promise<void>, onError?: (e: Error, stream: SSEStreamingApi) => Promise<void>) => Response;

package/node_modules/hono/dist/types/helper/streaming/stream.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '../../context';
+import { StreamingApi } from '../../utils/stream';
+export declare const stream: (c: Context, cb: (stream: StreamingApi) => Promise<void>, onError?: (e: Error, stream: StreamingApi) => Promise<void>) => Response;

package/node_modules/hono/dist/types/helper/streaming/text.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '../../context';
+import type { StreamingApi } from '../../utils/stream';
+export declare const streamText: (c: Context, cb: (stream: StreamingApi) => Promise<void>, onError?: (e: Error, stream: StreamingApi) => Promise<void>) => Response;

package/node_modules/hono/dist/types/helper/streaming/utils.d.ts

@@ -0,0 +1 @@
+export declare let isOldBunVersion: () => boolean;

package/node_modules/hono/dist/types/helper/testing/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module
+ * Testing Helper for Hono.
+ */
+import type { Client, ClientRequestOptions } 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, options?: Omit<ClientRequestOptions, "fetch">) => UnionToIntersection<Client<T, "http://localhost">>;
+export {};