@devizovaburza/payments-api-sdk 1.2.0 → 1.2.1

package/dist/v1/index.d.mts

@@ -1,1977 +1,12 @@
-export { WebhookEventType, WebhookEventType as WebhookEventTypeValue } from '@apps/gateway/src/types/webhook';
-
-/**
- * @module
- * HTTP Status utility.
- */
-type InfoStatusCode = 100 | 101 | 102 | 103;
-type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
-type DeprecatedStatusCode = 305 | 306;
-type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
-type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
-type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
-/**
- * `UnofficialStatusCode` can be used to specify an unofficial status code.
- * @example
- *
- * ```ts
- * app.get('/unknown', (c) => {
- *   return c.text("Unknown Error", 520 as UnofficialStatusCode)
- * })
- * ```
- */
-type UnofficialStatusCode = -1;
-/**
- * If you want to use an unofficial status, use `UnofficialStatusCode`.
- */
-type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode | UnofficialStatusCode;
-type ContentlessStatusCode = 101 | 204 | 205 | 304;
-type ContentfulStatusCode = Exclude<StatusCode, ContentlessStatusCode>;
-
-declare const GET_MATCH_RESULT: unique symbol;
-
-/**
- * Constant representing all HTTP methods in lowercase.
- */
-declare const METHOD_NAME_ALL_LOWERCASE: "all";
-/**
- * Array of supported HTTP methods.
- */
-declare const METHODS: readonly ["get", "post", "put", "delete", "options", "patch"];
-/**
- * Interface representing a router.
- *
- * @template T - The type of the handler.
- */
-interface Router<T> {
-    /**
-     * The name of the router.
-     */
-    name: string;
-    /**
-     * Adds a route to the router.
-     *
-     * @param method - The HTTP method (e.g., 'get', 'post').
-     * @param path - The path for the route.
-     * @param handler - The handler for the route.
-     */
-    add(method: string, path: string, handler: T): void;
-    /**
-     * Matches a route based on the given method and path.
-     *
-     * @param method - The HTTP method (e.g., 'get', 'post').
-     * @param path - The path to match.
-     * @returns The result of the match.
-     */
-    match(method: string, path: string): Result<T>;
-}
-/**
- * Type representing a map of parameter indices.
- */
-type ParamIndexMap = Record<string, number>;
-/**
- * Type representing a stash of parameters.
- */
-type ParamStash = string[];
-/**
- * Type representing a map of parameters.
- */
-type Params = Record<string, string>;
-/**
- * Type representing the result of a route match.
- *
- * The result can be in one of two formats:
- * 1. An array of handlers with their corresponding parameter index maps, followed by a parameter stash.
- * 2. An array of handlers with their corresponding parameter maps.
- *
- * Example:
- *
- * [[handler, paramIndexMap][], paramArray]
- * ```typescript
- * [
- *   [
- *     [middlewareA, {}],                     // '*'
- *     [funcA,       {'id': 0}],              // '/user/:id/*'
- *     [funcB,       {'id': 0, 'action': 1}], // '/user/:id/:action'
- *   ],
- *   ['123', 'abc']
- * ]
- * ```
- *
- * [[handler, params][]]
- * ```typescript
- * [
- *   [
- *     [middlewareA, {}],                             // '*'
- *     [funcA,       {'id': '123'}],                  // '/user/:id/*'
- *     [funcB,       {'id': '123', 'action': 'abc'}], // '/user/:id/:action'
- *   ]
- * ]
- * ```
- */
-type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
-
-/**
- * @module
- * HTTP Headers utility.
- */
-type RequestHeader = 'A-IM' | 'Accept' | 'Accept-Additions' | 'Accept-CH' | 'Accept-Charset' | 'Accept-Datetime' | 'Accept-Encoding' | 'Accept-Features' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges' | 'Accept-Signature' | 'Access-Control' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Age' | 'Allow' | 'ALPN' | 'Alt-Svc' | 'Alt-Used' | 'Alternates' | 'AMP-Cache-Transform' | 'Apply-To-Redirect-Ref' | 'Authentication-Control' | 'Authentication-Info' | 'Authorization' | 'Available-Dictionary' | 'C-Ext' | 'C-Man' | 'C-Opt' | 'C-PEP' | 'C-PEP-Info' | 'Cache-Control' | 'Cache-Status' | 'Cal-Managed-ID' | 'CalDAV-Timezones' | 'Capsule-Protocol' | 'CDN-Cache-Control' | 'CDN-Loop' | 'Cert-Not-After' | 'Cert-Not-Before' | 'Clear-Site-Data' | 'Client-Cert' | 'Client-Cert-Chain' | 'Close' | 'CMCD-Object' | 'CMCD-Request' | 'CMCD-Session' | 'CMCD-Status' | 'CMSD-Dynamic' | 'CMSD-Static' | 'Concealed-Auth-Export' | 'Configuration-Context' | 'Connection' | 'Content-Base' | 'Content-Digest' | 'Content-Disposition' | 'Content-Encoding' | 'Content-ID' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-MD5' | 'Content-Range' | 'Content-Script-Type' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Style-Type' | 'Content-Type' | 'Content-Version' | 'Cookie' | 'Cookie2' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Embedder-Policy-Report-Only' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Opener-Policy-Report-Only' | 'Cross-Origin-Resource-Policy' | 'CTA-Common-Access-Token' | 'DASL' | 'Date' | 'DAV' | 'Default-Style' | 'Delta-Base' | 'Deprecation' | 'Depth' | 'Derived-From' | 'Destination' | 'Differential-ID' | 'Dictionary-ID' | 'Digest' | 'DPoP' | 'DPoP-Nonce' | 'Early-Data' | 'EDIINT-Features' | 'ETag' | 'Expect' | 'Expect-CT' | 'Expires' | 'Ext' | 'Forwarded' | 'From' | 'GetProfile' | 'Hobareg' | 'Host' | 'HTTP2-Settings' | 'If' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Schedule-Tag-Match' | 'If-Unmodified-Since' | 'IM' | 'Include-Referred-Token-Binding-ID' | 'Isolation' | 'Keep-Alive' | 'Label' | 'Last-Event-ID' | 'Last-Modified' | 'Link' | 'Link-Template' | 'Location' | 'Lock-Token' | 'Man' | 'Max-Forwards' | 'Memento-Datetime' | 'Meter' | 'Method-Check' | 'Method-Check-Expires' | 'MIME-Version' | 'Negotiate' | 'NEL' | 'OData-EntityId' | 'OData-Isolation' | 'OData-MaxVersion' | 'OData-Version' | 'Opt' | 'Optional-WWW-Authenticate' | 'Ordering-Type' | 'Origin' | 'Origin-Agent-Cluster' | 'OSCORE' | 'OSLC-Core-Version' | 'Overwrite' | 'P3P' | 'PEP' | 'PEP-Info' | 'Permissions-Policy' | 'PICS-Label' | 'Ping-From' | 'Ping-To' | 'Position' | 'Pragma' | 'Prefer' | 'Preference-Applied' | 'Priority' | 'ProfileObject' | 'Protocol' | 'Protocol-Info' | 'Protocol-Query' | 'Protocol-Request' | 'Proxy-Authenticate' | 'Proxy-Authentication-Info' | 'Proxy-Authorization' | 'Proxy-Features' | 'Proxy-Instruction' | 'Proxy-Status' | 'Public' | 'Public-Key-Pins' | 'Public-Key-Pins-Report-Only' | 'Range' | 'Redirect-Ref' | 'Referer' | 'Referer-Root' | 'Referrer-Policy' | 'Refresh' | 'Repeatability-Client-ID' | 'Repeatability-First-Sent' | 'Repeatability-Request-ID' | 'Repeatability-Result' | 'Replay-Nonce' | 'Reporting-Endpoints' | 'Repr-Digest' | 'Retry-After' | 'Safe' | 'Schedule-Reply' | 'Schedule-Tag' | 'Sec-GPC' | 'Sec-Purpose' | 'Sec-Token-Binding' | 'Sec-WebSocket-Accept' | 'Sec-WebSocket-Extensions' | 'Sec-WebSocket-Key' | 'Sec-WebSocket-Protocol' | 'Sec-WebSocket-Version' | 'Security-Scheme' | 'Server' | 'Server-Timing' | 'Set-Cookie' | 'Set-Cookie2' | 'SetProfile' | 'Signature' | 'Signature-Input' | 'SLUG' | 'SoapAction' | 'Status-URI' | 'Strict-Transport-Security' | 'Sunset' | 'Surrogate-Capability' | 'Surrogate-Control' | 'TCN' | 'TE' | 'Timeout' | 'Timing-Allow-Origin' | 'Topic' | 'Traceparent' | 'Tracestate' | 'Trailer' | 'Transfer-Encoding' | 'TTL' | 'Upgrade' | 'Urgency' | 'URI' | 'Use-As-Dictionary' | 'User-Agent' | 'Variant-Vary' | 'Vary' | 'Via' | 'Want-Content-Digest' | 'Want-Digest' | 'Want-Repr-Digest' | 'Warning' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options';
-type ResponseHeader = 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Age' | 'Allow' | 'Cache-Control' | 'Clear-Site-Data' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Type' | 'Cookie' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Resource-Policy' | 'Date' | 'ETag' | 'Expires' | 'Last-Modified' | 'Location' | 'Permissions-Policy' | 'Pragma' | 'Retry-After' | 'Save-Data' | 'Sec-CH-Prefers-Color-Scheme' | 'Sec-CH-Prefers-Reduced-Motion' | 'Sec-CH-UA' | 'Sec-CH-UA-Arch' | 'Sec-CH-UA-Bitness' | 'Sec-CH-UA-Form-Factor' | 'Sec-CH-UA-Full-Version' | 'Sec-CH-UA-Full-Version-List' | 'Sec-CH-UA-Mobile' | 'Sec-CH-UA-Model' | 'Sec-CH-UA-Platform' | 'Sec-CH-UA-Platform-Version' | 'Sec-CH-UA-WoW64' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-User' | 'Sec-GPC' | 'Server' | 'Server-Timing' | 'Service-Worker-Navigation-Preload' | 'Set-Cookie' | 'Strict-Transport-Security' | 'Timing-Allow-Origin' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'Vary' | 'WWW-Authenticate' | 'Warning' | 'X-Content-Type-Options' | 'X-DNS-Prefetch-Control' | 'X-Frame-Options' | 'X-Permitted-Cross-Domain-Policies' | 'X-Powered-By' | 'X-Robots-Tag' | 'X-XSS-Protection';
-type CustomHeader = string & {};
-
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? (K extends string ? T : never) : never;
-type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T;
-type JSONPrimitive = string | boolean | number | null;
-type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
-type JSONObject = {
-    [key: string]: JSONPrimitive | JSONArray | JSONObject | object | InvalidJSONValue;
-};
-type InvalidJSONValue = undefined | symbol | ((...args: unknown[]) => unknown);
-type InvalidToNull<T> = T extends InvalidJSONValue ? null : T;
-type IsInvalid<T> = T extends InvalidJSONValue ? true : false;
-/**
- * symbol keys are omitted through `JSON.stringify`
- */
-type OmitSymbolKeys<T> = {
-    [K in keyof T as K extends symbol ? never : K]: T[K];
-};
-type JSONValue = JSONObject | JSONArray | JSONPrimitive;
-/**
- * Convert a type to a JSON-compatible type.
- *
- * Non-JSON values such as `Date` implement `.toJSON()`,
- * so they can be transformed to a value assignable to `JSONObject`
- *
- * `JSON.stringify()` throws a `TypeError` when it encounters a `bigint` value,
- * unless a custom `replacer` function or `.toJSON()` method is provided.
- *
- * This behaviour can be controlled by the `TError` generic type parameter,
- * which defaults to `bigint | ReadonlyArray<bigint>`.
- * You can set it to `never` to disable this check.
- */
-type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends {
-    toJSON(): infer J;
-} ? (() => J) extends () => JSONPrimitive ? J : (() => J) extends () => {
-    toJSON(): unknown;
-} ? {} : JSONParsed<J, TError> : T extends JSONPrimitive ? T : T extends InvalidJSONValue ? never : T extends ReadonlyArray<unknown> ? {
-    [K in keyof T]: JSONParsed<InvalidToNull<T[K]>, TError>;
-} : T extends Set<unknown> | Map<unknown, unknown> | Record<string, never> ? {} : T extends object ? T[keyof T] extends TError ? never : {
-    [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true ? never : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K], TError> | undefined : JSONParsed<T[K], TError>;
-} : T extends unknown ? T extends TError ? never : JSONValue : never;
-/**
- * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
- * @copyright from sindresorhus/type-fest
- */
-type Simplify<T> = {
-    [KeyType in keyof T]: T[KeyType];
-} & {};
-type RequiredKeysOf<BaseType extends object> = Exclude<{
-    [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never;
-}[keyof BaseType], undefined>;
-type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
-type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false;
-
-/**
- * @module
- * This module contains some type definitions for the Hono modules.
- */
-
-type Bindings = object;
-type Variables = object;
-type BlankEnv = {};
-type Env = {
-    Bindings?: Bindings;
-    Variables?: Variables;
-};
-type Next = () => Promise<void>;
-type ExtractInput<I extends Input | Input['in']> = I extends Input ? unknown extends I['in'] ? {} : I['in'] : I;
-type Input = {
-    in?: {};
-    out?: {};
-    outputFormat?: ResponseFormat;
-};
-type BlankSchema = {};
-type BlankInput = {};
-interface RouterRoute {
-    basePath: string;
-    path: string;
-    method: string;
-    handler: H;
-}
-type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>> | Promise<void>;
-type Handler<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = (c: Context<E, P, I>, next: Next) => R;
-type MiddlewareHandler<E extends Env = any, P extends string = string, I extends Input = {}, R extends HandlerResponse<any> = Response> = (c: Context<E, P, I>, next: Next) => Promise<R | void>;
-type H<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = Handler<E, P, I, R> | MiddlewareHandler<E, P, I, R>;
-/**
- * You can extend this interface to define a custom `c.notFound()` Response type.
- *
- * @example
- * declare module 'hono' {
- *   interface NotFoundResponse extends Response, TypedResponse<string, 404, 'text'> {}
- * }
- */
-interface NotFoundResponse {
-}
-type NotFoundHandler<E extends Env = any> = (c: Context<E>) => NotFoundResponse extends Response ? NotFoundResponse | Promise<NotFoundResponse> : Response | Promise<Response>;
-interface HTTPResponseError extends Error {
-    getResponse: () => Response;
-}
-type ErrorHandler<E extends Env = any> = (err: Error | HTTPResponseError, c: Context<E>) => Response | Promise<Response>;
-interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = '/', CurrentPath extends string = BasePath> {
-    <P extends string = CurrentPath, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono$1<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath, CurrentPath>;
-    <P extends string = CurrentPath, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, M1 extends H<E2, P, I> = H<E2, P, I>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, P, I2, MergeTypedResponse<R> | MergeMiddlewareResponse<M1>>, BasePath, CurrentPath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R>, S, M, P, I, BasePath>, BasePath, MergePath<BasePath, P>>;
-    <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, P, I3, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>>, BasePath, CurrentPath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2, R>]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1>, S, M, P, I2, BasePath>, BasePath, MergePath<BasePath, P>>;
-    <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, 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]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3> & M3, H<E5, P, I4, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, P, I4, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>>, BasePath, CurrentPath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3, R>]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>, S, M, P, I3, BasePath>, BasePath, MergePath<BasePath, P>>;
-    <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, 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]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>>(...handlers: [
-        H<E2, P, I> & M1,
-        H<E3, P, I2> & M2,
-        H<E4, P, I3> & M3,
-        H<E5, P, I4> & M4,
-        H<E6, P, I5, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, P, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, BasePath, CurrentPath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, 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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>>(path: P, ...handlers: [
-        H<E2, MergedPath, I> & M1,
-        H<E3, MergedPath, I2> & M2,
-        H<E4, MergedPath, I3> & M3,
-        H<E5, MergedPath, I4, R>
-    ]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>, S, M, P, I4, BasePath>, BasePath, MergePath<BasePath, P>>;
-    <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>, M5 extends H<E6, P, I5> = H<E6, P, I5>>(...handlers: [
-        H<E2, P, I> & M1,
-        H<E3, P, I2> & M2,
-        H<E4, P, I3> & M3,
-        H<E5, P, I4> & M4,
-        H<E6, P, I5> & M5,
-        H<E7, P, I6, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, P, I6, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>>, BasePath, CurrentPath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, 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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>>(path: P, ...handlers: [
-        H<E2, MergedPath, I> & M1,
-        H<E3, MergedPath, I2> & M2,
-        H<E4, MergedPath, I3> & M3,
-        H<E5, MergedPath, I4> & M4,
-        H<E6, MergedPath, I5, R>
-    ]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>, S, M, P, I5, BasePath>, BasePath, MergePath<BasePath, P>>;
-    <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>, M5 extends H<E6, P, I5> = H<E6, P, I5>, M6 extends H<E7, P, I6> = H<E7, P, I6>>(...handlers: [
-        H<E2, P, I> & M1,
-        H<E3, P, I2> & M2,
-        H<E4, P, I3> & M3,
-        H<E5, P, I4> & M4,
-        H<E6, P, I5> & M5,
-        H<E7, P, I6> & M6,
-        H<E8, P, I7, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, P, I7, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>>, BasePath, CurrentPath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>>(path: P, ...handlers: [
-        H<E2, MergedPath, I> & M1,
-        H<E3, MergedPath, I2> & M2,
-        H<E4, MergedPath, I3> & M3,
-        H<E5, MergedPath, I4> & M4,
-        H<E6, MergedPath, I5> & M5,
-        H<E7, MergedPath, I6, R>
-    ]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>, S, M, P, I6, BasePath>, BasePath, MergePath<BasePath, P>>;
-    <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>, M5 extends H<E6, P, I5> = H<E6, P, I5>, M6 extends H<E7, P, I6> = H<E7, P, I6>, M7 extends H<E8, P, I7> = H<E8, P, I7>>(...handlers: [
-        H<E2, P, I> & M1,
-        H<E3, P, I2> & M2,
-        H<E4, P, I3> & M3,
-        H<E5, P, I4> & M4,
-        H<E6, P, I5> & M5,
-        H<E7, P, I6> & M6,
-        H<E8, P, I7> & M7,
-        H<E9, P, I8, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, P, I8, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7>>, BasePath, CurrentPath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>>(path: P, ...handlers: [
-        H<E2, MergedPath, I> & M1,
-        H<E3, MergedPath, I2> & M2,
-        H<E4, MergedPath, I3> & M3,
-        H<E5, MergedPath, I4> & M4,
-        H<E6, MergedPath, I5> & M5,
-        H<E7, MergedPath, I6> & M6,
-        H<E8, MergedPath, I7, R>
-    ]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>, S, M, P, I7, BasePath>, BasePath, MergePath<BasePath, P>>;
-    <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>, M5 extends H<E6, P, I5> = H<E6, P, I5>, M6 extends H<E7, P, I6> = H<E7, P, I6>, M7 extends H<E8, P, I7> = H<E8, P, I7>, M8 extends H<E9, P, I8> = H<E9, P, I8>>(...handlers: [
-        H<E2, P, I> & M1,
-        H<E3, P, I2> & M2,
-        H<E4, P, I3> & M3,
-        H<E5, P, I4> & M4,
-        H<E6, P, I5> & M5,
-        H<E7, P, I6> & M6,
-        H<E8, P, I7> & M7,
-        H<E9, P, I8> & M8,
-        H<E10, P, I9, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, P, I9, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8>>, BasePath, CurrentPath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>>(path: P, ...handlers: [
-        H<E2, MergedPath, I> & M1,
-        H<E3, MergedPath, I2> & M2,
-        H<E4, MergedPath, I3> & M3,
-        H<E5, MergedPath, I4> & M4,
-        H<E6, MergedPath, I5> & M5,
-        H<E7, MergedPath, I6> & M6,
-        H<E8, MergedPath, I7> & M7,
-        H<E9, MergedPath, I8, R>
-    ]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7>, S, M, P, I8, BasePath>, BasePath, MergePath<BasePath, P>>;
-    <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>, M5 extends H<E6, P, I5> = H<E6, P, I5>, M6 extends H<E7, P, I6> = H<E7, P, I6>, M7 extends H<E8, P, I7> = H<E8, P, I7>, M8 extends H<E9, P, I8> = H<E9, P, I8>, M9 extends H<E10, P, I9> = H<E10, P, I9>>(...handlers: [
-        H<E2, P, I> & M1,
-        H<E3, P, I2> & M2,
-        H<E4, P, I3> & M3,
-        H<E5, P, I4> & M4,
-        H<E6, P, I5> & M5,
-        H<E7, P, I6> & M6,
-        H<E8, P, I7> & M7,
-        H<E9, P, I8> & M8,
-        H<E10, P, I9> & M9,
-        H<E11, P, I10, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, P, I10, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8> | MergeMiddlewareResponse<M9>>, BasePath, CurrentPath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>, M8 extends H<E9, MergedPath, I8> = H<E9, MergedPath, I8>>(path: P, ...handlers: [
-        H<E2, MergedPath, I> & M1,
-        H<E3, MergedPath, I2> & M2,
-        H<E4, MergedPath, I3> & M3,
-        H<E5, MergedPath, I4> & M4,
-        H<E6, MergedPath, I5> & M5,
-        H<E7, MergedPath, I6> & M6,
-        H<E8, MergedPath, I7> & M7,
-        H<E9, MergedPath, I8> & M8,
-        H<E10, MergedPath, I9, R>
-    ]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8>, S, M, P, I9, BasePath>, BasePath, MergePath<BasePath, P>>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>, M8 extends H<E9, MergedPath, I8> = H<E9, MergedPath, I8>, M9 extends H<E10, MergedPath, I9> = H<E10, MergedPath, I9>>(path: P, ...handlers: [
-        H<E2, MergedPath, I> & M1,
-        H<E3, MergedPath, I2> & M2,
-        H<E4, MergedPath, I3> & M3,
-        H<E5, MergedPath, I4> & M4,
-        H<E6, MergedPath, I5> & M5,
-        H<E7, MergedPath, I6> & M6,
-        H<E8, MergedPath, I7> & M7,
-        H<E9, MergedPath, I8> & M8,
-        H<E10, MergedPath, I9> & M9,
-        H<E11, MergedPath, I10, R>
-    ]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8> | MergeMiddlewareResponse<M9>, S, M, P, I10, BasePath>, BasePath, MergePath<BasePath, P>>;
-    <P extends string = CurrentPath, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(...handlers: H<E, P, I, R>[]): Hono$1<E, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath, CurrentPath>;
-    <P extends string, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(path: P, ...handlers: [H<E, MergePath<BasePath, P>, I, R>, ...H<E, MergePath<BasePath, P>, I, R>[]]): Hono$1<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(path: P): Hono$1<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-}
-interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
-    <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, '*'>>[]): Hono$1<IntersectNonAnyTypes<[E, E2]>, S, BasePath, MergePath<BasePath, '*'>>;
-    <E2 extends Env = E>(handler: MiddlewareHandler<E2, MergePath<BasePath, '*'>>): Hono$1<IntersectNonAnyTypes<[E, E2]>, S, BasePath, MergePath<BasePath, '*'>>;
-    <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, P extends string = MergePath<BasePath, '*'>>(...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3]>, S, BasePath, P>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E>(path: P, handler: MiddlewareHandler<E2, MergedPath, any, any>): Hono$1<IntersectNonAnyTypes<[E, E2]>, S, BasePath, MergedPath>;
-    <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, P extends string = MergePath<BasePath, '*'>>(...handlers: [
-        MiddlewareHandler<E2, P, any, any>,
-        MiddlewareHandler<E3, P, any, any>,
-        MiddlewareHandler<E4, P, any, any>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4]>, S, BasePath, P>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(path: P, ...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3]>, S, BasePath, MergedPath>;
-    <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]>, P extends string = MergePath<BasePath, '*'>>(...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S, BasePath, P>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>, MiddlewareHandler<E4, P>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4]>, S, BasePath, MergedPath>;
-    <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]>, P extends string = MergePath<BasePath, '*'>>(...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>,
-        MiddlewareHandler<E6, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S, BasePath, P>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, 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]>>(path: P, ...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S, BasePath, MergedPath>;
-    <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]>, P extends string = MergePath<BasePath, '*'>>(...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>,
-        MiddlewareHandler<E6, P>,
-        MiddlewareHandler<E7, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S, BasePath, P>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, 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]>>(path: P, ...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>,
-        MiddlewareHandler<E6, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S, BasePath, MergedPath>;
-    <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]>, P extends string = MergePath<BasePath, '*'>>(...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>,
-        MiddlewareHandler<E6, P>,
-        MiddlewareHandler<E7, P>,
-        MiddlewareHandler<E8, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S, BasePath, P>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, 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]>>(path: P, ...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>,
-        MiddlewareHandler<E6, P>,
-        MiddlewareHandler<E7, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S, BasePath, MergedPath>;
-    <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]>, P extends string = MergePath<BasePath, '*'>>(...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>,
-        MiddlewareHandler<E6, P>,
-        MiddlewareHandler<E7, P>,
-        MiddlewareHandler<E8, P>,
-        MiddlewareHandler<E9, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S, BasePath, P>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, 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]>>(path: P, ...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>,
-        MiddlewareHandler<E6, P>,
-        MiddlewareHandler<E7, P>,
-        MiddlewareHandler<E8, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S, BasePath, MergedPath>;
-    <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]>, P extends string = MergePath<BasePath, '*'>>(...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>,
-        MiddlewareHandler<E6, P>,
-        MiddlewareHandler<E7, P>,
-        MiddlewareHandler<E8, P>,
-        MiddlewareHandler<E9, P>,
-        MiddlewareHandler<E10, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S, BasePath, P>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, 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]>>(path: P, ...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>,
-        MiddlewareHandler<E6, P>,
-        MiddlewareHandler<E7, P>,
-        MiddlewareHandler<E8, P>,
-        MiddlewareHandler<E9, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S, BasePath, MergedPath>;
-    <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]>, P extends string = MergePath<BasePath, '*'>>(...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>,
-        MiddlewareHandler<E6, P>,
-        MiddlewareHandler<E7, P>,
-        MiddlewareHandler<E8, P>,
-        MiddlewareHandler<E9, P>,
-        MiddlewareHandler<E10, P>,
-        MiddlewareHandler<E11, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S, BasePath, P>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, 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]>>(path: P, ...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>,
-        MiddlewareHandler<E5, P>,
-        MiddlewareHandler<E6, P>,
-        MiddlewareHandler<E7, P>,
-        MiddlewareHandler<E8, P>,
-        MiddlewareHandler<E9, P>,
-        MiddlewareHandler<E10, P>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S, BasePath, MergedPath>;
-    <P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono$1<E, S, BasePath, MergePath<BasePath, P>>;
-}
-interface OnHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(method: M, path: P, handler: H<E2, MergedPath, I, R>): Hono$1<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, 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]>>(method: M, path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, 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]>>(method: M, path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>>(method: M, path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>>(method: M, path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>>(method: M, path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>>(method: M, path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8>,
-        H<E10, MergedPath, I9, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>>(method: M, path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8>,
-        H<E10, MergedPath, I9>,
-        H<E11, MergedPath, I10, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(method: M, path: P, ...handlers: [H<E, MergePath<BasePath, P>, I, R>, ...H<E, MergePath<BasePath, P>, I, R>[]]): Hono$1<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(methods: M[], path: P, handler: H<E2, MergedPath, I, R>): Hono$1<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(methods: M[], path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(methods: M[], path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, 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]>>(methods: M[], path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, 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]>>(methods: M[], path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>>(methods: M[], path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>>(methods: M[], path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>>(methods: M[], path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>>(methods: M[], path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8>,
-        H<E10, MergedPath, I9, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<HandlerResponse<any>>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, 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, 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]>>(methods: M[], path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8>,
-        H<E10, MergedPath, I9>,
-        H<E11, MergedPath, I10, R>
-    ]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(methods: M[], path: P, ...handlers: [H<E, MergePath<BasePath, P>, I, R>, ...H<E, MergePath<BasePath, P>, I, R>[]]): Hono$1<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
-    <M extends string, const Ps extends string[], I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(methods: M | M[], paths: Ps, ...handlers: H<E2, MergePath<BasePath, Ps[number]>, I, R>[]): Hono$1<E, S & ToSchema<M, MergePath<BasePath, Ps[number]>, I, MergeTypedResponse<R>>, BasePath, Ps extends [...string[], infer LastPath extends string] ? MergePath<BasePath, LastPath> : never>;
-}
-type ToSchemaOutput<RorO, I extends Input | Input['in']> = RorO extends TypedResponse<infer T, infer U, infer F> ? {
-    output: unknown extends T ? {} : T;
-    outputFormat: I extends {
-        outputFormat: string;
-    } ? I['outputFormat'] : F;
-    status: U;
-} : {
-    output: unknown extends RorO ? {} : RorO;
-    outputFormat: unknown extends RorO ? 'json' : I extends {
-        outputFormat: string;
-    } ? I['outputFormat'] : 'json';
-    status: StatusCode;
-};
-type ToSchema<M extends string, P extends string, I extends Input | Input['in'], RorO> = IsAny<RorO> extends true ? {
-    [K in P]: {
-        [K2 in M as AddDollar<K2>]: {
-            input: AddParam<ExtractInput<I>, P>;
-            output: {};
-            outputFormat: ResponseFormat;
-            status: StatusCode;
-        };
-    };
-} : [RorO] extends [never] ? {} : [RorO] extends [Promise<void>] ? {} : {
-    [K in P]: {
-        [K2 in M as AddDollar<K2>]: Simplify<{
-            input: AddParam<ExtractInput<I>, P>;
-        } & ToSchemaOutput<RorO, I>>;
-    };
-};
-type Schema = {
-    [Path: string]: {
-        [Method: `$${Lowercase<string>}`]: Endpoint;
-    };
-};
-type AddSchemaIfHasResponse<Merged, S extends Schema, M extends string, P extends string, I extends Input | Input['in'], BasePath extends string> = [Merged] extends [Promise<void>] ? S : S & ToSchema<M, MergePath<BasePath, P>, I, Merged>;
-type Endpoint = {
-    input: any;
-    output: any;
-    outputFormat: ResponseFormat;
-    status: StatusCode;
-};
-type ExtractParams<Path extends string> = string extends Path ? Record<string, string> : Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
-    [K in Param | keyof ExtractParams<`/${Rest}`>]: string;
-} : Path extends `${infer _Start}:${infer Param}` ? {
-    [K in Param]: string;
-} : never;
-type FlattenIfIntersect<T> = T extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string> = {
-    [P in keyof OrigSchema as MergePath<SubPath, P & string>]: [OrigSchema[P]] extends [
-        Record<string, Endpoint>
-    ] ? {
-        [M in keyof OrigSchema[P]]: MergeEndpointParamsWithPath<OrigSchema[P][M], SubPath>;
-    } : never;
-};
-type MergeEndpointParamsWithPath<T extends Endpoint, SubPath extends string> = T extends unknown ? {
-    input: T['input'] extends {
-        param: infer _;
-    } ? ExtractParams<SubPath> extends never ? T['input'] : FlattenIfIntersect<T['input'] & {
-        param: {
-            [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
-        };
-    }> : RemoveBlankRecord<ExtractParams<SubPath>> extends never ? T['input'] : T['input'] & {
-        param: {
-            [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
-        };
-    };
-    output: T['output'];
-    outputFormat: T['outputFormat'];
-    status: T['status'];
-} : never;
-type AddParam<I, P extends string> = ParamKeys<P> extends never ? I : I extends {
-    param: infer _;
-} ? I : I & {
-    param: UnionToIntersection<ParamKeyToRecord<ParamKeys<P>>>;
-};
-type AddDollar<T extends string> = `$${Lowercase<T>}`;
-type MergePath<A extends string, B extends string> = B extends '' ? MergePath<A, '/'> : A extends '' ? B : A extends '/' ? B : A extends `${infer P}/` ? B extends `/${infer Q}` ? `${P}/${Q}` : `${P}/${B}` : B extends `/${infer Q}` ? Q extends '' ? A : `${A}/${Q}` : `${A}/${B}`;
-type KnownResponseFormat = 'json' | 'text' | 'redirect';
-type ResponseFormat = KnownResponseFormat | string;
-type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = T extends string ? 'text' : T extends JSONValue ? 'json' : ResponseFormat> = {
-    _data: T;
-    _status: U;
-    _format: F;
-};
-type MergeTypedResponse<T> = T extends Promise<void> ? T : T extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : TypedResponse : T extends TypedResponse ? T : TypedResponse;
-type ExtractTypedResponseOnly<T> = T extends TypedResponse ? T : never;
-type MergeMiddlewareResponse<T> = T extends (c: any, next: any) => Promise<infer R> ? Exclude<R, void> extends never ? never : Exclude<R, void> extends Response | TypedResponse<any, any, any> ? ExtractTypedResponseOnly<Exclude<R, void>> : never : T extends (c: any, next: any) => infer R ? R extends Response | TypedResponse<any, any, any> ? ExtractTypedResponseOnly<R> : never : never;
-type FormValue = string | Blob;
-type ParsedFormValue = string | File;
-type ValidationTargets<T extends FormValue = ParsedFormValue, P extends string = string> = {
-    json: any;
-    form: Record<string, T | T[]>;
-    query: Record<string, string | string[]>;
-    param: Record<P, P extends `${infer _}?` ? string | undefined : string>;
-    header: Record<RequestHeader | CustomHeader, string>;
-    cookie: Record<string, string>;
-};
-type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? NameWithPattern extends `${infer Name}{${infer Rest}` ? Rest extends `${infer _Pattern}?` ? `${Name}?` : Name : NameWithPattern : never;
-type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
-type ParamKeyToRecord<T extends string> = T extends `${infer R}?` ? Record<R, string | undefined> : {
-    [K in T]: string;
-};
-type InputToDataByTarget<T extends Input['out'], Target extends keyof ValidationTargets> = T extends {
-    [K in Target]: infer R;
-} ? R : never;
-type RemoveQuestion<T> = T extends `${infer R}?` ? R : T;
-type ProcessHead<T> = IfAnyThenEmptyObject<T extends Env ? (Env extends T ? {} : T) : T>;
-type IntersectNonAnyTypes<T extends any[]> = T extends [infer Head, ...infer Rest] ? ProcessHead<Head> & IntersectNonAnyTypes<Rest> : {};
-declare abstract class FetchEventLike {
-    abstract readonly request: Request;
-    abstract respondWith(promise: Response | Promise<Response>): void;
-    abstract passThroughOnException(): void;
-    abstract waitUntil(promise: Promise<void>): void;
-}
-
-/**
- * @module
- * Body utility.
- */
-
-type BodyDataValueDot = {
-    [x: string]: string | File | BodyDataValueDot;
-};
-type BodyDataValueDotAll = {
-    [x: string]: string | File | (string | File)[] | BodyDataValueDotAll;
-};
-type SimplifyBodyData<T> = {
-    [K in keyof T]: string | File | (string | File)[] | BodyDataValueDotAll extends T[K] ? string | File | (string | File)[] | BodyDataValueDotAll : string | File | BodyDataValueDot extends T[K] ? string | File | BodyDataValueDot : string | File | (string | File)[] extends T[K] ? string | File | (string | File)[] : string | File;
-} & {};
-type BodyDataValueComponent<T> = string | File | (T extends {
-    all: false;
-} ? never : T extends {
-    all: true;
-} | {
-    all: boolean;
-} ? (string | File)[] : never);
-type BodyDataValueObject<T> = {
-    [key: string]: BodyDataValueComponent<T> | BodyDataValueObject<T>;
-};
-type BodyDataValue<T> = BodyDataValueComponent<T> | (T extends {
-    dot: false;
-} ? never : T extends {
-    dot: true;
-} | {
-    dot: boolean;
-} ? BodyDataValueObject<T> : never);
-type BodyData<T extends Partial<ParseBodyOptions> = {}> = SimplifyBodyData<Record<string, BodyDataValue<T>>>;
-type ParseBodyOptions = {
-    /**
-     * Determines whether all fields with multiple values should be parsed as arrays.
-     * @default false
-     * @example
-     * const data = new FormData()
-     * data.append('file', 'aaa')
-     * data.append('file', 'bbb')
-     * data.append('message', 'hello')
-     *
-     * If all is false:
-     * parseBody should return { file: 'bbb', message: 'hello' }
-     *
-     * If all is true:
-     * parseBody should return { file: ['aaa', 'bbb'], message: 'hello' }
-     */
-    all: boolean;
-    /**
-     * Determines whether all fields with dot notation should be parsed as nested objects.
-     * @default false
-     * @example
-     * const data = new FormData()
-     * data.append('obj.key1', 'value1')
-     * data.append('obj.key2', 'value2')
-     *
-     * If dot is false:
-     * parseBody should return { 'obj.key1': 'value1', 'obj.key2': 'value2' }
-     *
-     * If dot is true:
-     * parseBody should return { obj: { key1: 'value1', key2: 'value2' } }
-     */
-    dot: boolean;
-};
-
-type Body = {
-    json: any;
-    text: string;
-    arrayBuffer: ArrayBuffer;
-    blob: Blob;
-    formData: FormData;
-};
-type BodyCache = Partial<Body>;
-declare class HonoRequest$1<P extends string = '/', I extends Input['out'] = {}> {
-             
-    /**
-     * `.raw` can get the raw Request object.
-     *
-     * @see {@link https://hono.dev/docs/api/request#raw}
-     *
-     * @example
-     * ```ts
-     * // For Cloudflare Workers
-     * app.post('/', async (c) => {
-     *   const metadata = c.req.raw.cf?.hostMetadata?
-     *   ...
-     * })
-     * ```
-     */
-    raw: Request;
-    routeIndex: number;
-    /**
-     * `.path` can get the pathname of the request.
-     *
-     * @see {@link https://hono.dev/docs/api/request#path}
-     *
-     * @example
-     * ```ts
-     * app.get('/about/me', (c) => {
-     *   const pathname = c.req.path // `/about/me`
-     * })
-     * ```
-     */
-    path: string;
-    bodyCache: BodyCache;
-    constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
-    /**
-     * `.req.param()` gets the path parameters.
-     *
-     * @see {@link https://hono.dev/docs/api/routing#path-parameter}
-     *
-     * @example
-     * ```ts
-     * const name = c.req.param('name')
-     * // or all parameters at once
-     * const { id, comment_id } = c.req.param()
-     * ```
-     */
-    param<P2 extends ParamKeys<P> = ParamKeys<P>>(key: string extends P ? never : P2 extends `${infer _}?` ? never : P2): string;
-    param<P2 extends RemoveQuestion<ParamKeys<P>> = RemoveQuestion<ParamKeys<P>>>(key: P2): string | undefined;
-    param(key: string): string | undefined;
-    param<P2 extends string = P>(): Simplify<UnionToIntersection<ParamKeyToRecord<ParamKeys<P2>>>>;
-    /**
-     * `.query()` can get querystring parameters.
-     *
-     * @see {@link https://hono.dev/docs/api/request#query}
-     *
-     * @example
-     * ```ts
-     * // Query params
-     * app.get('/search', (c) => {
-     *   const query = c.req.query('q')
-     * })
-     *
-     * // Get all params at once
-     * app.get('/search', (c) => {
-     *   const { q, limit, offset } = c.req.query()
-     * })
-     * ```
-     */
-    query(key: string): string | undefined;
-    query(): Record<string, string>;
-    /**
-     * `.queries()` can get multiple querystring parameter values, e.g. /search?tags=A&tags=B
-     *
-     * @see {@link https://hono.dev/docs/api/request#queries}
-     *
-     * @example
-     * ```ts
-     * app.get('/search', (c) => {
-     *   // tags will be string[]
-     *   const tags = c.req.queries('tags')
-     * })
-     * ```
-     */
-    queries(key: string): string[] | undefined;
-    queries(): Record<string, string[]>;
-    /**
-     * `.header()` can get the request header value.
-     *
-     * @see {@link https://hono.dev/docs/api/request#header}
-     *
-     * @example
-     * ```ts
-     * app.get('/', (c) => {
-     *   const userAgent = c.req.header('User-Agent')
-     * })
-     * ```
-     */
-    header(name: RequestHeader): string | undefined;
-    header(name: string): string | undefined;
-    header(): Record<RequestHeader | (string & CustomHeader), string>;
-    /**
-     * `.parseBody()` can parse Request body of type `multipart/form-data` or `application/x-www-form-urlencoded`
-     *
-     * @see {@link https://hono.dev/docs/api/request#parsebody}
-     *
-     * @example
-     * ```ts
-     * app.post('/entry', async (c) => {
-     *   const body = await c.req.parseBody()
-     * })
-     * ```
-     */
-    parseBody<Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(options?: Options): Promise<T>;
-    parseBody<T extends BodyData>(options?: Partial<ParseBodyOptions>): Promise<T>;
-    /**
-     * `.json()` can parse Request body of type `application/json`
-     *
-     * @see {@link https://hono.dev/docs/api/request#json}
-     *
-     * @example
-     * ```ts
-     * app.post('/entry', async (c) => {
-     *   const body = await c.req.json()
-     * })
-     * ```
-     */
-    json<T = any>(): Promise<T>;
-    /**
-     * `.text()` can parse Request body of type `text/plain`
-     *
-     * @see {@link https://hono.dev/docs/api/request#text}
-     *
-     * @example
-     * ```ts
-     * app.post('/entry', async (c) => {
-     *   const body = await c.req.text()
-     * })
-     * ```
-     */
-    text(): Promise<string>;
-    /**
-     * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
-     *
-     * @see {@link https://hono.dev/docs/api/request#arraybuffer}
-     *
-     * @example
-     * ```ts
-     * app.post('/entry', async (c) => {
-     *   const body = await c.req.arrayBuffer()
-     * })
-     * ```
-     */
-    arrayBuffer(): Promise<ArrayBuffer>;
-    /**
-     * Parses the request body as a `Blob`.
-     * @example
-     * ```ts
-     * app.post('/entry', async (c) => {
-     *   const body = await c.req.blob();
-     * });
-     * ```
-     * @see https://hono.dev/docs/api/request#blob
-     */
-    blob(): Promise<Blob>;
-    /**
-     * Parses the request body as `FormData`.
-     * @example
-     * ```ts
-     * app.post('/entry', async (c) => {
-     *   const body = await c.req.formData();
-     * });
-     * ```
-     * @see https://hono.dev/docs/api/request#formdata
-     */
-    formData(): Promise<FormData>;
-    /**
-     * Adds validated data to the request.
-     *
-     * @param target - The target of the validation.
-     * @param data - The validated data to add.
-     */
-    addValidatedData(target: keyof ValidationTargets, data: {}): void;
-    /**
-     * Gets validated data from the request.
-     *
-     * @param target - The target of the validation.
-     * @returns The validated data.
-     *
-     * @see https://hono.dev/docs/api/request#valid
-     */
-    valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
-    /**
-     * `.url()` can get the request url strings.
-     *
-     * @see {@link https://hono.dev/docs/api/request#url}
-     *
-     * @example
-     * ```ts
-     * app.get('/about/me', (c) => {
-     *   const url = c.req.url // `http://localhost:8787/about/me`
-     *   ...
-     * })
-     * ```
-     */
-    get url(): string;
-    /**
-     * `.method()` can get the method name of the request.
-     *
-     * @see {@link https://hono.dev/docs/api/request#method}
-     *
-     * @example
-     * ```ts
-     * app.get('/about/me', (c) => {
-     *   const method = c.req.method // `GET`
-     * })
-     * ```
-     */
-    get method(): string;
-    get [GET_MATCH_RESULT](): Result<[unknown, RouterRoute]>;
-    /**
-     * `.matchedRoutes()` can return a matched route in the handler
-     *
-     * @deprecated
-     *
-     * Use matchedRoutes helper defined in "hono/route" instead.
-     *
-     * @see {@link https://hono.dev/docs/api/request#matchedroutes}
-     *
-     * @example
-     * ```ts
-     * app.use('*', async function logger(c, next) {
-     *   await next()
-     *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
-     *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
-     *     console.log(
-     *       method,
-     *       ' ',
-     *       path,
-     *       ' '.repeat(Math.max(10 - path.length, 0)),
-     *       name,
-     *       i === c.req.routeIndex ? '<- respond from here' : ''
-     *     )
-     *   })
-     * })
-     * ```
-     */
-    get matchedRoutes(): RouterRoute[];
-    /**
-     * `routePath()` can retrieve the path registered within the handler
-     *
-     * @deprecated
-     *
-     * Use routePath helper defined in "hono/route" instead.
-     *
-     * @see {@link https://hono.dev/docs/api/request#routepath}
-     *
-     * @example
-     * ```ts
-     * app.get('/posts/:id', (c) => {
-     *   return c.json({ path: c.req.routePath })
-     * })
-     * ```
-     */
-    get routePath(): string;
-}
-
-/**
- * Union types for BaseMime
- */
-type BaseMime = (typeof _baseMimes)[keyof typeof _baseMimes];
-declare const _baseMimes: {
-    readonly aac: "audio/aac";
-    readonly avi: "video/x-msvideo";
-    readonly avif: "image/avif";
-    readonly av1: "video/av1";
-    readonly bin: "application/octet-stream";
-    readonly bmp: "image/bmp";
-    readonly css: "text/css";
-    readonly csv: "text/csv";
-    readonly eot: "application/vnd.ms-fontobject";
-    readonly epub: "application/epub+zip";
-    readonly gif: "image/gif";
-    readonly gz: "application/gzip";
-    readonly htm: "text/html";
-    readonly html: "text/html";
-    readonly ico: "image/x-icon";
-    readonly ics: "text/calendar";
-    readonly jpeg: "image/jpeg";
-    readonly jpg: "image/jpeg";
-    readonly js: "text/javascript";
-    readonly json: "application/json";
-    readonly jsonld: "application/ld+json";
-    readonly map: "application/json";
-    readonly mid: "audio/x-midi";
-    readonly midi: "audio/x-midi";
-    readonly mjs: "text/javascript";
-    readonly mp3: "audio/mpeg";
-    readonly mp4: "video/mp4";
-    readonly mpeg: "video/mpeg";
-    readonly oga: "audio/ogg";
-    readonly ogv: "video/ogg";
-    readonly ogx: "application/ogg";
-    readonly opus: "audio/opus";
-    readonly otf: "font/otf";
-    readonly pdf: "application/pdf";
-    readonly png: "image/png";
-    readonly rtf: "application/rtf";
-    readonly svg: "image/svg+xml";
-    readonly tif: "image/tiff";
-    readonly tiff: "image/tiff";
-    readonly ts: "video/mp2t";
-    readonly ttf: "font/ttf";
-    readonly txt: "text/plain";
-    readonly wasm: "application/wasm";
-    readonly webm: "video/webm";
-    readonly weba: "audio/webm";
-    readonly webmanifest: "application/manifest+json";
-    readonly webp: "image/webp";
-    readonly woff: "font/woff";
-    readonly woff2: "font/woff2";
-    readonly xhtml: "application/xhtml+xml";
-    readonly xml: "application/xml";
-    readonly zip: "application/zip";
-    readonly '3gp': "video/3gpp";
-    readonly '3g2': "video/3gpp2";
-    readonly gltf: "model/gltf+json";
-    readonly glb: "model/gltf-binary";
-};
-
-type HeaderRecord = Record<'Content-Type', BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
-/**
- * Data type can be a string, ArrayBuffer, Uint8Array (buffer), or ReadableStream.
- */
-type Data = string | ArrayBuffer | ReadableStream | Uint8Array<ArrayBuffer>;
-/**
- * Interface for the execution context in a web worker or similar environment.
- */
-interface ExecutionContext {
-    /**
-     * Extends the lifetime of the event callback until the promise is settled.
-     *
-     * @param promise - A promise to wait for.
-     */
-    waitUntil(promise: Promise<unknown>): void;
-    /**
-     * Allows the event to be passed through to subsequent event listeners.
-     */
-    passThroughOnException(): void;
-    /**
-     * For compatibility with Wrangler 4.x.
-     */
-    props: any;
-    /**
-     * For compatibility with Wrangler 4.x.
-     */
-    exports?: any;
-}
-/**
- * Interface for context variable mapping.
- */
-interface ContextVariableMap {
-}
-/**
- * Interface for context renderer.
- */
-interface ContextRenderer {
-}
-/**
- * Interface representing a renderer for content.
- *
- * @interface DefaultRenderer
- * @param {string | Promise<string>} content - The content to be rendered, which can be either a string or a Promise resolving to a string.
- * @returns {Response | Promise<Response>} - The response after rendering the content, which can be either a Response or a Promise resolving to a Response.
- */
-interface DefaultRenderer {
-    (content: string | Promise<string>): Response | Promise<Response>;
-}
-/**
- * Renderer type which can either be a ContextRenderer or DefaultRenderer.
- */
-type Renderer = ContextRenderer extends Function ? ContextRenderer : DefaultRenderer;
-/**
- * Extracts the props for the renderer.
- */
-type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
-type Layout<T = Record<string, any>> = (props: T) => any;
-/**
- * Interface for getting context variables.
- *
- * @template E - Environment type.
- */
-interface Get<E extends Env> {
-    <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
-    <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
-}
-/**
- * Interface for setting context variables.
- *
- * @template E - Environment type.
- */
-interface Set$1<E extends Env> {
-    <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
-    <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
-}
-/**
- * Interface for creating a new response.
- */
-interface NewResponse {
-    (data: Data | null, status?: StatusCode, headers?: HeaderRecord): Response;
-    (data: Data | null, init?: ResponseOrInit): Response;
-}
-/**
- * Interface for responding with a body.
- */
-interface BodyRespond {
-    <T extends Data, U extends ContentfulStatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'body'>;
-    <T extends Data, U extends ContentfulStatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'body'>;
-    <T extends null, U extends StatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<null, U, 'body'>;
-    <T extends null, U extends StatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<null, U, 'body'>;
-}
-/**
- * Interface for responding with text.
- *
- * @interface TextRespond
- * @template T - The type of the text content.
- * @template U - The type of the status code.
- *
- * @param {T} text - The text content to be included in the response.
- * @param {U} [status] - An optional status code for the response.
- * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
- *
- * @returns {Response & TypedResponse<T, U, 'text'>} - The response after rendering the text content, typed with the provided text and status code types.
- */
-interface TextRespond {
-    <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'text'>;
-    <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'text'>;
-}
-/**
- * Interface for responding with JSON.
- *
- * @interface JSONRespond
- * @template T - The type of the JSON value or simplified unknown type.
- * @template U - The type of the status code.
- *
- * @param {T} object - The JSON object to be included in the response.
- * @param {U} [status] - An optional status code for the response.
- * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
- *
- * @returns {JSONRespondReturn<T, U>} - The response after rendering the JSON object, typed with the provided object and status code types.
- */
-interface JSONRespond {
-    <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
-    <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, init?: ResponseOrInit<U>): JSONRespondReturn<T, U>;
-}
-/**
- * @template T - The type of the JSON value or simplified unknown type.
- * @template U - The type of the status code.
- *
- * @returns {Response & TypedResponse<JSONParsed<T>, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
- */
-type JSONRespondReturn<T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<JSONParsed<T>, U, 'json'>;
-/**
- * Interface representing a function that responds with HTML content.
- *
- * @param html - The HTML content to respond with, which can be a string or a Promise that resolves to a string.
- * @param status - (Optional) The HTTP status code for the response.
- * @param headers - (Optional) A record of headers to include in the response.
- * @param init - (Optional) The response initialization object.
- *
- * @returns A Response object or a Promise that resolves to a Response object.
- */
-interface HTMLRespond {
-    <T extends string | Promise<string>>(html: T, status?: ContentfulStatusCode, headers?: HeaderRecord): T extends string ? Response : Promise<Response>;
-    <T extends string | Promise<string>>(html: T, init?: ResponseOrInit<ContentfulStatusCode>): T extends string ? Response : Promise<Response>;
-}
-/**
- * Options for configuring the context.
- *
- * @template E - Environment type.
- */
-type ContextOptions<E extends Env> = {
-    /**
-     * Bindings for the environment.
-     */
-    env: E['Bindings'];
-    /**
-     * Execution context for the request.
-     */
-    executionCtx?: FetchEventLike | ExecutionContext | undefined;
-    /**
-     * Handler for not found responses.
-     */
-    notFoundHandler?: NotFoundHandler<E>;
-    matchResult?: Result<[H, RouterRoute]>;
-    path?: string;
-};
-interface SetHeadersOptions {
-    append?: boolean;
-}
-interface SetHeaders {
-    (name: 'Content-Type', value?: BaseMime, options?: SetHeadersOptions): void;
-    (name: ResponseHeader, value?: string, options?: SetHeadersOptions): void;
-    (name: string, value?: string, options?: SetHeadersOptions): void;
-}
-type ResponseHeadersInit = [string, string][] | Record<'Content-Type', BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
-interface ResponseInit<T extends StatusCode = StatusCode> {
-    headers?: ResponseHeadersInit;
-    status?: T;
-    statusText?: string;
-}
-type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit<T> | Response;
-declare class Context<E extends Env = any, P extends string = any, I extends Input = {}> {
-             
-    /**
-     * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
-     *
-     * @see {@link https://hono.dev/docs/api/context#env}
-     *
-     * @example
-     * ```ts
-     * // Environment object for Cloudflare Workers
-     * app.get('*', async c => {
-     *   const counter = c.env.COUNTER
-     * })
-     * ```
-     */
-    env: E['Bindings'];
-    finalized: boolean;
-    /**
-     * `.error` can get the error object from the middleware if the Handler throws an error.
-     *
-     * @see {@link https://hono.dev/docs/api/context#error}
-     *
-     * @example
-     * ```ts
-     * app.use('*', async (c, next) => {
-     *   await next()
-     *   if (c.error) {
-     *     // do something...
-     *   }
-     * })
-     * ```
-     */
-    error: Error | undefined;
-    /**
-     * Creates an instance of the Context class.
-     *
-     * @param req - The Request object.
-     * @param options - Optional configuration options for the context.
-     */
-    constructor(req: Request, options?: ContextOptions<E>);
-    /**
-     * `.req` is the instance of {@link HonoRequest}.
-     */
-    get req(): HonoRequest$1<P, I['out']>;
-    /**
-     * @see {@link https://hono.dev/docs/api/context#event}
-     * The FetchEvent associated with the current request.
-     *
-     * @throws Will throw an error if the context does not have a FetchEvent.
-     */
-    get event(): FetchEventLike;
-    /**
-     * @see {@link https://hono.dev/docs/api/context#executionctx}
-     * The ExecutionContext associated with the current request.
-     *
-     * @throws Will throw an error if the context does not have an ExecutionContext.
-     */
-    get executionCtx(): ExecutionContext;
-    /**
-     * @see {@link https://hono.dev/docs/api/context#res}
-     * The Response object for the current request.
-     */
-    get res(): Response;
-    /**
-     * Sets the Response object for the current request.
-     *
-     * @param _res - The Response object to set.
-     */
-    set res(_res: Response | undefined);
-    /**
-     * `.render()` can create a response within a layout.
-     *
-     * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
-     *
-     * @example
-     * ```ts
-     * app.get('/', (c) => {
-     *   return c.render('Hello!')
-     * })
-     * ```
-     */
-    render: Renderer;
-    /**
-     * Sets the layout for the response.
-     *
-     * @param layout - The layout to set.
-     * @returns The layout function.
-     */
-    setLayout: (layout: Layout<PropsForRenderer & {
-        Layout: Layout;
-    }>) => Layout<PropsForRenderer & {
-        Layout: Layout;
-    }>;
-    /**
-     * Gets the current layout for the response.
-     *
-     * @returns The current layout function.
-     */
-    getLayout: () => Layout<PropsForRenderer & {
-        Layout: Layout;
-    }> | undefined;
-    /**
-     * `.setRenderer()` can set the layout in the custom middleware.
-     *
-     * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
-     *
-     * @example
-     * ```tsx
-     * app.use('*', async (c, next) => {
-     *   c.setRenderer((content) => {
-     *     return c.html(
-     *       <html>
-     *         <body>
-     *           <p>{content}</p>
-     *         </body>
-     *       </html>
-     *     )
-     *   })
-     *   await next()
-     * })
-     * ```
-     */
-    setRenderer: (renderer: Renderer) => void;
-    /**
-     * `.header()` can set headers.
-     *
-     * @see {@link https://hono.dev/docs/api/context#header}
-     *
-     * @example
-     * ```ts
-     * app.get('/welcome', (c) => {
-     *   // Set headers
-     *   c.header('X-Message', 'Hello!')
-     *   c.header('Content-Type', 'text/plain')
-     *
-     *   return c.body('Thank you for coming')
-     * })
-     * ```
-     */
-    header: SetHeaders;
-    status: (status: StatusCode) => void;
-    /**
-     * `.set()` can set the value specified by the key.
-     *
-     * @see {@link https://hono.dev/docs/api/context#set-get}
-     *
-     * @example
-     * ```ts
-     * app.use('*', async (c, next) => {
-     *   c.set('message', 'Hono is hot!!')
-     *   await next()
-     * })
-     * ```
-     */
-    set: Set$1<IsAny<E> extends true ? {
-        Variables: ContextVariableMap & Record<string, any>;
-    } : E>;
-    /**
-     * `.get()` can use the value specified by the key.
-     *
-     * @see {@link https://hono.dev/docs/api/context#set-get}
-     *
-     * @example
-     * ```ts
-     * app.get('/', (c) => {
-     *   const message = c.get('message')
-     *   return c.text(`The message is "${message}"`)
-     * })
-     * ```
-     */
-    get: Get<IsAny<E> extends true ? {
-        Variables: ContextVariableMap & Record<string, any>;
-    } : E>;
-    /**
-     * `.var` can access the value of a variable.
-     *
-     * @see {@link https://hono.dev/docs/api/context#var}
-     *
-     * @example
-     * ```ts
-     * const result = c.var.client.oneMethod()
-     * ```
-     */
-    get var(): Readonly<ContextVariableMap & (IsAny<E['Variables']> extends true ? Record<string, any> : E['Variables'])>;
-    newResponse: NewResponse;
-    /**
-     * `.body()` can return the HTTP response.
-     * You can set headers with `.header()` and set HTTP status code with `.status`.
-     * This can also be set in `.text()`, `.json()` and so on.
-     *
-     * @see {@link https://hono.dev/docs/api/context#body}
-     *
-     * @example
-     * ```ts
-     * app.get('/welcome', (c) => {
-     *   // Set headers
-     *   c.header('X-Message', 'Hello!')
-     *   c.header('Content-Type', 'text/plain')
-     *   // Set HTTP status code
-     *   c.status(201)
-     *
-     *   // Return the response body
-     *   return c.body('Thank you for coming')
-     * })
-     * ```
-     */
-    body: BodyRespond;
-    /**
-     * `.text()` can render text as `Content-Type:text/plain`.
-     *
-     * @see {@link https://hono.dev/docs/api/context#text}
-     *
-     * @example
-     * ```ts
-     * app.get('/say', (c) => {
-     *   return c.text('Hello!')
-     * })
-     * ```
-     */
-    text: TextRespond;
-    /**
-     * `.json()` can render JSON as `Content-Type:application/json`.
-     *
-     * @see {@link https://hono.dev/docs/api/context#json}
-     *
-     * @example
-     * ```ts
-     * app.get('/api', (c) => {
-     *   return c.json({ message: 'Hello!' })
-     * })
-     * ```
-     */
-    json: JSONRespond;
-    html: HTMLRespond;
-    /**
-     * `.redirect()` can Redirect, default status code is 302.
-     *
-     * @see {@link https://hono.dev/docs/api/context#redirect}
-     *
-     * @example
-     * ```ts
-     * app.get('/redirect', (c) => {
-     *   return c.redirect('/')
-     * })
-     * app.get('/redirect-permanently', (c) => {
-     *   return c.redirect('/', 301)
-     * })
-     * ```
-     */
-    redirect: <T extends RedirectStatusCode = 302>(location: string | URL, status?: T) => Response & TypedResponse<undefined, T, "redirect">;
-    /**
-     * `.notFound()` can return the Not Found Response.
-     *
-     * @see {@link https://hono.dev/docs/api/context#notfound}
-     *
-     * @example
-     * ```ts
-     * app.get('/notfound', (c) => {
-     *   return c.notFound()
-     * })
-     * ```
-     */
-    notFound: () => ReturnType<NotFoundHandler>;
-}
-
-/**
- * @module
- * This module is the base module for the Hono object.
- */
-
-type GetPath<E extends Env> = (request: Request, options?: {
-    env?: E['Bindings'];
-}) => string;
-type HonoOptions<E extends Env> = {
-    /**
-     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#strict-mode}
-     *
-     * @default true
-     */
-    strict?: boolean;
-    /**
-     * `router` option specifies which router to use.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#router-option}
-     *
-     * @example
-     * ```ts
-     * const app = new Hono({ router: new RegExpRouter() })
-     * ```
-     */
-    router?: Router<[H, RouterRoute]>;
-    /**
-     * `getPath` can handle the host header value.
-     *
-     * @see {@link https://hono.dev/docs/api/routing#routing-with-host-header-value}
-     *
-     * @example
-     * ```ts
-     * const app = new Hono({
-     *  getPath: (req) =>
-     *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
-     * })
-     *
-     * app.get('/www1.example.com/hello', () => c.text('hello www1'))
-     *
-     * // A following request will match the route:
-     * // new Request('http://www1.example.com/hello', {
-     * //  headers: { host: 'www1.example.com' },
-     * // })
-     * ```
-     */
-    getPath?: GetPath<E>;
-};
-type MountOptionHandler = (c: Context) => unknown;
-type MountReplaceRequest = (originalRequest: Request) => Request;
-type MountOptions = MountOptionHandler | {
-    optionHandler?: MountOptionHandler;
-    replaceRequest?: MountReplaceRequest | false;
-};
-declare class Hono$1<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/', CurrentPath extends string = BasePath> {
-             
-    get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
-    post: HandlerInterface<E, 'post', S, BasePath, CurrentPath>;
-    put: HandlerInterface<E, 'put', S, BasePath, CurrentPath>;
-    delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
-    options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
-    patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
-    all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
-    on: OnHandlerInterface<E, S, BasePath>;
-    use: MiddlewareHandlerInterface<E, S, BasePath>;
-    router: Router<[H, RouterRoute]>;
-    readonly getPath: GetPath<E>;
-    private _basePath;
-    routes: RouterRoute[];
-    constructor(options?: HonoOptions<E>);
-    private errorHandler;
-    /**
-     * `.route()` allows grouping other Hono instance in routes.
-     *
-     * @see {@link https://hono.dev/docs/api/routing#grouping}
-     *
-     * @param {string} path - base Path
-     * @param {Hono} app - other Hono instance
-     * @returns {Hono} routed Hono instance
-     *
-     * @example
-     * ```ts
-     * const app = new Hono()
-     * const app2 = new Hono()
-     *
-     * app2.get("/user", (c) => c.text("user"))
-     * app.route("/api", app2) // GET /api/user
-     * ```
-     */
-    route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string, SubCurrentPath extends string>(path: SubPath, app: Hono$1<SubEnv, SubSchema, SubBasePath, SubCurrentPath>): Hono$1<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> | S, BasePath, CurrentPath>;
-    /**
-     * `.basePath()` allows base paths to be specified.
-     *
-     * @see {@link https://hono.dev/docs/api/routing#base-path}
-     *
-     * @param {string} path - base Path
-     * @returns {Hono} changed Hono instance
-     *
-     * @example
-     * ```ts
-     * const api = new Hono().basePath('/api')
-     * ```
-     */
-    basePath<SubPath extends string>(path: SubPath): Hono$1<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
-    /**
-     * `.onError()` handles an error and returns a customized Response.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#error-handling}
-     *
-     * @param {ErrorHandler} handler - request Handler for error
-     * @returns {Hono} changed Hono instance
-     *
-     * @example
-     * ```ts
-     * app.onError((err, c) => {
-     *   console.error(`${err}`)
-     *   return c.text('Custom Error Message', 500)
-     * })
-     * ```
-     */
-    onError: (handler: ErrorHandler<E>) => Hono$1<E, S, BasePath, CurrentPath>;
-    /**
-     * `.notFound()` allows you to customize a Not Found Response.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#not-found}
-     *
-     * @param {NotFoundHandler} handler - request handler for not-found
-     * @returns {Hono} changed Hono instance
-     *
-     * @example
-     * ```ts
-     * app.notFound((c) => {
-     *   return c.text('Custom 404 Message', 404)
-     * })
-     * ```
-     */
-    notFound: (handler: NotFoundHandler<E>) => Hono$1<E, S, BasePath, CurrentPath>;
-    /**
-     * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#mount}
-     *
-     * @param {string} path - base Path
-     * @param {Function} applicationHandler - other Request Handler
-     * @param {MountOptions} [options] - options of `.mount()`
-     * @returns {Hono} mounted Hono instance
-     *
-     * @example
-     * ```ts
-     * import { Router as IttyRouter } from 'itty-router'
-     * import { Hono } from 'hono'
-     * // Create itty-router application
-     * const ittyRouter = IttyRouter()
-     * // GET /itty-router/hello
-     * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
-     *
-     * const app = new Hono()
-     * app.mount('/itty-router', ittyRouter.handle)
-     * ```
-     *
-     * @example
-     * ```ts
-     * const app = new Hono()
-     * // Send the request to another application without modification.
-     * app.mount('/app', anotherApp, {
-     *   replaceRequest: (req) => req,
-     * })
-     * ```
-     */
-    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono$1<E, S, BasePath, CurrentPath>;
-    /**
-     * `.fetch()` will be entry point of your app.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#fetch}
-     *
-     * @param {Request} request - request Object of request
-     * @param {Env} Env - env Object
-     * @param {ExecutionContext} - context of execution
-     * @returns {Response | Promise<Response>} response of request
-     *
-     */
-    fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-    /**
-     * `.request()` is a useful method for testing.
-     * You can pass a URL or pathname to send a GET request.
-     * app will return a Response object.
-     * ```ts
-     * test('GET /hello is ok', async () => {
-     *   const res = await app.request('/hello')
-     *   expect(res.status).toBe(200)
-     * })
-     * ```
-     * @see https://hono.dev/docs/api/hono#request
-     */
-    request: (input: Request | string | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-    /**
-     * `.fire()` automatically adds a global fetch event listener.
-     * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
-     * @deprecated
-     * Use `fire` from `hono/service-worker` instead.
-     * ```ts
-     * import { Hono } from 'hono'
-     * import { fire } from 'hono/service-worker'
-     *
-     * const app = new Hono()
-     * // ...
-     * fire(app)
-     * ```
-     * @see https://hono.dev/docs/api/hono#fire
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
-     * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
-     */
-    fire: () => void;
-}
-
-/**
- * The Hono class extends the functionality of the HonoBase class.
- * It sets up routing and allows for custom options to be passed.
- *
- * @template E - The environment type.
- * @template S - The schema type.
- * @template BasePath - The base path type.
- */
-declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends Hono$1<E, S, BasePath> {
-    /**
-     * Creates an instance of the Hono class.
-     *
-     * @param options - Optional configuration options for the Hono instance.
-     */
-    constructor(options?: HonoOptions<E>);
-}
-
-/**
- * Type representing the '$all' method name
- */
-type MethodNameAll = `$${typeof METHOD_NAME_ALL_LOWERCASE}`;
-/**
- * Type representing all standard HTTP methods prefixed with '$'
- * e.g., '$get' | '$post' | '$put' | '$delete' | '$options' | '$patch'
- */
-type StandardMethods = `$${(typeof METHODS)[number]}`;
-/**
- * Expands '$all' into all standard HTTP methods.
- * 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 BuildSearchParamsFn = (query: Record<string, string | string[]>) => URLSearchParams;
-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;
-} & (keyof T extends never ? {
-    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
-} : {
-    headers: T | (() => T | Promise<T>);
-});
-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';
-} ? S['$get'] extends {
-    input: infer I;
-} ? {
-    $ws: (args?: I) => WebSocket;
-} : {} : {});
-type ClientResponseOfEndpoint<T extends Endpoint = Endpoint> = T extends {
-    output: infer O;
-    outputFormat: infer F;
-    status: infer S;
-} ? ClientResponse<O, S extends number ? S : never, F extends ResponseFormat ? F : never> : never;
-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$1;
-    clone(): Response$1;
-    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 BuildPathname<P extends string, Arg> = Arg extends {
-    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'>>;
-type HonoURL<Prefix extends string, Path extends string, Arg> = IsLiteral<Prefix> extends true ? TrimEndSlash<Prefix> extends `${infer Protocol}://${infer Rest}` ? Rest extends `${infer Hostname}/${infer P}` ? ParseHostName<Hostname> extends [infer Host extends string, infer Port extends string] ? BuildTypedURL<Protocol, Host, Port, P, Arg> : never : ParseHostName<Rest> extends [infer Host extends string, infer Port extends string] ? BuildTypedURL<Protocol, Host, Port, Path, Arg> : never : URL : URL;
-type ParseHostName<T extends string> = T extends `${infer Host}:${infer Port}` ? [Host, Port] : [T, ''];
-type TrimStartSlash<T extends string> = T extends `/${infer R}` ? TrimStartSlash<R> : T;
-type TrimEndSlash<T extends string> = T extends `${infer R}/` ? TrimEndSlash<R> : T;
-type IsLiteral<T extends string> = [T] extends [never] ? false : string extends T ? false : true;
-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;
-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}`;
-}
-interface Response$1 extends ClientResponse<unknown> {
-}
-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>;
-};
-type Client<T, Prefix extends string> = T extends Hono$1<any, infer S, any> ? S extends Record<infer K, Schema> ? K extends string ? PathToChain<Prefix, K, S> : never : never : never;
-
-declare const hc: <T extends Hono<any, any, any>, Prefix extends string = string>(baseUrl: Prefix, options?: ClientRequestOptions) => UnionToIntersection<Client<T, Prefix>>;
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import * as hono_client from 'hono/client';
+import { hc } from 'hono/client';
+export { signPayload, verifyPayloadSignature } from '@develit-io/backend-sdk/signature';
 
 declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
     v1: {
         auth: {
-            token: ClientRequest<string, "/v1/auth/token", {
+            token: hono_client.ClientRequest<string, "/v1/auth/token", {
                 $post: {
                     input: {
                         json: {
@@ -2006,7 +41,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
     v1: {
         auth: {
             token: {
-                refresh: ClientRequest<string, "/v1/auth/token/refresh", {
+                refresh: hono_client.ClientRequest<string, "/v1/auth/token/refresh", {
                     $put: {
                         input: {
                             json: {
@@ -2040,7 +75,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
     v1: {
         bank: {
             auth: {
-                "get-auth-uri": ClientRequest<string, "/v1/bank/auth/get-auth-uri", {
+                "get-auth-uri": hono_client.ClientRequest<string, "/v1/bank/auth/get-auth-uri", {
                     $get: {
                         input: {
                             query: {
@@ -2072,7 +107,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
 } & {
     v1: {
         bank: {
-            callback: ClientRequest<string, "/v1/bank/callback", {
+            callback: hono_client.ClientRequest<string, "/v1/bank/callback", {
                 $get: {
                     input: {
                         query: {
@@ -2131,7 +166,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
 } & {
     v1: {
         observability: {
-            "health-check": ClientRequest<string, "/v1/observability/health-check", {
+            "health-check": hono_client.ClientRequest<string, "/v1/observability/health-check", {
                 $get: {
                     input: {};
                     output: {
@@ -2145,15 +180,11 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
     };
 } & {
     v1: {
-        organization: ClientRequest<string, "/v1/organization", {
+        organization: hono_client.ClientRequest<string, "/v1/organization", {
             $get: {
                 input: {};
                 output: {
                     message: string;
-                    balance: {
-                        amount: number;
-                        currency: string;
-                    };
                     organization: {
                         id: string;
                         name: string;
@@ -2195,7 +226,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
     v1: {
         organizations: {
             ":id": {
-                accounts: ClientRequest<string, "/v1/organizations/:id/accounts", {
+                accounts: hono_client.ClientRequest<string, "/v1/organizations/:id/accounts", {
                     $get: {
                         input: {
                             param: {
@@ -2280,7 +311,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
     v1: {
         organizations: {
             ":id": {
-                payments: ClientRequest<string, "/v1/organizations/:id/payments", {
+                payments: hono_client.ClientRequest<string, "/v1/organizations/:id/payments", {
                     $get: {
                         input: {
                             param: {
@@ -2293,7 +324,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                             query: {
                                 page?: string | undefined;
                                 limit?: string | undefined;
-                                sortColumn?: "amount" | "createdAt" | "updatedAt" | undefined;
+                                sortColumn?: "createdAt" | "updatedAt" | "amount" | undefined;
                                 sortDirection?: "asc" | "desc" | undefined;
                                 filterStatus?: "PENDING" | "PROCESSING" | "BOOKED" | "CANCELLED" | "REJECTED" | "SCHEDULED" | "HOLD" | "INFO" | ("PENDING" | "PROCESSING" | "BOOKED" | "CANCELLED" | "REJECTED" | "SCHEDULED" | "HOLD" | "INFO")[] | undefined;
                                 filterPaymentType?: "DOMESTIC" | "DOMESTIC"[] | undefined;
@@ -2335,7 +366,13 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                     iban?: string | undefined;
                                     bankCode?: string | undefined;
                                     swiftBic?: string | undefined;
-                                    address?: string | undefined;
+                                    address?: {
+                                        streetName?: string | undefined;
+                                        buildingNumber?: string | undefined;
+                                        city?: string | undefined;
+                                        postalCode?: string | undefined;
+                                        countryCode?: string | undefined;
+                                    } | undefined;
                                 };
                                 dates: {
                                     created: string | null;
@@ -2379,7 +416,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                             query: {
                                 page?: string | undefined;
                                 limit?: string | undefined;
-                                sortColumn?: "amount" | "createdAt" | "updatedAt" | undefined;
+                                sortColumn?: "createdAt" | "updatedAt" | "amount" | undefined;
                                 sortDirection?: "asc" | "desc" | undefined;
                                 filterStatus?: "PENDING" | "PROCESSING" | "BOOKED" | "CANCELLED" | "REJECTED" | "SCHEDULED" | "HOLD" | "INFO" | ("PENDING" | "PROCESSING" | "BOOKED" | "CANCELLED" | "REJECTED" | "SCHEDULED" | "HOLD" | "INFO")[] | undefined;
                                 filterPaymentType?: "DOMESTIC" | "DOMESTIC"[] | undefined;
@@ -2414,7 +451,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
     v1: {
         organizations: {
             ":id": {
-                "payment-requests": ClientRequest<string, "/v1/organizations/:id/payment-requests", {
+                "payment-requests": hono_client.ClientRequest<string, "/v1/organizations/:id/payment-requests", {
                     $get: {
                         input: {
                             param: {
@@ -2427,7 +464,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                             query: {
                                 page?: string | undefined;
                                 limit?: string | undefined;
-                                sortColumn?: "amount" | "createdAt" | "updatedAt" | undefined;
+                                sortColumn?: "createdAt" | "updatedAt" | "amount" | undefined;
                                 sortDirection?: "asc" | "desc" | undefined;
                                 filterStatus?: "BOOKED" | "REJECTED" | "OPENED" | "AUTHORIZED" | "COMPLETED" | "SETTLED" | "CLOSED" | ("BOOKED" | "REJECTED" | "OPENED" | "AUTHORIZED" | "COMPLETED" | "SETTLED" | "CLOSED")[] | undefined;
                                 filterPaymentType?: "DOMESTIC" | "DOMESTIC"[] | undefined;
@@ -2450,6 +487,8 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                         output: {
                             paymentRequests: {
                                 id: string;
+                                referenceId: string | null;
+                                bankRefId: string | null;
                                 status: string;
                                 direction: "OUTGOING";
                                 type: string;
@@ -2460,38 +499,39 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                 debtor: {
                                     name: string | null;
                                     iban: string | null;
-                                    accountId?: string | undefined;
-                                    bankCode?: string | undefined;
+                                    accountId: string;
+                                    bankCode: string | null;
                                 };
                                 creditor: {
                                     name: string | null;
                                     iban?: string | undefined;
                                     bankCode?: string | undefined;
                                     swiftBic?: string | undefined;
-                                    address?: string | undefined;
+                                    address?: {
+                                        streetName?: string | undefined;
+                                        buildingNumber?: string | undefined;
+                                        city?: string | undefined;
+                                        postalCode?: string | undefined;
+                                        countryCode?: string | undefined;
+                                    } | undefined;
                                 };
+                                remittanceInfo: {
+                                    message: string | null;
+                                    variableSymbol: string | null;
+                                    specificSymbol: string | null;
+                                    constantSymbol: string | null;
+                                } | null;
+                                statusReason: string | null;
                                 dates: {
                                     created: string | null;
-                                    initiated?: string | undefined;
-                                    processed?: string | undefined;
-                                    updated?: string | undefined;
+                                    initiated: string | null;
+                                    processed: string | null;
+                                    updated: string | null;
                                 };
-                                referenceId?: string | undefined;
-                                bankRefId?: string | undefined;
-                                authorization?: {
-                                    url: string;
-                                } | undefined;
-                                remittanceInfo?: {
-                                    message?: string | undefined;
-                                    variableSymbol?: string | undefined;
-                                    specificSymbol?: string | undefined;
-                                    constantSymbol?: string | undefined;
-                                } | undefined;
-                                statusReason?: string | undefined;
-                                batch?: {
+                                batch: {
                                     id: string;
-                                } | undefined;
-                                instructionPriority?: "NORMAL" | "INSTANT" | undefined;
+                                } | null;
+                                instructionPriority: "NORMAL" | "INSTANT" | null;
                             }[];
                             pagination: {
                                 page: number;
@@ -2516,7 +556,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                             query: {
                                 page?: string | undefined;
                                 limit?: string | undefined;
-                                sortColumn?: "amount" | "createdAt" | "updatedAt" | undefined;
+                                sortColumn?: "createdAt" | "updatedAt" | "amount" | undefined;
                                 sortDirection?: "asc" | "desc" | undefined;
                                 filterStatus?: "BOOKED" | "REJECTED" | "OPENED" | "AUTHORIZED" | "COMPLETED" | "SETTLED" | "CLOSED" | ("BOOKED" | "REJECTED" | "OPENED" | "AUTHORIZED" | "COMPLETED" | "SETTLED" | "CLOSED")[] | undefined;
                                 filterPaymentType?: "DOMESTIC" | "DOMESTIC"[] | undefined;
@@ -2573,13 +613,6 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                     clabe?: string | undefined;
                                     bsb?: string | undefined;
                                     brBankNumber?: string | undefined;
-                                    address?: {
-                                        streetName?: string | undefined;
-                                        buildingNumber?: string | undefined;
-                                        city?: string | undefined;
-                                        postalCode?: string | undefined;
-                                        countryCode?: string | undefined;
-                                    } | undefined;
                                 };
                                 referenceId?: string | undefined;
                                 remittanceInfo?: {
@@ -2592,11 +625,52 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                             };
                         };
                         output: {
-                            paymentRequestId: string;
-                            authorizationUrl: string;
-                            status: "accepted";
-                            instructionPriority: "NORMAL" | "INSTANT";
-                            referenceId?: string | undefined;
+                            id: string;
+                            referenceId: string | null;
+                            bankRefId: string | null;
+                            status: string;
+                            direction: "OUTGOING";
+                            type: string;
+                            amount: {
+                                value: number;
+                                currency: string;
+                            };
+                            debtor: {
+                                name: string | null;
+                                iban: string | null;
+                                accountId: string;
+                                bankCode: string | null;
+                            };
+                            creditor: {
+                                name: string | null;
+                                iban?: string | undefined;
+                                bankCode?: string | undefined;
+                                swiftBic?: string | undefined;
+                                address?: {
+                                    streetName?: string | undefined;
+                                    buildingNumber?: string | undefined;
+                                    city?: string | undefined;
+                                    postalCode?: string | undefined;
+                                    countryCode?: string | undefined;
+                                } | undefined;
+                            };
+                            remittanceInfo: {
+                                message: string | null;
+                                variableSymbol: string | null;
+                                specificSymbol: string | null;
+                                constantSymbol: string | null;
+                            } | null;
+                            statusReason: string | null;
+                            dates: {
+                                created: string | null;
+                                initiated: string | null;
+                                processed: string | null;
+                                updated: string | null;
+                            };
+                            batch: {
+                                id: string;
+                            } | null;
+                            instructionPriority: "NORMAL" | "INSTANT" | null;
                         };
                         outputFormat: "json";
                         status: 202;
@@ -2630,13 +704,6 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                     clabe?: string | undefined;
                                     bsb?: string | undefined;
                                     brBankNumber?: string | undefined;
-                                    address?: {
-                                        streetName?: string | undefined;
-                                        buildingNumber?: string | undefined;
-                                        city?: string | undefined;
-                                        postalCode?: string | undefined;
-                                        countryCode?: string | undefined;
-                                    } | undefined;
                                 };
                                 referenceId?: string | undefined;
                                 remittanceInfo?: {
@@ -2684,13 +751,6 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                     clabe?: string | undefined;
                                     bsb?: string | undefined;
                                     brBankNumber?: string | undefined;
-                                    address?: {
-                                        streetName?: string | undefined;
-                                        buildingNumber?: string | undefined;
-                                        city?: string | undefined;
-                                        postalCode?: string | undefined;
-                                        countryCode?: string | undefined;
-                                    } | undefined;
                                 };
                                 referenceId?: string | undefined;
                                 remittanceInfo?: {
@@ -2738,13 +798,6 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                     clabe?: string | undefined;
                                     bsb?: string | undefined;
                                     brBankNumber?: string | undefined;
-                                    address?: {
-                                        streetName?: string | undefined;
-                                        buildingNumber?: string | undefined;
-                                        city?: string | undefined;
-                                        postalCode?: string | undefined;
-                                        countryCode?: string | undefined;
-                                    } | undefined;
                                 };
                                 referenceId?: string | undefined;
                                 remittanceInfo?: {
@@ -2792,13 +845,6 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                     clabe?: string | undefined;
                                     bsb?: string | undefined;
                                     brBankNumber?: string | undefined;
-                                    address?: {
-                                        streetName?: string | undefined;
-                                        buildingNumber?: string | undefined;
-                                        city?: string | undefined;
-                                        postalCode?: string | undefined;
-                                        countryCode?: string | undefined;
-                                    } | undefined;
                                 };
                                 referenceId?: string | undefined;
                                 remittanceInfo?: {
@@ -2825,7 +871,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
         organizations: {
             ":id": {
                 "payment-requests": {
-                    batch: ClientRequest<string, "/v1/organizations/:id/payment-requests/batch", {
+                    batch: hono_client.ClientRequest<string, "/v1/organizations/:id/payment-requests/batch", {
                         $post: {
                             input: {
                                 param: {
@@ -2857,13 +903,6 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                             clabe?: string | undefined;
                                             bsb?: string | undefined;
                                             brBankNumber?: string | undefined;
-                                            address?: {
-                                                streetName?: string | undefined;
-                                                buildingNumber?: string | undefined;
-                                                city?: string | undefined;
-                                                postalCode?: string | undefined;
-                                                countryCode?: string | undefined;
-                                            } | undefined;
                                         };
                                         referenceId?: string | undefined;
                                         remittanceInfo?: {
@@ -2878,9 +917,54 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                             };
                             output: {
                                 batchId: string;
-                                authorizationUrls: string[];
-                                status: "accepted";
-                                paymentCount: number;
+                                paymentRequests: {
+                                    id: string;
+                                    referenceId: string | null;
+                                    bankRefId: string | null;
+                                    status: string;
+                                    direction: "OUTGOING";
+                                    type: string;
+                                    amount: {
+                                        value: number;
+                                        currency: string;
+                                    };
+                                    debtor: {
+                                        name: string | null;
+                                        iban: string | null;
+                                        accountId: string;
+                                        bankCode: string | null;
+                                    };
+                                    creditor: {
+                                        name: string | null;
+                                        iban?: string | undefined;
+                                        bankCode?: string | undefined;
+                                        swiftBic?: string | undefined;
+                                        address?: {
+                                            streetName?: string | undefined;
+                                            buildingNumber?: string | undefined;
+                                            city?: string | undefined;
+                                            postalCode?: string | undefined;
+                                            countryCode?: string | undefined;
+                                        } | undefined;
+                                    };
+                                    remittanceInfo: {
+                                        message: string | null;
+                                        variableSymbol: string | null;
+                                        specificSymbol: string | null;
+                                        constantSymbol: string | null;
+                                    } | null;
+                                    statusReason: string | null;
+                                    dates: {
+                                        created: string | null;
+                                        initiated: string | null;
+                                        processed: string | null;
+                                        updated: string | null;
+                                    };
+                                    batch: {
+                                        id: string;
+                                    } | null;
+                                    instructionPriority: "NORMAL" | "INSTANT" | null;
+                                }[];
                             };
                             outputFormat: "json";
                             status: 202;
@@ -2915,13 +999,6 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                             clabe?: string | undefined;
                                             bsb?: string | undefined;
                                             brBankNumber?: string | undefined;
-                                            address?: {
-                                                streetName?: string | undefined;
-                                                buildingNumber?: string | undefined;
-                                                city?: string | undefined;
-                                                postalCode?: string | undefined;
-                                                countryCode?: string | undefined;
-                                            } | undefined;
                                         };
                                         referenceId?: string | undefined;
                                         remittanceInfo?: {
@@ -2971,13 +1048,6 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                             clabe?: string | undefined;
                                             bsb?: string | undefined;
                                             brBankNumber?: string | undefined;
-                                            address?: {
-                                                streetName?: string | undefined;
-                                                buildingNumber?: string | undefined;
-                                                city?: string | undefined;
-                                                postalCode?: string | undefined;
-                                                countryCode?: string | undefined;
-                                            } | undefined;
                                         };
                                         referenceId?: string | undefined;
                                         remittanceInfo?: {
@@ -3027,13 +1097,6 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                             clabe?: string | undefined;
                                             bsb?: string | undefined;
                                             brBankNumber?: string | undefined;
-                                            address?: {
-                                                streetName?: string | undefined;
-                                                buildingNumber?: string | undefined;
-                                                city?: string | undefined;
-                                                postalCode?: string | undefined;
-                                                countryCode?: string | undefined;
-                                            } | undefined;
                                         };
                                         referenceId?: string | undefined;
                                         remittanceInfo?: {
@@ -3083,13 +1146,6 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                             clabe?: string | undefined;
                                             bsb?: string | undefined;
                                             brBankNumber?: string | undefined;
-                                            address?: {
-                                                streetName?: string | undefined;
-                                                buildingNumber?: string | undefined;
-                                                city?: string | undefined;
-                                                postalCode?: string | undefined;
-                                                countryCode?: string | undefined;
-                                            } | undefined;
                                         };
                                         referenceId?: string | undefined;
                                         remittanceInfo?: {
@@ -3118,7 +1174,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
         organizations: {
             ":id": {
                 "payment-requests": {
-                    ":paymentRequestId": ClientRequest<string, "/v1/organizations/:id/payment-requests/:paymentRequestId", {
+                    ":paymentRequestId": hono_client.ClientRequest<string, "/v1/organizations/:id/payment-requests/:paymentRequestId", {
                         $get: {
                             input: {
                                 param: {
@@ -3131,6 +1187,8 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                             };
                             output: {
                                 id: string;
+                                referenceId: string | null;
+                                bankRefId: string | null;
                                 status: string;
                                 direction: "OUTGOING";
                                 type: string;
@@ -3141,38 +1199,39 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                 debtor: {
                                     name: string | null;
                                     iban: string | null;
-                                    accountId?: string | undefined;
-                                    bankCode?: string | undefined;
+                                    accountId: string;
+                                    bankCode: string | null;
                                 };
                                 creditor: {
                                     name: string | null;
                                     iban?: string | undefined;
                                     bankCode?: string | undefined;
                                     swiftBic?: string | undefined;
-                                    address?: string | undefined;
+                                    address?: {
+                                        streetName?: string | undefined;
+                                        buildingNumber?: string | undefined;
+                                        city?: string | undefined;
+                                        postalCode?: string | undefined;
+                                        countryCode?: string | undefined;
+                                    } | undefined;
                                 };
+                                remittanceInfo: {
+                                    message: string | null;
+                                    variableSymbol: string | null;
+                                    specificSymbol: string | null;
+                                    constantSymbol: string | null;
+                                } | null;
+                                statusReason: string | null;
                                 dates: {
                                     created: string | null;
-                                    initiated?: string | undefined;
-                                    processed?: string | undefined;
-                                    updated?: string | undefined;
+                                    initiated: string | null;
+                                    processed: string | null;
+                                    updated: string | null;
                                 };
-                                referenceId?: string | undefined;
-                                bankRefId?: string | undefined;
-                                authorization?: {
-                                    url: string;
-                                } | undefined;
-                                remittanceInfo?: {
-                                    message?: string | undefined;
-                                    variableSymbol?: string | undefined;
-                                    specificSymbol?: string | undefined;
-                                    constantSymbol?: string | undefined;
-                                } | undefined;
-                                statusReason?: string | undefined;
-                                batch?: {
+                                batch: {
                                     id: string;
-                                } | undefined;
-                                instructionPriority?: "NORMAL" | "INSTANT" | undefined;
+                                } | null;
+                                instructionPriority: "NORMAL" | "INSTANT" | null;
                             };
                             outputFormat: "json";
                             status: 200;
@@ -3215,7 +1274,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
 } & {
     v1: {
         organization: {
-            "signature-keys": ClientRequest<string, "/v1/organization/signature-keys", {
+            "signature-keys": hono_client.ClientRequest<string, "/v1/organization/signature-keys", {
                 $post: {
                     input: {
                         header: {
@@ -3276,7 +1335,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
     v1: {
         organization: {
             "signature-keys": {
-                ":name": ClientRequest<string, "/v1/organization/signature-keys/:name", {
+                ":name": hono_client.ClientRequest<string, "/v1/organization/signature-keys/:name", {
                     $delete: {
                         input: {
                             param: {
@@ -3317,7 +1376,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
 } & {
     v1: {
         organization: {
-            users: ClientRequest<string, "/v1/organization/users", {
+            users: hono_client.ClientRequest<string, "/v1/organization/users", {
                 $post: {
                     input: {
                         header: {
@@ -3358,7 +1417,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
     v1: {
         organization: {
             users: {
-                ":id": ClientRequest<string, "/v1/organization/users/:id", {
+                ":id": hono_client.ClientRequest<string, "/v1/organization/users/:id", {
                     $delete: {
                         input: {
                             param: {
@@ -3445,7 +1504,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
     v1: {
         tasks: {
             setups: {
-                organization: ClientRequest<string, "/v1/tasks/setups/organization", {
+                organization: hono_client.ClientRequest<string, "/v1/tasks/setups/organization", {
                     $post: {
                         input: {
                             json: {
@@ -3532,7 +1591,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
         users: {
             ":userId": {
                 verification: {
-                    ":confirmationToken": ClientRequest<string, "/v1/users/:userId/verification/:confirmationToken", {
+                    ":confirmationToken": hono_client.ClientRequest<string, "/v1/users/:userId/verification/:confirmationToken", {
                         $patch: {
                             input: {
                                 param: {
@@ -3549,7 +1608,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                             };
                             output: Response;
                             outputFormat: "json";
-                            status: StatusCode;
+                            status: hono_utils_http_status.StatusCode;
                         };
                     } & {
                         $get: {
@@ -3564,7 +1623,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                             };
                             output: Response;
                             outputFormat: "json";
-                            status: StatusCode;
+                            status: hono_utils_http_status.StatusCode;
                         };
                     }>;
                 };
@@ -3577,7 +1636,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
             ":userId": {
                 verification: {
                     ":confirmationToken": {
-                        success: ClientRequest<string, "/v1/users/:userId/verification/:confirmationToken/success", {
+                        success: hono_client.ClientRequest<string, "/v1/users/:userId/verification/:confirmationToken/success", {
                             $get: {
                                 input: {
                                     param: {
@@ -3591,7 +1650,7 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
                                 };
                                 output: Response;
                                 outputFormat: "json";
-                                status: StatusCode;
+                                status: hono_utils_http_status.StatusCode;
                             };
                         }>;
                     };
@@ -3601,15 +1660,16 @@ declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
     };
 };
 
-declare const signPayload: ({ payload, privateKey, }: {
-    payload: string;
-    privateKey: string;
-}) => Promise<string>;
-declare const verifyPayloadSignature: ({ signature, data, publicKey, algorithm, }: {
-    signature: string;
-    data: string;
-    publicKey: string;
-    algorithm?: "RSA" | "EC" | "HMAC";
-}) => Promise<boolean>;
+declare const WebhookEventType: {
+    readonly PaymentFetched: "payment.fetched";
+    readonly PaymentUpdated: "payment.updated";
+    readonly PaymentRequestAuthorized: "payment_request.authorized";
+    readonly PaymentRequestCompleted: "payment_request.completed";
+    readonly PaymentRequestBooked: "payment_request.booked";
+    readonly PaymentRequestSettled: "payment_request.settled";
+    readonly PaymentRequestRejected: "payment_request.rejected";
+    readonly PaymentRequestClosed: "payment_request.closed";
+};
+type WebhookEventType = (typeof WebhookEventType)[keyof typeof WebhookEventType];
 
-export { createPartnerApiClient, signPayload, verifyPayloadSignature };
+export { WebhookEventType, WebhookEventType as WebhookEventTypeValue, createPartnerApiClient };