@zuplo/cli 7.8.18 → 7.8.20

package/node_modules/hono/dist/types/adapter/service-worker/index.d.ts

@@ -1,11 +1,7 @@
-/**
- * Service Worker Adapter for Hono.
- * @module
- */
-import type { Hono } from '../../hono';
-import type { Env, Schema } from '../../types';
-import { handle } from './handler';
-import type { HandleOptions } from './handler';
+import { Env, Schema } from "../../types.js";
+import { Hono } from "../../hono.js";
+import { HandleOptions, handle } from "./handler.js";
+//#region src/adapter/service-worker/index.d.ts
 /**
  * Registers a Hono app to handle fetch events in a service worker.
  * This sets up `addEventListener('fetch', handle(app, options))` for the provided app.
@@ -25,4 +21,5 @@ import type { HandleOptions } from './handler';
  * ```
  */
 declare const fire: <E extends Env, S extends Schema, BasePath extends string>(app: Hono<E, S, BasePath>, options?: HandleOptions) => void;
-export { handle, fire };
+//#endregion
+export { fire, handle };

package/node_modules/hono/dist/types/adapter/service-worker/types.d.ts

@@ -1,12 +1,16 @@
+//#region src/adapter/service-worker/types.d.ts
 interface ExtendableEvent extends Event {
-    waitUntil(f: Promise<any>): void;
+  waitUntil(f: Promise<any>): void;
 }
+/**
+ * @deprecated `hono/service-worker` will be removed in v5. Install `@hono/service-worker` and import from there instead.
+ */
 export interface FetchEvent extends ExtendableEvent {
-    readonly clientId: string;
-    readonly handled: Promise<void>;
-    readonly preloadResponse: Promise<any>;
-    readonly request: Request;
-    readonly resultingClientId: string;
-    respondWith(r: Response | PromiseLike<Response>): void;
+  readonly clientId: string;
+  readonly handled: Promise<void>;
+  readonly preloadResponse: Promise<any>;
+  readonly request: Request;
+  readonly resultingClientId: string;
+  respondWith(r: Response | PromiseLike<Response>): void;
 }
-export {};
+//#endregion

package/node_modules/hono/dist/types/adapter/vercel/conninfo.d.ts

@@ -1,2 +1,7 @@
-import type { GetConnInfo } from '../../helper/conninfo';
+import { GetConnInfo } from "../../helper/conninfo/types.js";
+//#region src/adapter/vercel/conninfo.d.ts
+/**
+ * @deprecated `hono/vercel` will be removed in v5. Install `@hono/vercel` and import from there instead.
+ */
 export declare const getConnInfo: GetConnInfo;
+//#endregion

package/node_modules/hono/dist/types/adapter/vercel/handler.d.ts

@@ -1,2 +1,7 @@
-import type { Hono } from '../../hono';
+import { Hono } from "../../hono.js";
+//#region src/adapter/vercel/handler.d.ts
+/**
+ * @deprecated `hono/vercel` will be removed in v5. Install `@hono/vercel` and import from there instead.
+ */
 export declare const handle: (app: Hono<any, any, any>) => (req: Request) => Response | Promise<Response>;
+//#endregion

package/node_modules/hono/dist/types/adapter/vercel/index.d.ts

@@ -1,6 +1,3 @@
-/**
- * @module
- * Vercel Adapter for Hono.
- */
-export { handle } from './handler';
-export { getConnInfo } from './conninfo';
+import { getConnInfo } from "./conninfo.js";
+import { handle } from "./handler.js";
+export { getConnInfo, handle };

package/node_modules/hono/dist/types/client/client.d.ts

@@ -1,4 +1,6 @@
-import type { Hono } from '../hono';
-import type { UnionToIntersection } from '../utils/types';
-import type { Client, ClientRequestOptions } from './types';
+import { UnionToIntersection } from "../utils/types.js";
+import { Hono } from "../hono.js";
+import { Client, ClientRequestOptions } from "./types.js";
+//#region src/client/client.d.ts
 export declare const hc: <T extends Hono<any, any, any>, Prefix extends string = string>(baseUrl: Prefix, options?: ClientRequestOptions) => UnionToIntersection<Client<T, Prefix>>;
+//#endregion

package/node_modules/hono/dist/types/client/fetch-result-please.d.ts

@@ -1,3 +1,4 @@
+//#region src/client/fetch-result-please.d.ts
 /**
  * @description This file is a modified version of `fetch-result-please` (`ofetch`), minimalized and adapted to Hono's custom needs.
  *
@@ -10,26 +11,27 @@
  */
 export declare function fetchRP(fetchRes: Response | Promise<Response>): Promise<any>;
 export declare class DetailedError extends Error {
-    /**
-     * Additional `message` that will be logged AND returned to client
-     */
+  /**
+   * Additional `message` that will be logged AND returned to client
+   */
+  detail?: any;
+  /**
+   * Additional `code` that will be logged AND returned to client
+   */
+  code?: any;
+  /**
+   * Additional value that will be logged AND NOT returned to client
+   */
+  log?: any;
+  /**
+   * Optionally set the status code to return, in a web server context
+   */
+  statusCode?: any;
+  constructor(message: string, options?: {
     detail?: any;
-    /**
-     * Additional `code` that will be logged AND returned to client
-     */
     code?: any;
-    /**
-     * Additional value that will be logged AND NOT returned to client
-     */
+    statusCode?: number;
     log?: any;
-    /**
-     * Optionally set the status code to return, in a web server context
-     */
-    statusCode?: any;
-    constructor(message: string, options?: {
-        detail?: any;
-        code?: any;
-        statusCode?: number;
-        log?: any;
-    });
+  });
 }
+//#endregion

package/node_modules/hono/dist/types/client/index.d.ts

@@ -1,7 +1,5 @@
-/**
- * @module
- * The HTTP Client for Hono.
- */
-export { hc } from './client';
-export { parseResponse, DetailedError } from './utils';
-export type { InferResponseType, InferRequestType, Fetch, ClientRequestOptions, ClientRequest, ClientResponse, ApplyGlobalResponse, PickResponseByStatusCode, } from './types';
+import { ApplyGlobalResponse, ClientRequest, ClientRequestOptions, ClientResponse, Fetch, InferRequestType, InferResponseType, PickResponseByStatusCode } from "./types.js";
+import { hc } from "./client.js";
+import { DetailedError } from "./fetch-result-please.js";
+import { parseResponse } from "./utils.js";
+export { type ApplyGlobalResponse, type ClientRequest, type ClientRequestOptions, type ClientResponse, DetailedError, type Fetch, type InferRequestType, type InferResponseType, type PickResponseByStatusCode, hc, parseResponse };

package/node_modules/hono/dist/types/client/types.d.ts

@@ -1,9 +1,10 @@
-import type { Hono } from '../hono';
-import type { HonoBase } from '../hono-base';
-import type { METHODS, METHOD_NAME_ALL_LOWERCASE } from '../router';
-import type { Endpoint, ExtractSchema, KnownResponseFormat, ResponseFormat, Schema } from '../types';
-import type { StatusCode, SuccessStatusCode } from '../utils/http-status';
-import type { HasRequiredKeys } from '../utils/types';
+import { METHODS, METHOD_NAME_ALL_LOWERCASE } from "../router.js";
+import { HonoBase as Hono } from "../hono-base.js";
+import { StatusCode, SuccessStatusCode } from "../utils/http-status.js";
+import { HasRequiredKeys } from "../utils/types.js";
+import { Endpoint, ExtractSchema, KnownResponseFormat, ResponseFormat, Schema } from "../types.js";
+import { Hono as Hono$1 } from "../hono.js";
+//#region src/client/types.d.ts
 /**
  * Type representing the '$all' method name
  */
@@ -18,114 +19,108 @@ type StandardMethods = `$${(typeof METHODS)[number]}`;
  * If the schema contains '$all', it creates a type where all standard HTTP methods
  * point to the same endpoint definition as '$all', while removing '$all' itself.
  */
-type ExpandAllMethod<S> = MethodNameAll extends keyof S ? {
-    [M in StandardMethods]: S[MethodNameAll];
-} & Omit<S, MethodNameAll> : S;
-type HonoRequest = (typeof Hono.prototype)['request'];
+type ExpandAllMethod<S> = MethodNameAll extends keyof S ? { [M in StandardMethods]: S[MethodNameAll]; } & Omit<S, MethodNameAll> : S;
+type HonoRequest = (typeof Hono$1.prototype)['request'];
 export type BuildSearchParamsFn = (query: Record<string, string | string[]>) => URLSearchParams;
 export type ClientRequestOptions<T = unknown> = {
-    fetch?: typeof fetch | HonoRequest;
-    webSocket?: (...args: ConstructorParameters<typeof WebSocket>) => WebSocket;
-    /**
-     * Standard `RequestInit`, caution that this take highest priority
-     * and could be used to overwrite things that Hono sets for you, like `body | method | headers`.
-     *
-     * If you want to add some headers, use in `headers` instead of `init`
-     */
-    init?: RequestInit;
-    /**
-     * Custom function to serialize query parameters into URLSearchParams.
-     * By default, arrays are serialized as multiple parameters with the same key (e.g., `key=a&key=b`).
-     * You can provide a custom function to change this behavior, for example to use bracket notation (e.g., `key[]=a&key[]=b`).
-     *
-     * @example
-     * ```ts
-     * const client = hc('http://localhost', {
-     *   buildSearchParams: (query) => {
-     *     return new URLSearchParams(qs.stringify(query))
-     *   }
-     * })
-     * ```
-     */
-    buildSearchParams?: BuildSearchParamsFn;
+  fetch?: typeof fetch | HonoRequest;
+  webSocket?: (...args: ConstructorParameters<typeof WebSocket>) => WebSocket;
+  /**
+   * Standard `RequestInit`, caution that this take highest priority
+   * and could be used to overwrite things that Hono sets for you, like `body | method | headers`.
+   *
+   * If you want to add some headers, use in `headers` instead of `init`
+   */
+  init?: RequestInit;
+  /**
+   * Custom function to serialize query parameters into URLSearchParams.
+   * By default, arrays are serialized as multiple parameters with the same key (e.g., `key=a&key=b`).
+   * You can provide a custom function to change this behavior, for example to use bracket notation (e.g., `key[]=a&key[]=b`).
+   *
+   * @example
+   * ```ts
+   * const client = hc('http://localhost', {
+   *   buildSearchParams: (query) => {
+   *     return new URLSearchParams(qs.stringify(query))
+   *   }
+   * })
+   * ```
+   */
+  buildSearchParams?: BuildSearchParamsFn;
 } & (keyof T extends never ? {
-    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+  headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
 } : {
-    headers: T | (() => T | Promise<T>);
+  headers: T | (() => T | Promise<T>);
 });
-export type ClientRequest<Prefix extends string, Path extends string, S extends Schema> = {
-    [M in keyof ExpandAllMethod<S>]: ExpandAllMethod<S>[M] extends Endpoint & {
-        input: infer R;
-    } ? R extends object ? HasRequiredKeys<R> extends true ? (args: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : (args?: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : never : never;
-} & {
-    $url: <const Arg extends (S[keyof S] extends {
-        input: infer R;
-    } ? R extends {
-        param: infer P;
-    } ? R extends {
-        query: infer Q;
-    } ? {
-        param: P;
-        query: Q;
-    } : {
-        param: P;
-    } : R extends {
-        query: infer Q;
-    } ? {
-        query: Q;
-    } : {} : {}) | undefined = undefined>(arg?: Arg) => HonoURL<Prefix, Path, Arg>;
-    $path: <const Arg extends (S[keyof S] extends {
-        input: infer R;
-    } ? R extends {
-        param: infer P;
-    } ? R extends {
-        query: infer Q;
-    } ? {
-        param: P;
-        query: Q;
-    } : {
-        param: P;
-    } : R extends {
-        query: infer Q;
-    } ? {
-        query: Q;
-    } : {} : {}) | undefined = undefined>(arg?: Arg) => BuildPath<Path, Arg>;
+export type ClientRequest<Prefix extends string, Path extends string, S extends Schema> = { [M in keyof ExpandAllMethod<S>]: ExpandAllMethod<S>[M] extends Endpoint & {
+  input: infer R;
+} ? R extends object ? HasRequiredKeys<R> extends true ? (args: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : (args?: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : never : never; } & {
+  $url: <const Arg extends (S[keyof S] extends {
+    input: infer R;
+  } ? R extends {
+    param: infer P;
+  } ? R extends {
+    query: infer Q;
+  } ? {
+    param: P;
+    query: Q;
+  } : {
+    param: P;
+  } : R extends {
+    query: infer Q;
+  } ? {
+    query: Q;
+  } : {} : {}) | undefined = undefined>(arg?: Arg) => HonoURL<Prefix, Path, Arg>;
+  $path: <const Arg extends (S[keyof S] extends {
+    input: infer R;
+  } ? R extends {
+    param: infer P;
+  } ? R extends {
+    query: infer Q;
+  } ? {
+    param: P;
+    query: Q;
+  } : {
+    param: P;
+  } : R extends {
+    query: infer Q;
+  } ? {
+    query: Q;
+  } : {} : {}) | undefined = undefined>(arg?: Arg) => BuildPath<Path, Arg>;
 } & (S['$get'] extends {
-    outputFormat: 'ws';
+  outputFormat: 'ws';
 } ? S['$get'] extends {
-    input: infer I;
+  input: infer I;
 } ? {
-    $ws: (args?: I) => WebSocket;
+  $ws: (args?: I) => WebSocket;
 } : {} : {});
 type ClientResponseOfEndpoint<T extends Endpoint = Endpoint> = T extends {
-    output: infer O;
-    outputFormat: infer F;
-    status: infer S;
+  output: infer O;
+  outputFormat: infer F;
+  status: infer S;
 } ? ClientResponse<O, S extends number ? S : never, F extends ResponseFormat ? F : never> : never;
 export interface ClientResponse<T, U extends number = StatusCode, F extends ResponseFormat = ResponseFormat> {
-    readonly body: ReadableStream | null;
-    readonly bodyUsed: boolean;
-    ok: U extends SuccessStatusCode ? true : U extends Exclude<StatusCode, SuccessStatusCode> ? false : boolean;
-    redirected: boolean;
-    status: U;
-    statusText: string;
-    type: 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
-    headers: Headers;
-    url: string;
-    redirect(url: string, status: number): Response;
-    clone(): Response;
-    bytes(): Promise<Uint8Array<ArrayBuffer>>;
-    json(): F extends 'text' ? Promise<never> : F extends 'json' ? Promise<T> : Promise<unknown>;
-    text(): F extends 'text' ? (T extends string ? Promise<T> : Promise<never>) : Promise<string>;
-    blob(): Promise<Blob>;
-    formData(): Promise<FormData>;
-    arrayBuffer(): Promise<ArrayBuffer>;
+  readonly body: ReadableStream | null;
+  readonly bodyUsed: boolean;
+  ok: U extends SuccessStatusCode ? true : U extends Exclude<StatusCode, SuccessStatusCode> ? false : boolean;
+  redirected: boolean;
+  status: U;
+  statusText: string;
+  type: 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
+  headers: Headers;
+  url: string;
+  redirect(url: string, status: number): Response;
+  clone(): Response;
+  bytes(): Promise<Uint8Array<ArrayBuffer>>;
+  json(): F extends 'text' ? Promise<never> : F extends 'json' ? Promise<T> : Promise<unknown>;
+  text(): F extends 'text' ? (T extends string ? Promise<T> : Promise<never>) : Promise<string>;
+  blob(): Promise<Blob>;
+  formData(): Promise<FormData>;
+  arrayBuffer(): Promise<ArrayBuffer>;
 }
-type BuildSearch<Arg, Key extends 'query'> = Arg extends {
-    [K in Key]: infer Query;
-} ? IsEmptyObject<Query> extends true ? '' : `?${string}` : '';
+type BuildSearch<Arg, Key extends 'query'> = Arg extends { [K in Key]: infer Query; } ? IsEmptyObject<Query> extends true ? '' : `?${string}` : '';
 type BuildPathname<P extends string, Arg> = Arg extends {
-    param: infer Param;
+  param: infer Param;
 } ? `${ApplyParam<TrimStartSlash<P>, Param>}` : `/${TrimStartSlash<P>}`;
 type BuildPath<P extends string, Arg> = `${BuildPathname<P, Arg>}${BuildSearch<Arg, 'query'>}`;
 type BuildTypedURL<Protocol extends string, Host extends string, Port extends string, P extends string, Arg> = TypedURL<`${Protocol}:`, Host, Port, BuildPathname<P, Arg>, BuildSearch<Arg, 'query'>>;
@@ -137,83 +132,62 @@ type IsLiteral<T extends string> = [T] extends [never] ? false : string extends
 type ApplyParam<Path extends string, P, Result extends string = ''> = Path extends `${infer Head}/${infer Rest}` ? Head extends `:${infer Param}` ? P extends Record<Param, infer Value extends string> ? IsLiteral<Value> extends true ? ApplyParam<Rest, P, `${Result}/${Value & string}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : Path extends `:${infer Param}` ? P extends Record<Param, infer Value extends string> ? IsLiteral<Value> extends true ? `${Result}/${Value & string}` : `${Result}/${Path}` : `${Result}/${Path}` : `${Result}/${Path}`;
 type IsEmptyObject<T> = keyof T extends never ? true : false;
 export interface TypedURL<Protocol extends string, Hostname extends string, Port extends string, Pathname extends string, Search extends string> extends URL {
-    protocol: Protocol;
-    hostname: Hostname;
-    port: Port;
-    host: Port extends '' ? Hostname : `${Hostname}:${Port}`;
-    origin: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}`;
-    pathname: Pathname;
-    search: Search;
-    href: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}${Pathname}${Search}`;
-}
-export interface Response extends ClientResponse<unknown> {
+  protocol: Protocol;
+  hostname: Hostname;
+  port: Port;
+  host: Port extends '' ? Hostname : `${Hostname}:${Port}`;
+  origin: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}`;
+  pathname: Pathname;
+  search: Search;
+  href: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}${Pathname}${Search}`;
 }
+export interface Response extends ClientResponse<unknown> {}
 export type Fetch<T> = (args?: InferRequestType<T>, opt?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<InferEndpointType<T>>>;
-type InferEndpointType<T> = T extends (args: infer R, options: any | undefined) => Promise<infer U> ? U extends ClientResponse<infer O, infer S, infer F> ? {
-    input: NonNullable<R>;
-    output: O;
-    outputFormat: F;
-    status: S;
+type InferEndpointType<T> = T extends ((args: infer R, options: any | undefined) => Promise<infer U>) ? U extends ClientResponse<infer O, infer S, infer F> ? {
+  input: NonNullable<R>;
+  output: O;
+  outputFormat: F;
+  status: S;
 } extends Endpoint ? {
-    input: NonNullable<R>;
-    output: O;
-    outputFormat: F;
-    status: S;
+  input: NonNullable<R>;
+  output: O;
+  outputFormat: F;
+  status: S;
 } : never : never : never;
 export type InferResponseType<T, U extends StatusCode = StatusCode> = InferResponseTypeFromEndpoint<InferEndpointType<T>, U>;
 type InferResponseTypeFromEndpoint<T extends Endpoint, U extends StatusCode> = T extends {
-    output: infer O;
-    status: infer S;
+  output: infer O;
+  status: infer S;
 } ? S extends U ? O : never : never;
-export type InferRequestType<T> = T extends (args: infer R, options: any | undefined) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
-export type InferRequestOptionsType<T> = T extends (args: any, options: infer R) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
+export type InferRequestType<T> = T extends ((args: infer R, options: any | undefined) => Promise<ClientResponse<unknown>>) ? NonNullable<R> : never;
+export type InferRequestOptionsType<T> = T extends ((args: any, options: infer R) => Promise<ClientResponse<unknown>>) ? NonNullable<R> : never;
 /**
  * Filter a ClientResponse type so it only includes responses of specific status codes.
  */
 export type FilterClientResponseByStatusCode<T extends ClientResponse<any, any, any>, U extends number = StatusCode> = T extends ClientResponse<infer RT, infer RC, infer RF> ? RC extends U ? ClientResponse<RT, RC, RF> : never : never;
-type PathToChain<Prefix extends string, Path extends string, E extends Schema, Original extends string = Path> = Path extends `/${infer P}` ? PathToChain<Prefix, P, E, Path> : Path extends `${infer P}/${infer R}` ? {
-    [K in P]: PathToChain<Prefix, R, E, Original>;
-} : {
-    [K in Path extends '' ? 'index' : Path]: ClientRequest<Prefix, Original, E extends Record<string, unknown> ? E[Original] : never>;
-};
-export type Client<T, Prefix extends string> = T extends HonoBase<any, infer S, any> ? S extends Record<infer K, Schema> ? K extends string ? PathToChain<Prefix, K, S> : never : never : never;
+type PathToChain<Prefix extends string, Path extends string, E extends Schema, Original extends string = Path> = Path extends `/${infer P}` ? PathToChain<Prefix, P, E, Path> : Path extends `${infer P}/${infer R}` ? { [K in P]: PathToChain<Prefix, R, E, Original>; } : { [K in Path extends '' ? 'index' : Path]: ClientRequest<Prefix, Original, E extends Record<string, unknown> ? E[Original] : never>; };
+export type Client<T, Prefix extends string> = T extends Hono<any, infer S, any> ? S extends Record<infer K, Schema> ? K extends string ? PathToChain<Prefix, K, S> : never : never : never;
 export type Callback = (opts: CallbackOptions) => unknown;
 interface CallbackOptions {
-    path: string[];
-    args: any[];
+  path: string[];
+  args: any[];
 }
 export type ObjectType<T = unknown> = {
-    [key: string]: T;
+  [key: string]: T;
 };
-type GlobalResponseDefinition = {
-    [S in StatusCode]?: {
-        [F in KnownResponseFormat]?: unknown;
-    };
-};
-type ToEndpoints<Def extends GlobalResponseDefinition, R> = {
-    [S in keyof Def & StatusCode]: {
-        [F in keyof Def[S] & KnownResponseFormat]: Omit<R, 'output' | 'status' | 'outputFormat'> & {
-            output: Def[S][F];
-            status: S;
-            outputFormat: F;
-        };
-    }[keyof Def[S] & KnownResponseFormat];
-}[keyof Def & StatusCode];
+type GlobalResponseDefinition = { [S in StatusCode]?: { [F in KnownResponseFormat]?: unknown; }; };
+type ToEndpoints<Def extends GlobalResponseDefinition, R> = { [S in keyof Def & StatusCode]: { [F in keyof Def[S] & KnownResponseFormat]: Omit<R, 'output' | 'status' | 'outputFormat'> & {
+  output: Def[S][F];
+  status: S;
+  outputFormat: F;
+}; }[keyof Def[S] & KnownResponseFormat]; }[keyof Def & StatusCode];
 type ModRoute<R, Def extends GlobalResponseDefinition> = R extends Endpoint ? R | ToEndpoints<Def, R> : R;
-type ModSchema<D, Def extends GlobalResponseDefinition> = {
-    [K in keyof D]: {
-        [M in keyof D[K]]: ModRoute<D[K][M], Def>;
-    };
-};
-export type ApplyGlobalResponse<App, Def extends GlobalResponseDefinition> = App extends HonoBase<infer E, infer _ extends Schema, infer B> ? ModSchema<ExtractSchema<App>, Def> extends infer S extends Schema ? Hono<E, S, B> : never : never;
+type ModSchema<D, Def extends GlobalResponseDefinition> = { [K in keyof D]: { [M in keyof D[K]]: ModRoute<D[K][M], Def>; }; };
+export type ApplyGlobalResponse<App, Def extends GlobalResponseDefinition> = App extends Hono<infer E, infer _ extends Schema, infer B> ? ModSchema<ExtractSchema<App>, Def> extends (infer S extends Schema) ? Hono$1<E, S, B> : never : never;
 type PickRoute<R, U extends StatusCode> = R extends Endpoint ? R extends {
-    status: U;
+  status: U;
 } ? R : never : R;
-type PickSchema<D, U extends StatusCode> = {
-    [K in keyof D]: {
-        [M in keyof D[K]]: PickRoute<D[K][M], U>;
-    };
-};
+type PickSchema<D, U extends StatusCode> = { [K in keyof D]: { [M in keyof D[K]]: PickRoute<D[K][M], U>; }; };
 /**
  * Keep only specific status code responses from all routes of an app.
  * Useful when error responses are handled centrally (e.g., via custom fetch)
@@ -225,5 +199,5 @@ type PickSchema<D, U extends StatusCode> = {
  * const client = hc<AppSuccessOnly>('http://localhost')
  * ```
  */
-export type PickResponseByStatusCode<App, U extends StatusCode> = App extends HonoBase<infer E, infer _ extends Schema, infer B> ? PickSchema<ExtractSchema<App>, U> extends infer S extends Schema ? Hono<E, S, B> : never : never;
-export {};
+export type PickResponseByStatusCode<App, U extends StatusCode> = App extends Hono<infer E, infer _ extends Schema, infer B> ? PickSchema<ExtractSchema<App>, U> extends (infer S extends Schema) ? Hono$1<E, S, B> : never : never;
+//#endregion

package/node_modules/hono/dist/types/client/utils.d.ts

@@ -1,7 +1,7 @@
-import type { ClientErrorStatusCode, ContentfulStatusCode, ServerErrorStatusCode } from '../utils/http-status';
-import { DetailedError } from './fetch-result-please';
-import type { ClientResponse, FilterClientResponseByStatusCode } from './types';
-export { DetailedError };
+import { ClientErrorStatusCode, ContentfulStatusCode, ServerErrorStatusCode } from "../utils/http-status.js";
+import { ClientResponse, FilterClientResponseByStatusCode } from "./types.js";
+import { DetailedError } from "./fetch-result-please.js";
+//#region src/client/utils.d.ts
 export declare const mergePath: (base: string, path: string) => string;
 export declare const replaceUrlParam: (urlString: string, params: Record<string, string | undefined>) => string;
 export declare const buildSearchParams: (query: Record<string, string | string[]>) => URLSearchParams;
@@ -16,3 +16,5 @@ export declare function deepMerge<T>(target: T, source: Record<string, unknown>)
  * @example const result = await parseResponse(client.posts.$get())
  */
 export declare function parseResponse<T extends ClientResponse<any>>(fetchRes: T | Promise<T>): Promise<FilterClientResponseByStatusCode<T, Exclude<ContentfulStatusCode, ClientErrorStatusCode | ServerErrorStatusCode>> extends never ? undefined : FilterClientResponseByStatusCode<T, Exclude<ContentfulStatusCode, ClientErrorStatusCode | ServerErrorStatusCode>> extends ClientResponse<infer RT, infer _, infer RF> ? RF extends 'json' ? RT : RT extends string ? RT : string : undefined>;
+//#endregion
+export { DetailedError };

package/node_modules/hono/dist/types/compose.d.ts

@@ -1,5 +1,6 @@
-import type { Context } from './context';
-import type { Env, ErrorHandler, Next, NotFoundHandler } from './types';
+import { Env, ErrorHandler, Next, NotFoundHandler } from "./types.js";
+import { Context } from "./context.js";
+//#region src/compose.d.ts
 /**
  * Compose middleware functions into a single function based on `koa-compose` package.
  *
@@ -12,3 +13,4 @@ import type { Env, ErrorHandler, Next, NotFoundHandler } from './types';
  * @returns {(context: Context, next?: Next) => Promise<Context>} - A composed middleware function.
  */
 export declare const compose: <E extends Env = Env>(middleware: [[Function, unknown], unknown][] | [[Function]][], onError?: ErrorHandler<E>, onNotFound?: NotFoundHandler<E>) => ((context: Context, next?: Next) => Promise<Context>);
+//#endregion