@devizovaburza/payments-api-sdk 1.1.0

package/dist/v1/index.d.ts

@@ -0,0 +1,3394 @@
+/**
+ * @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, any> = H<E2, P, any>>(...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, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>>(...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, any> = H<E2, MergedPath, any>>(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, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>>(...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, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>>(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, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>>(...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, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>>(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, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>>(...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, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>>(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, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>>(...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, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>>(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, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>>(...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, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>>(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, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>, M8 extends H<E9, P, any> = H<E9, P, any>>(...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, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>>(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, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>, M8 extends H<E9, P, any> = H<E9, P, any>, M9 extends H<E10, P, any> = H<E10, P, any>>(...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, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>, M8 extends H<E9, MergedPath, any> = H<E9, MergedPath, any>>(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, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>, M8 extends H<E9, MergedPath, any> = H<E9, MergedPath, any>, M9 extends H<E10, MergedPath, any> = H<E10, MergedPath, any>>(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 & {
+    parsedBody: BodyData;
+}>;
+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: 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;
+}
+/**
+ * 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: RequestInfo | 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>;
+} & (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> extends globalThis.Response {
+    readonly body: ReadableStream | null;
+    readonly bodyUsed: boolean;
+    ok: U extends SuccessStatusCode ? true : U extends Exclude<StatusCode, SuccessStatusCode> ? false : boolean;
+    status: U;
+    statusText: string;
+    headers: Headers;
+    url: string;
+    redirect(url: string, status: number): Response$1;
+    clone(): Response$1;
+    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 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>>;
+
+declare const createPartnerApiClient: (...args: Parameters<typeof hc>) => {
+    v1: {
+        auth: {
+            token: ClientRequest<string, "/v1/auth/token", {
+                $post: {
+                    input: {
+                        json: {
+                            email: string;
+                            password: string;
+                        };
+                    };
+                    output: {
+                        message: string;
+                        accessToken: string;
+                        refreshToken: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        json: {
+                            email: string;
+                            password: string;
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 401;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        auth: {
+            token: {
+                refresh: ClientRequest<string, "/v1/auth/token/refresh", {
+                    $put: {
+                        input: {
+                            json: {
+                                refreshToken: string;
+                            };
+                        };
+                        output: {
+                            message: string;
+                            accessToken: string;
+                            refreshToken: string;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            json: {
+                                refreshToken: string;
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 401;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        bank: {
+            auth: {
+                "get-auth-uri": ClientRequest<string, "/v1/bank/auth/get-auth-uri", {
+                    $get: {
+                        input: {
+                            query: {
+                                connectorKey: "ERSTE" | "FINBRICKS" | "MOCK" | "CREDITAS" | "MOCK_COBS" | "FIO" | "MONETA" | "DBU" | "CSAS" | "AIRBANK" | "KB" | "CSOB";
+                            };
+                        };
+                        output: {
+                            message: string;
+                            uri: string;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            query: {
+                                connectorKey: "ERSTE" | "FINBRICKS" | "MOCK" | "CREDITAS" | "MOCK_COBS" | "FIO" | "MONETA" | "DBU" | "CSAS" | "AIRBANK" | "KB" | "CSOB";
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 500;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        bank: {
+            callback: ClientRequest<string, "/v1/bank/callback", {
+                $get: {
+                    input: {
+                        query: {
+                            [x: string]: string;
+                            type: "auth" | "batch";
+                            ott?: string | undefined;
+                            batchId?: string | undefined;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: 302;
+                } | {
+                    input: {
+                        query: {
+                            [x: string]: string;
+                            type: "auth" | "batch";
+                            ott?: string | undefined;
+                            batchId?: string | undefined;
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        query: {
+                            [x: string]: string;
+                            type: "auth" | "batch";
+                            ott?: string | undefined;
+                            batchId?: string | undefined;
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 400;
+                } | {
+                    input: {
+                        query: {
+                            [x: string]: string;
+                            type: "auth" | "batch";
+                            ott?: string | undefined;
+                            batchId?: string | undefined;
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 500;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        observability: {
+            "health-check": ClientRequest<string, "/v1/observability/health-check", {
+                $get: {
+                    input: {};
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        organization: ClientRequest<string, "/v1/organization", {
+            $get: {
+                input: {};
+                output: {
+                    message: string;
+                    balance: {
+                        amount: number;
+                        currency: string;
+                    };
+                    organization: {
+                        id: string;
+                        name: string;
+                        webhook: string;
+                        ipAuthorization: boolean;
+                        signatureKeyLimit: number;
+                        state: string;
+                        signatureKeys: {
+                            name: string;
+                            publicKey: string;
+                        }[];
+                        authorizedIps: {
+                            ip: string;
+                        }[];
+                        users: {
+                            id: string;
+                            email: string;
+                            role: string;
+                        }[];
+                        bankAccounts?: {
+                            iban: string;
+                            currency: "CZK" | "EUR" | "USD";
+                        }[] | null | undefined;
+                    };
+                };
+                outputFormat: "json";
+                status: 200;
+            } | {
+                input: {};
+                output: {
+                    message: string;
+                };
+                outputFormat: "json";
+                status: 500;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        organizations: {
+            ":id": {
+                accounts: ClientRequest<string, "/v1/organizations/:id/accounts", {
+                    $get: {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                [x: string]: string;
+                                [x: number]: string;
+                                [x: symbol]: string;
+                            };
+                            query: {
+                                page?: string | undefined;
+                                limit?: string | undefined;
+                            };
+                        };
+                        output: {
+                            accounts: {
+                                id: string;
+                                status: "ACTIVE" | "INACTIVE" | "BLOCKED" | "DISABLED";
+                                accountHolderName: string | null;
+                                iban: string | null;
+                                accountNumber: string;
+                                bankCode: string;
+                                swiftBic: string | null;
+                                currency: string;
+                                countryCode: string;
+                            }[];
+                            pagination: {
+                                page: number;
+                                pageSize: number;
+                                totalPages: number;
+                                totalCount: number;
+                                hasNext: boolean;
+                                hasPrevious: boolean;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                [x: string]: string;
+                                [x: number]: string;
+                                [x: symbol]: string;
+                            };
+                            query: {
+                                page?: string | undefined;
+                                limit?: string | undefined;
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    } | {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                [x: string]: string;
+                                [x: number]: string;
+                                [x: symbol]: string;
+                            };
+                            query: {
+                                page?: string | undefined;
+                                limit?: string | undefined;
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 500;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        organizations: {
+            ":id": {
+                payments: ClientRequest<string, "/v1/organizations/:id/payments", {
+                    $get: {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                [x: string]: string;
+                                [x: number]: string;
+                                [x: symbol]: string;
+                            };
+                            query: {
+                                page?: string | undefined;
+                                limit?: string | undefined;
+                                sortColumn?: "amount" | "createdAt" | "updatedAt" | undefined;
+                                sortDirection?: "asc" | "desc" | undefined;
+                                filterStatus?: "CREATED" | "PREPARED" | "SIGNED" | "PENDING" | "COMPLETED" | "FAILED" | ("CREATED" | "PREPARED" | "SIGNED" | "PENDING" | "COMPLETED" | "FAILED")[] | undefined;
+                                filterPaymentType?: "DOMESTIC" | "SEPA" | "SWIFT" | ("DOMESTIC" | "SEPA" | "SWIFT")[] | undefined;
+                                filterCurrency?: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX" | ("CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX")[] | undefined;
+                                filterMinAmount?: string | undefined;
+                                filterMaxAmount?: string | undefined;
+                                filterBatchId?: string | undefined;
+                                filterCreditorIban?: string | undefined;
+                                filterDebtorIban?: string | undefined;
+                                filterDateFrom?: string | undefined;
+                                filterDateTo?: string | undefined;
+                                filterVariableSymbol?: string | undefined;
+                                filterSpecificSymbol?: string | undefined;
+                                filterConstantSymbol?: string | undefined;
+                                filterMessage?: string | undefined;
+                                filterBankRefId?: string | undefined;
+                                filterPaymentId?: string | undefined;
+                                filterDirection?: "INCOMING" | "OUTGOING" | undefined;
+                                filterSource?: "API" | "BANK" | undefined;
+                            };
+                        };
+                        output: {
+                            payments: {
+                                id: string;
+                                source: "API" | "BANK";
+                                status: string;
+                                direction: "INCOMING" | "OUTGOING";
+                                type: string;
+                                amount: {
+                                    value: number;
+                                    currency: string;
+                                };
+                                debtor: {
+                                    name: string | null;
+                                    iban: string | null;
+                                    accountId?: string | undefined;
+                                    bankCode?: string | undefined;
+                                };
+                                creditor: {
+                                    name: string | null;
+                                    iban?: string | undefined;
+                                    bankCode?: string | undefined;
+                                    swiftBic?: string | undefined;
+                                    address?: string | undefined;
+                                };
+                                dates: {
+                                    created: string | null;
+                                    initiated?: string | undefined;
+                                    processed?: string | undefined;
+                                    updated?: string | undefined;
+                                };
+                                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?: {
+                                    id: string;
+                                } | undefined;
+                            }[];
+                            pagination: {
+                                page: number;
+                                pageSize: number;
+                                totalPages: number;
+                                totalCount: number;
+                                hasNext: boolean;
+                                hasPrevious: boolean;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                [x: string]: string;
+                                [x: number]: string;
+                                [x: symbol]: string;
+                            };
+                            query: {
+                                page?: string | undefined;
+                                limit?: string | undefined;
+                                sortColumn?: "amount" | "createdAt" | "updatedAt" | undefined;
+                                sortDirection?: "asc" | "desc" | undefined;
+                                filterStatus?: "CREATED" | "PREPARED" | "SIGNED" | "PENDING" | "COMPLETED" | "FAILED" | ("CREATED" | "PREPARED" | "SIGNED" | "PENDING" | "COMPLETED" | "FAILED")[] | undefined;
+                                filterPaymentType?: "DOMESTIC" | "SEPA" | "SWIFT" | ("DOMESTIC" | "SEPA" | "SWIFT")[] | undefined;
+                                filterCurrency?: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX" | ("CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX")[] | undefined;
+                                filterMinAmount?: string | undefined;
+                                filterMaxAmount?: string | undefined;
+                                filterBatchId?: string | undefined;
+                                filterCreditorIban?: string | undefined;
+                                filterDebtorIban?: string | undefined;
+                                filterDateFrom?: string | undefined;
+                                filterDateTo?: string | undefined;
+                                filterVariableSymbol?: string | undefined;
+                                filterSpecificSymbol?: string | undefined;
+                                filterConstantSymbol?: string | undefined;
+                                filterMessage?: string | undefined;
+                                filterBankRefId?: string | undefined;
+                                filterPaymentId?: string | undefined;
+                                filterDirection?: "INCOMING" | "OUTGOING" | undefined;
+                                filterSource?: "API" | "BANK" | undefined;
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 500;
+                    };
+                } & {
+                    $post: {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                [x: string]: string;
+                                [x: number]: string;
+                                [x: symbol]: string;
+                            };
+                            header: {
+                                'x-idempotency-key': string;
+                            };
+                            json: {
+                                paymentType: "DOMESTIC" | "SEPA" | "SWIFT";
+                                amount: {
+                                    value: number;
+                                    currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                                };
+                                debtorAccountId: string;
+                                creditor: {
+                                    name: string;
+                                    iban?: string | undefined;
+                                    accountNumber?: string | undefined;
+                                    bankCode?: "5051" | "0100" | "0300" | "0600" | "0710" | "0800" | "2010" | "2060" | "2070" | "2100" | "2200" | "2220" | "2250" | "2260" | "2600" | "2700" | "3030" | "3060" | "3500" | "4300" | "5500" | "5800" | "6000" | "6200" | "6210" | "6300" | "6363" | "6700" | "6800" | "7910" | "7950" | "7960" | "7970" | "7990" | "8030" | "8040" | "8060" | "8090" | "8150" | "8190" | "8198" | "8220" | "8250" | "8255" | "8265" | "8500" | undefined;
+                                    swiftBic?: string | undefined;
+                                    sortCode?: string | undefined;
+                                    routingNumber?: string | undefined;
+                                    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?: {
+                                    message?: string | undefined;
+                                    variableSymbol?: string | undefined;
+                                    constantSymbol?: string | undefined;
+                                    specificSymbol?: string | undefined;
+                                } | undefined;
+                                instructionPriority?: "NORMAL" | "HIGH" | "INSTANT" | undefined;
+                                chargeBearer?: "SHA" | "OUR" | "BEN" | undefined;
+                            };
+                        };
+                        output: {
+                            paymentId: string;
+                            status: "accepted";
+                            queuedAt: string;
+                            processing: {
+                                priority: "NORMAL" | "HIGH" | "INSTANT";
+                                estimatedCompletion: string;
+                            };
+                            referenceId?: string | undefined;
+                        };
+                        outputFormat: "json";
+                        status: 202;
+                    } | {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                [x: string]: string;
+                                [x: number]: string;
+                                [x: symbol]: string;
+                            };
+                            header: {
+                                'x-idempotency-key': string;
+                            };
+                            json: {
+                                paymentType: "DOMESTIC" | "SEPA" | "SWIFT";
+                                amount: {
+                                    value: number;
+                                    currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                                };
+                                debtorAccountId: string;
+                                creditor: {
+                                    name: string;
+                                    iban?: string | undefined;
+                                    accountNumber?: string | undefined;
+                                    bankCode?: "5051" | "0100" | "0300" | "0600" | "0710" | "0800" | "2010" | "2060" | "2070" | "2100" | "2200" | "2220" | "2250" | "2260" | "2600" | "2700" | "3030" | "3060" | "3500" | "4300" | "5500" | "5800" | "6000" | "6200" | "6210" | "6300" | "6363" | "6700" | "6800" | "7910" | "7950" | "7960" | "7970" | "7990" | "8030" | "8040" | "8060" | "8090" | "8150" | "8190" | "8198" | "8220" | "8250" | "8255" | "8265" | "8500" | undefined;
+                                    swiftBic?: string | undefined;
+                                    sortCode?: string | undefined;
+                                    routingNumber?: string | undefined;
+                                    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?: {
+                                    message?: string | undefined;
+                                    variableSymbol?: string | undefined;
+                                    constantSymbol?: string | undefined;
+                                    specificSymbol?: string | undefined;
+                                } | undefined;
+                                instructionPriority?: "NORMAL" | "HIGH" | "INSTANT" | undefined;
+                                chargeBearer?: "SHA" | "OUR" | "BEN" | undefined;
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    } | {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                [x: string]: string;
+                                [x: number]: string;
+                                [x: symbol]: string;
+                            };
+                            header: {
+                                'x-idempotency-key': string;
+                            };
+                            json: {
+                                paymentType: "DOMESTIC" | "SEPA" | "SWIFT";
+                                amount: {
+                                    value: number;
+                                    currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                                };
+                                debtorAccountId: string;
+                                creditor: {
+                                    name: string;
+                                    iban?: string | undefined;
+                                    accountNumber?: string | undefined;
+                                    bankCode?: "5051" | "0100" | "0300" | "0600" | "0710" | "0800" | "2010" | "2060" | "2070" | "2100" | "2200" | "2220" | "2250" | "2260" | "2600" | "2700" | "3030" | "3060" | "3500" | "4300" | "5500" | "5800" | "6000" | "6200" | "6210" | "6300" | "6363" | "6700" | "6800" | "7910" | "7950" | "7960" | "7970" | "7990" | "8030" | "8040" | "8060" | "8090" | "8150" | "8190" | "8198" | "8220" | "8250" | "8255" | "8265" | "8500" | undefined;
+                                    swiftBic?: string | undefined;
+                                    sortCode?: string | undefined;
+                                    routingNumber?: string | undefined;
+                                    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?: {
+                                    message?: string | undefined;
+                                    variableSymbol?: string | undefined;
+                                    constantSymbol?: string | undefined;
+                                    specificSymbol?: string | undefined;
+                                } | undefined;
+                                instructionPriority?: "NORMAL" | "HIGH" | "INSTANT" | undefined;
+                                chargeBearer?: "SHA" | "OUR" | "BEN" | undefined;
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 500;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        organizations: {
+            ":id": {
+                payments: {
+                    ":paymentId": ClientRequest<string, "/v1/organizations/:id/payments/:paymentId", {
+                        $get: {
+                            input: {
+                                param: {
+                                    id: string;
+                                    paymentId: string;
+                                } & {
+                                    id: string;
+                                    paymentId: string;
+                                };
+                            };
+                            output: {
+                                id: string;
+                                source: "API" | "BANK";
+                                status: string;
+                                direction: "INCOMING" | "OUTGOING";
+                                type: string;
+                                amount: {
+                                    value: number;
+                                    currency: string;
+                                };
+                                debtor: {
+                                    name: string | null;
+                                    iban: string | null;
+                                    accountId?: string | undefined;
+                                    bankCode?: string | undefined;
+                                };
+                                creditor: {
+                                    name: string | null;
+                                    iban?: string | undefined;
+                                    bankCode?: string | undefined;
+                                    swiftBic?: string | undefined;
+                                    address?: string | undefined;
+                                };
+                                dates: {
+                                    created: string | null;
+                                    initiated?: string | undefined;
+                                    processed?: string | undefined;
+                                    updated?: string | undefined;
+                                };
+                                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?: {
+                                    id: string;
+                                } | undefined;
+                                chargeBearer?: string | undefined;
+                                instructionPriority?: string | undefined;
+                            };
+                            outputFormat: "json";
+                            status: 200;
+                        } | {
+                            input: {
+                                param: {
+                                    id: string;
+                                    paymentId: string;
+                                } & {
+                                    id: string;
+                                    paymentId: string;
+                                };
+                            };
+                            output: {
+                                message: string;
+                            };
+                            outputFormat: "json";
+                            status: 404;
+                        } | {
+                            input: {
+                                param: {
+                                    id: string;
+                                    paymentId: string;
+                                } & {
+                                    id: string;
+                                    paymentId: string;
+                                };
+                            };
+                            output: {
+                                message: string;
+                            };
+                            outputFormat: "json";
+                            status: 500;
+                        };
+                    }>;
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        organization: {
+            "signature-keys": ClientRequest<string, "/v1/organization/signature-keys", {
+                $post: {
+                    input: {
+                        header: {
+                            'X-Idempotency-Key': string;
+                        };
+                    } & {
+                        json: {
+                            name: string;
+                        };
+                    };
+                    output: {
+                        message: string;
+                        publicKey: string;
+                        privateKey: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        header: {
+                            'X-Idempotency-Key': string;
+                        };
+                    } & {
+                        json: {
+                            name: string;
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 500;
+                };
+            } & {
+                $get: {
+                    input: {};
+                    output: {
+                        message: string;
+                        signatureKeys: {
+                            name: string;
+                            publicKey: string;
+                        }[];
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {};
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 500;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        organization: {
+            "signature-keys": {
+                ":name": ClientRequest<string, "/v1/organization/signature-keys/:name", {
+                    $delete: {
+                        input: {
+                            param: {
+                                name: string;
+                            } & {
+                                name: string;
+                            };
+                            header: {
+                                'X-Idempotency-Key': string;
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            param: {
+                                name: string;
+                            } & {
+                                name: string;
+                            };
+                            header: {
+                                'X-Idempotency-Key': string;
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 500;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        organization: {
+            users: ClientRequest<string, "/v1/organization/users", {
+                $post: {
+                    input: {
+                        header: {
+                            'X-Idempotency-Key': string;
+                        };
+                    } & {
+                        json: {
+                            email: string;
+                            password: string;
+                            roles?: string[] | undefined;
+                            scopes?: {
+                                scope: "organizations.{jwt.user.rawUserMetaData.organizationId}.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.accounts.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.payments.create" | "organizations.{jwt.user.rawUserMetaData.organizationId}.payments.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.signature-keys.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.signature-keys.create" | "organizations.{jwt.user.rawUserMetaData.organizationId}.signature-keys.delete" | "organizations.{jwt.user.rawUserMetaData.organizationId}.users.create" | "organizations.{jwt.user.rawUserMetaData.organizationId}.users.delete" | "organizations.{jwt.user.rawUserMetaData.organizationId}.users.update" | "organizations.{jwt.user.rawUserMetaData.organizationId}.users.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.transactions.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.transactions.deposit.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.transactions.simulate-deposit.create" | "organizations.{jwt.user.rawUserMetaData.organizationId}.transactions.withdraw.create";
+                                resourceId?: string | undefined;
+                            }[] | undefined;
+                        };
+                    };
+                    output: {
+                        message: string;
+                        id: string;
+                        email: string;
+                        role: "OWNER" | "ADMIN" | "MEMBER";
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        header: {
+                            'X-Idempotency-Key': string;
+                        };
+                    } & {
+                        json: {
+                            email: string;
+                            password: string;
+                            roles?: string[] | undefined;
+                            scopes?: {
+                                scope: "organizations.{jwt.user.rawUserMetaData.organizationId}.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.accounts.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.payments.create" | "organizations.{jwt.user.rawUserMetaData.organizationId}.payments.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.signature-keys.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.signature-keys.create" | "organizations.{jwt.user.rawUserMetaData.organizationId}.signature-keys.delete" | "organizations.{jwt.user.rawUserMetaData.organizationId}.users.create" | "organizations.{jwt.user.rawUserMetaData.organizationId}.users.delete" | "organizations.{jwt.user.rawUserMetaData.organizationId}.users.update" | "organizations.{jwt.user.rawUserMetaData.organizationId}.users.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.transactions.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.transactions.deposit.read" | "organizations.{jwt.user.rawUserMetaData.organizationId}.transactions.simulate-deposit.create" | "organizations.{jwt.user.rawUserMetaData.organizationId}.transactions.withdraw.create";
+                                resourceId?: string | undefined;
+                            }[] | undefined;
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 500;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        organization: {
+            users: {
+                ":id": ClientRequest<string, "/v1/organization/users/:id", {
+                    $delete: {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                id: string;
+                            };
+                            header: {
+                                'X-Idempotency-Key': string;
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                id: string;
+                            };
+                            header: {
+                                'X-Idempotency-Key': string;
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 500;
+                    };
+                } & {
+                    $patch: {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                id: string;
+                            };
+                            header: {
+                                'X-Idempotency-Key': string;
+                            };
+                            json: {
+                                email?: string | undefined;
+                                role?: "OWNER" | "ADMIN" | "MEMBER" | undefined;
+                            };
+                        };
+                        output: {
+                            message: string;
+                            id: string;
+                            email: string;
+                            role: "OWNER" | "ADMIN" | "MEMBER";
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            param: {
+                                id: string;
+                            } & {
+                                id: string;
+                            };
+                            header: {
+                                'X-Idempotency-Key': string;
+                            };
+                            json: {
+                                email?: string | undefined;
+                                role?: "OWNER" | "ADMIN" | "MEMBER" | undefined;
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 500;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        tasks: {
+            setups: {
+                organization: ClientRequest<string, "/v1/tasks/setups/organization", {
+                    $post: {
+                        input: {
+                            json: {
+                                name: string;
+                                webhook: string;
+                                depositFeeMultiplier: number;
+                                withdrawFeeMultiplier: number;
+                                ipAuthorization: boolean;
+                                ownerEmail: string;
+                                bankAccounts: {
+                                    iban: string;
+                                    currency: "CZK" | "EUR" | "USD";
+                                    amount: number;
+                                }[];
+                            };
+                        };
+                        output: {
+                            message: string;
+                            id: string;
+                            name: string;
+                            webhook: string;
+                            signatureKeyLimit: number;
+                            state: "BLOCKED" | "OPERATIONAL";
+                            createdAt: string;
+                            updatedAt: string | null;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            json: {
+                                name: string;
+                                webhook: string;
+                                depositFeeMultiplier: number;
+                                withdrawFeeMultiplier: number;
+                                ipAuthorization: boolean;
+                                ownerEmail: string;
+                                bankAccounts: {
+                                    iban: string;
+                                    currency: "CZK" | "EUR" | "USD";
+                                    amount: number;
+                                }[];
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    } | {
+                        input: {
+                            json: {
+                                name: string;
+                                webhook: string;
+                                depositFeeMultiplier: number;
+                                withdrawFeeMultiplier: number;
+                                ipAuthorization: boolean;
+                                ownerEmail: string;
+                                bankAccounts: {
+                                    iban: string;
+                                    currency: "CZK" | "EUR" | "USD";
+                                    amount: number;
+                                }[];
+                            };
+                        };
+                        output: {
+                            message: string;
+                        };
+                        outputFormat: "json";
+                        status: 500;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        transactions: ClientRequest<string, "/v1/transactions", {
+            $get: {
+                input: {
+                    query: {
+                        page?: string | undefined;
+                        limit?: string | undefined;
+                        sort?: "oldest" | "newest" | undefined;
+                        filterFromDate?: string | undefined;
+                        filterToDate?: string | undefined;
+                        filterBankingVs?: string | undefined;
+                        filterCreditorReferenceCode?: string | undefined;
+                        filterStatus?: "PENDING" | "COMPLETED" | "FAILED" | "APPROVED" | "INITIALIZED" | undefined;
+                        filterPaymentId?: string | undefined;
+                    };
+                };
+                output: {
+                    message: string;
+                    transactions: {
+                        transaction: {
+                            id: string;
+                            createdAt: number | null;
+                            action: "WITHDRAW" | "DEPOSIT" | "TRANSFER" | "MINT" | "BURN" | "STAKE" | "UNSTAKE";
+                            transactionType: string | null;
+                            amount: number;
+                            amountDecimals: number;
+                            currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                            status: "PENDING" | "COMPLETED" | "FAILED" | "APPROVED" | "INITIALIZED";
+                            bank: {
+                                vs: string | null;
+                                ss: string | null;
+                                ks: string | null;
+                                message: string | null;
+                            };
+                        };
+                        creditor: {
+                            holderName: string;
+                            iban: string | null;
+                            accountNumber: string | null;
+                            bankCode: string | null;
+                            referenceCode: string | null;
+                        };
+                        debtor: {
+                            holderName: string;
+                            iban: string | null;
+                            accountNumber: string | null;
+                            bankCode: string | null;
+                            referenceCode: string | null;
+                        };
+                    }[];
+                };
+                outputFormat: "json";
+                status: 200;
+            } | {
+                input: {
+                    query: {
+                        page?: string | undefined;
+                        limit?: string | undefined;
+                        sort?: "oldest" | "newest" | undefined;
+                        filterFromDate?: string | undefined;
+                        filterToDate?: string | undefined;
+                        filterBankingVs?: string | undefined;
+                        filterCreditorReferenceCode?: string | undefined;
+                        filterStatus?: "PENDING" | "COMPLETED" | "FAILED" | "APPROVED" | "INITIALIZED" | undefined;
+                        filterPaymentId?: string | undefined;
+                    };
+                };
+                output: {
+                    message: string;
+                };
+                outputFormat: "json";
+                status: 500;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        transactions: {
+            deposit: ClientRequest<string, "/v1/transactions/deposit", {
+                $get: {
+                    input: {
+                        query: {
+                            currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                        };
+                    };
+                    output: {
+                        message: string;
+                        accountNumber: string;
+                        bankCode: string;
+                        currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                        iban: string;
+                        bic: string | null;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        query: {
+                            currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                } | {
+                    input: {
+                        query: {
+                            currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 500;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        transactions: {
+            withdraw: ClientRequest<string, "/v1/transactions/withdraw", {
+                $post: {
+                    input: {
+                        header: {
+                            'X-Idempotency-Key': string;
+                            'X-Signature-Key': string;
+                            'X-Signature': string;
+                        };
+                    } & {
+                        json: {
+                            amount: number;
+                            currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                            referenceCode: string;
+                            creditorAccount: {
+                                accountNumber: string;
+                                bankCode: string;
+                                creditorName: string;
+                                iban: string;
+                            };
+                            paymentMessage: string;
+                            vs?: string | undefined;
+                            ks?: string | undefined;
+                            ss?: string | undefined;
+                        };
+                    };
+                    output: {
+                        message: string;
+                        id: string;
+                        createdAt: number | null;
+                        action: "WITHDRAW" | "DEPOSIT" | "TRANSFER" | "MINT" | "BURN" | "STAKE" | "UNSTAKE";
+                        transactionType: string | null;
+                        amount: number;
+                        amountDecimals: number;
+                        currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                        status: "PENDING" | "COMPLETED" | "FAILED" | "APPROVED" | "INITIALIZED";
+                        bank: {
+                            vs: string | null;
+                            ss: string | null;
+                            ks: string | null;
+                            message: string | null;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        header: {
+                            'X-Idempotency-Key': string;
+                            'X-Signature-Key': string;
+                            'X-Signature': string;
+                        };
+                    } & {
+                        json: {
+                            amount: number;
+                            currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                            referenceCode: string;
+                            creditorAccount: {
+                                accountNumber: string;
+                                bankCode: string;
+                                creditorName: string;
+                                iban: string;
+                            };
+                            paymentMessage: string;
+                            vs?: string | undefined;
+                            ks?: string | undefined;
+                            ss?: string | undefined;
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                } | {
+                    input: {
+                        header: {
+                            'X-Idempotency-Key': string;
+                            'X-Signature-Key': string;
+                            'X-Signature': string;
+                        };
+                    } & {
+                        json: {
+                            amount: number;
+                            currency: "CZK" | "EUR" | "USD" | "PLN" | "RON" | "GBP" | "RUB" | "HUF" | "CHF" | "DKK" | "SEK" | "HRK" | "NOK" | "BGN" | "TRY" | "AUD" | "CAD" | "JPY" | "CNY" | "INR" | "BRL" | "MXN" | "ZAR" | "SGD" | "HKD" | "KRW" | "MYR" | "THB" | "IDR" | "PHP" | "AED" | "SAR" | "ILS" | "EGP" | "NGN" | "PKR" | "COP" | "CLP" | "PEN" | "VND" | "KZT" | "UAH" | "BTC" | "ETH" | "ADA" | "DOT" | "ATOM" | "XRP" | "LTC" | "SOL" | "DOGE" | "MATIC" | "AVAX";
+                            referenceCode: string;
+                            creditorAccount: {
+                                accountNumber: string;
+                                bankCode: string;
+                                creditorName: string;
+                                iban: string;
+                            };
+                            paymentMessage: string;
+                            vs?: string | undefined;
+                            ks?: string | undefined;
+                            ss?: string | undefined;
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 500;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        transactions: {
+            "simulate-deposit": ClientRequest<string, "/v1/transactions/simulate-deposit", {
+                $post: {
+                    input: {
+                        header: {
+                            'X-Idempotency-Key': string;
+                            'X-Signature-Key': string;
+                            'X-Signature': string;
+                        };
+                    } & {
+                        json: {
+                            amount: number;
+                            currency: "CZK" | "EUR" | "USD";
+                            bank: {
+                                vs: string;
+                                ss?: string | undefined;
+                                ks?: string | undefined;
+                                message?: string | undefined;
+                            };
+                            debtorIban: string;
+                            debtorHolderName: string;
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        header: {
+                            'X-Idempotency-Key': string;
+                            'X-Signature-Key': string;
+                            'X-Signature': string;
+                        };
+                    } & {
+                        json: {
+                            amount: number;
+                            currency: "CZK" | "EUR" | "USD";
+                            bank: {
+                                vs: string;
+                                ss?: string | undefined;
+                                ks?: string | undefined;
+                                message?: string | undefined;
+                            };
+                            debtorIban: string;
+                            debtorHolderName: string;
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                } | {
+                    input: {
+                        header: {
+                            'X-Idempotency-Key': string;
+                            'X-Signature-Key': string;
+                            'X-Signature': string;
+                        };
+                    } & {
+                        json: {
+                            amount: number;
+                            currency: "CZK" | "EUR" | "USD";
+                            bank: {
+                                vs: string;
+                                ss?: string | undefined;
+                                ks?: string | undefined;
+                                message?: string | undefined;
+                            };
+                            debtorIban: string;
+                            debtorHolderName: string;
+                        };
+                    };
+                    output: {
+                        message: string;
+                    };
+                    outputFormat: "json";
+                    status: 500;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        users: {
+            ":userId": {
+                verification: {
+                    ":confirmationToken": ClientRequest<string, "/v1/users/:userId/verification/:confirmationToken", {
+                        $patch: {
+                            input: {
+                                param: {
+                                    userId: string;
+                                    confirmationToken: string;
+                                } & {
+                                    userId: string;
+                                    confirmationToken: string;
+                                };
+                                json: {
+                                    password: string;
+                                    captchaToken: string;
+                                };
+                            };
+                            output: Response;
+                            outputFormat: "json";
+                            status: StatusCode;
+                        };
+                    } & {
+                        $get: {
+                            input: {
+                                param: {
+                                    userId: string;
+                                    confirmationToken: string;
+                                } & {
+                                    userId: string;
+                                    confirmationToken: string;
+                                };
+                            };
+                            output: Response;
+                            outputFormat: "json";
+                            status: StatusCode;
+                        };
+                    }>;
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        users: {
+            ":userId": {
+                verification: {
+                    ":confirmationToken": {
+                        success: ClientRequest<string, "/v1/users/:userId/verification/:confirmationToken/success", {
+                            $get: {
+                                input: {
+                                    param: {
+                                        userId: string;
+                                        confirmationToken: string;
+                                    } & {
+                                        [x: string]: string;
+                                        [x: number]: string;
+                                        [x: symbol]: string;
+                                    };
+                                };
+                                output: Response;
+                                outputFormat: "json";
+                                status: StatusCode;
+                            };
+                        }>;
+                    };
+                };
+            };
+        };
+    };
+};
+
+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>;
+
+export { createPartnerApiClient, signPayload, verifyPayloadSignature };